@secondlayer/stacks 0.0.1

package/dist/src/clarity/index.d.cts

@@ -0,0 +1,821 @@
+type ClarityType = "int" | "uint" | "buffer" | "true" | "false" | "address" | "contract" | "ok" | "err" | "none" | "some" | "list" | "tuple" | "ascii" | "utf8";
+/** Wire type IDs matching the Stacks binary format (SIP-005) */
+declare const ClarityWireType: {
+	readonly int: 0x00
+	readonly uint: 0x01
+	readonly buffer: 0x02
+	readonly true: 0x03
+	readonly false: 0x04
+	readonly address: 0x05
+	readonly contract: 0x06
+	readonly ok: 0x07
+	readonly err: 0x08
+	readonly none: 0x09
+	readonly some: 0x0a
+	readonly list: 0x0b
+	readonly tuple: 0x0c
+	readonly ascii: 0x0d
+	readonly utf8: 0x0e
+};
+declare function clarityTypeFromByte(byte: number): ClarityType;
+type IntCV = {
+	readonly type: "int"
+	readonly value: bigint
+};
+type UIntCV = {
+	readonly type: "uint"
+	readonly value: bigint
+};
+type BooleanCV = TrueCV | FalseCV;
+type TrueCV = {
+	readonly type: "true"
+};
+type FalseCV = {
+	readonly type: "false"
+};
+type BufferCV = {
+	readonly type: "buffer"
+	readonly value: string
+};
+type NoneCV = {
+	readonly type: "none"
+};
+type SomeCV = {
+	readonly type: "some"
+	readonly value: ClarityValue
+};
+type OptionalCV = NoneCV | SomeCV;
+type ResponseOkCV = {
+	readonly type: "ok"
+	readonly value: ClarityValue
+};
+type ResponseErrorCV = {
+	readonly type: "err"
+	readonly value: ClarityValue
+};
+type ResponseCV = ResponseOkCV | ResponseErrorCV;
+type StandardPrincipalCV = {
+	readonly type: "address"
+	readonly value: string
+};
+type ContractPrincipalCV = {
+	readonly type: "contract"
+	readonly value: string
+};
+type PrincipalCV = StandardPrincipalCV | ContractPrincipalCV;
+type ListCV = {
+	type: "list"
+	value: ClarityValue[]
+};
+type TupleData = {
+	[key: string]: ClarityValue
+};
+type TupleCV = {
+	type: "tuple"
+	value: TupleData
+};
+type StringAsciiCV = {
+	readonly type: "ascii"
+	readonly value: string
+};
+type StringUtf8CV = {
+	readonly type: "utf8"
+	readonly value: string
+};
+type ClarityValue = IntCV | UIntCV | BooleanCV | BufferCV | NoneCV | SomeCV | ResponseOkCV | ResponseErrorCV | StandardPrincipalCV | ContractPrincipalCV | ListCV | TupleCV | StringAsciiCV | StringUtf8CV;
+type IntegerType = number | string | bigint | Uint8Array;
+declare function intCV(value: IntegerType): IntCV;
+declare function uintCV(value: IntegerType): UIntCV;
+declare const trueCV: () => TrueCV;
+declare const falseCV: () => FalseCV;
+declare const boolCV: (v: boolean) => BooleanCV;
+declare function bufferCV(buffer: Uint8Array): BufferCV;
+declare function standardPrincipalCV(address: string): StandardPrincipalCV;
+declare function contractPrincipalCV(address: string, contractName: string): ContractPrincipalCV;
+declare function noneCV(): NoneCV;
+declare function someCV(value: ClarityValue): SomeCV;
+declare function responseOkCV(value: ClarityValue): ResponseOkCV;
+declare function responseErrorCV(value: ClarityValue): ResponseErrorCV;
+declare function listCV(values: ClarityValue[]): ListCV;
+declare function tupleCV(data: TupleData): TupleCV;
+declare function stringAsciiCV(value: string): StringAsciiCV;
+declare function stringUtf8CV(value: string): StringUtf8CV;
+declare const Cl: {
+	readonly principal: (address: string) => StandardPrincipalCV | ContractPrincipalCV
+	readonly serialize: (value: ClarityValue) => string
+};
+declare function serializeCVBytes(value: ClarityValue): Uint8Array;
+declare function serializeCV(value: ClarityValue): string;
+declare function deserializeCVBytes<T extends ClarityValue = ClarityValue>(input: Uint8Array | string): T;
+declare function deserializeCV<T extends ClarityValue = ClarityValue>(input: Uint8Array | string): T;
+declare function prettyPrint(val: ClarityValue, encoding?: "tryAscii" | "hex"): string | undefined;
+declare function cvToJSON(val: ClarityValue): any;
+declare function cvToValue(val: ClarityValue): any;
+declare const CONTRACT_NAME_REGEX: RegExp;
+type AbiUInt128 = "uint128";
+type AbiInt128 = "int128";
+type AbiBool = "bool";
+type AbiPrincipal = "principal";
+type AbiTraitReference = "trait_reference";
+type AbiNone = "none";
+type AbiStringAscii<L extends number = number> = {
+	"string-ascii": {
+		length: L
+	}
+};
+type AbiStringUtf8<L extends number = number> = {
+	"string-utf8": {
+		length: L
+	}
+};
+type AbiBuffer<L extends number = number> = {
+	buff: {
+		length: L
+	}
+};
+type AbiPrimitiveType = AbiUInt128 | AbiInt128 | AbiBool | AbiPrincipal | AbiTraitReference | AbiNone | AbiStringAscii | AbiStringUtf8 | AbiBuffer;
+interface AbiListType {
+	list: {
+		type: AbiType
+		length: number
+	};
+}
+interface AbiTupleType {
+	tuple: ReadonlyArray<{
+		name: string
+		type: AbiType
+	}>;
+}
+interface AbiOptionalType {
+	optional: AbiType;
+}
+interface AbiResponseType {
+	response: {
+		ok: AbiType
+		error: AbiType
+	};
+}
+/** Discriminated union of all Clarity value types (primitives, buffers, lists, tuples, optionals, responses). */
+type AbiType = AbiPrimitiveType | AbiListType | AbiTupleType | AbiOptionalType | AbiResponseType;
+type AbiList<
+	T extends AbiType = AbiType,
+	L extends number = number
+> = {
+	list: {
+		type: T
+		length: L
+	}
+};
+type AbiTuple<T extends ReadonlyArray<{
+	name: string
+	type: AbiType
+}>> = {
+	tuple: T
+};
+type AbiOptional<T extends AbiType = AbiType> = {
+	optional: T
+};
+type AbiResponse<
+	O extends AbiType = AbiType,
+	E extends AbiType = AbiType
+> = {
+	response: {
+		ok: O
+		error: E
+	}
+};
+type CamelCaseInner<S extends string> = S extends `${infer P1}-${infer P2}${infer P3}` ? `${P1}${Capitalize<CamelCaseInner<`${P2}${P3}`>>}` : S;
+type ToCamelCase<S extends string> = CamelCaseInner<S> extends `${number}${string}` ? `_${CamelCaseInner<S>}` : CamelCaseInner<S>;
+declare function toCamelCase(str: string): string;
+type TupleToObject<T extends ReadonlyArray<{
+	name: string
+	type: AbiType
+}>> = { [K in T[number]["name"] as ToCamelCase<K>] : AbiToTS<Extract<T[number], {
+	name: K
+}>["type"]> };
+type AbiToTS<T extends AbiType> = T extends "none" ? never : T extends "uint128" ? bigint : T extends "int128" ? bigint : T extends "bool" ? boolean : T extends "principal" ? string : T extends "trait_reference" ? string : T extends {
+	"string-ascii": any
+} ? string : T extends {
+	"string-utf8": any
+} ? string : T extends {
+	buff: any
+} ? Uint8Array : T extends {
+	list: {
+		type: infer U extends AbiType
+	}
+} ? Array<AbiToTS<U>> : T extends {
+	optional: infer U extends AbiType
+} ? AbiToTS<U> | null : T extends {
+	response: {
+		ok: infer O extends AbiType
+		error: infer E extends AbiType
+	}
+} ? {
+	ok: AbiToTS<O>
+} | {
+	err: AbiToTS<E>
+} : T extends {
+	tuple: infer Fields extends ReadonlyArray<{
+		name: string
+		type: AbiType
+	}>
+} ? TupleToObject<Fields> : never;
+type ResponseOk<T> = {
+	ok: T
+};
+type ResponseErr<E> = {
+	err: E
+};
+type Response<
+	T,
+	E
+> = ResponseOk<T> | ResponseErr<E>;
+type FunctionAccess = "public" | "read-only" | "private";
+interface FunctionArg {
+	name: string;
+	type: AbiType;
+}
+/** A single Clarity function definition with name, access level, arguments, and return type. */
+interface AbiFunction {
+	name: string;
+	access: FunctionAccess;
+	args: ReadonlyArray<FunctionArg>;
+	outputs: AbiType;
+}
+type VariableAccess = "constant" | "variable";
+interface AbiVariable {
+	name: string;
+	type: AbiType;
+	access: VariableAccess;
+}
+interface AbiMap {
+	name: string;
+	key: AbiType;
+	value: AbiType;
+}
+interface AbiFungibleToken {
+	name: string;
+}
+interface AbiNonFungibleToken {
+	name: string;
+	type: AbiType;
+}
+type TraitFunctionAccess = Exclude<FunctionAccess, "private">;
+interface AbiTraitFunction {
+	name: string;
+	access: TraitFunctionAccess;
+	args: ReadonlyArray<FunctionArg>;
+	outputs: AbiType;
+}
+interface AbiTraitDefinition {
+	name: string;
+	functions: ReadonlyArray<AbiTraitFunction>;
+}
+/** Full Clarity contract ABI including functions, maps, variables, and token definitions. */
+interface AbiContract {
+	functions: ReadonlyArray<AbiFunction>;
+	maps?: ReadonlyArray<AbiMap>;
+	variables?: ReadonlyArray<AbiVariable>;
+	fungible_tokens?: ReadonlyArray<AbiFungibleToken>;
+	non_fungible_tokens?: ReadonlyArray<AbiNonFungibleToken>;
+	implemented_traits?: ReadonlyArray<string>;
+	defined_traits?: ReadonlyArray<AbiTraitDefinition>;
+}
+type ExtractFunctionNames<
+	C extends AbiContract,
+	Access extends FunctionAccess = FunctionAccess
+> = Extract<C["functions"][number], {
+	access: Access
+}>["name"];
+type ExtractFunction<
+	C extends AbiContract,
+	N extends ExtractFunctionNames<C>
+> = Extract<C["functions"][number], {
+	name: N
+}>;
+type ExtractFunctionArgs<
+	C extends AbiContract,
+	N extends ExtractFunctionNames<C>
+> = ExtractFunction<C, N> extends {
+	args: infer Args extends ReadonlyArray<{
+		name: string
+		type: any
+	}>
+} ? { [K in Args[number]["name"] as ToCamelCase<K>] : AbiToTS<Extract<Args[number], {
+	name: K
+}>["type"]> } : never;
+type ExtractFunctionOutput<
+	C extends AbiContract,
+	N extends ExtractFunctionNames<C>
+> = ExtractFunction<C, N> extends {
+	outputs: infer O extends AbiType
+} ? AbiToTS<O> : never;
+type ExtractPublicFunctions<C extends AbiContract> = ExtractFunctionNames<C, "public">;
+type ExtractReadOnlyFunctions<C extends AbiContract> = ExtractFunctionNames<C, "read-only">;
+type ExtractPrivateFunctions<C extends AbiContract> = ExtractFunctionNames<C, "private">;
+type ExtractMapNames<C extends AbiContract> = C["maps"] extends ReadonlyArray<{
+	name: infer N extends string
+}> ? N : never;
+type ExtractMap<
+	C extends AbiContract,
+	N extends ExtractMapNames<C>
+> = C["maps"] extends ReadonlyArray<infer M> ? Extract<M, {
+	name: N
+}> : never;
+type ExtractMapKey<
+	C extends AbiContract,
+	N extends ExtractMapNames<C>
+> = ExtractMap<C, N> extends {
+	key: infer K extends AbiType
+} ? AbiToTS<K> : never;
+type ExtractMapValue<
+	C extends AbiContract,
+	N extends ExtractMapNames<C>
+> = ExtractMap<C, N> extends {
+	value: infer V extends AbiType
+} ? AbiToTS<V> : never;
+type ExtractVariableNames<
+	C extends AbiContract,
+	Access extends VariableAccess = VariableAccess
+> = C["variables"] extends ReadonlyArray<infer V> ? V extends {
+	name: infer N extends string
+	access: Access
+} ? N : never : never;
+type ExtractVariable<
+	C extends AbiContract,
+	N extends ExtractVariableNames<C>
+> = C["variables"] extends ReadonlyArray<infer V> ? Extract<V, {
+	name: N
+}> : never;
+type ExtractVariableType<
+	C extends AbiContract,
+	N extends ExtractVariableNames<C>
+> = ExtractVariable<C, N> extends {
+	type: infer T extends AbiType
+} ? AbiToTS<T> : never;
+type ExtractConstants<C extends AbiContract> = ExtractVariableNames<C, "constant">;
+type ExtractDataVars<C extends AbiContract> = ExtractVariableNames<C, "variable">;
+type ExtractFungibleTokenNames<C extends AbiContract> = C["fungible_tokens"] extends ReadonlyArray<{
+	name: infer N extends string
+}> ? N : never;
+type ExtractNonFungibleTokenNames<C extends AbiContract> = C["non_fungible_tokens"] extends ReadonlyArray<{
+	name: infer N extends string
+}> ? N : never;
+type ExtractNFTAssetType<
+	C extends AbiContract,
+	N extends ExtractNonFungibleTokenNames<C>
+> = C["non_fungible_tokens"] extends ReadonlyArray<infer T> ? Extract<T, {
+	name: N
+}> extends {
+	type: infer A extends AbiType
+} ? AbiToTS<A> : never : never;
+type ExtractDefinedTraitNames<C extends AbiContract> = C["defined_traits"] extends ReadonlyArray<{
+	name: infer N extends string
+}> ? N : never;
+type ExtractImplementedTraits<C extends AbiContract> = C["implemented_traits"] extends ReadonlyArray<infer T extends string> ? T : never;
+declare function isUint128(value: unknown): value is bigint;
+declare function isInt128(value: unknown): value is bigint;
+declare function isBool(value: unknown): value is boolean;
+declare function isPrincipal(value: unknown): value is string;
+declare function isStandardPrincipal(value: unknown): value is string;
+declare function isContractPrincipal(value: unknown): value is string;
+declare function isTraitReference(value: unknown): value is string;
+declare function isString(value: unknown): value is string;
+declare function isUint8Array(value: unknown): value is Uint8Array;
+declare function isArray<T>(value: unknown, itemGuard: (item: unknown) => item is T): value is T[];
+declare function isOptional<T>(value: unknown, guard: (val: unknown) => val is T): value is T | null;
+declare function isOkResponse<T>(response: {
+	ok: T
+} | {
+	err: any
+}): response is ResponseOk<T>;
+declare function isErrResponse<E>(response: {
+	ok: any
+} | {
+	err: E
+}): response is ResponseErr<E>;
+declare function isResponse<
+	T,
+	E
+>(value: unknown, okGuard: (val: unknown) => val is T, errGuard: (val: unknown) => val is E): value is ResponseOk<T> | ResponseErr<E>;
+declare function isAbiList(type: AbiType): type is AbiListType;
+declare function isAbiTuple(type: AbiType): type is AbiTupleType;
+declare function isAbiOptional(type: AbiType): type is AbiOptionalType;
+declare function isAbiResponse(type: AbiType): type is AbiResponseType;
+declare function isAbiBuffer(type: AbiType): type is AbiBuffer;
+declare function isAbiStringAscii(type: AbiType): type is AbiStringAscii;
+declare function isAbiStringUtf8(type: AbiType): type is AbiStringUtf8;
+declare function isAbiTraitReference(type: AbiType): type is AbiTraitReference;
+declare class ClarityConversionError extends Error {
+	readonly type: AbiType;
+	readonly value: unknown;
+	constructor(message: string, type: AbiType, value: unknown);
+}
+declare function jsToClarity(type: AbiType, value: unknown): unknown;
+declare function prepareArgs<F extends AbiFunction>(func: F, args: Record<string, unknown>): unknown[];
+declare function validateArgs<F extends AbiFunction>(func: F, args: Record<string, unknown>): void;
+declare function validateArgsArray<F extends AbiFunction>(func: F, args: unknown[]): void;
+declare const SIP010_ABI: {
+	readonly functions: readonly [{
+		readonly name: "transfer"
+		readonly access: "public"
+		readonly args: readonly [{
+			readonly name: "amount"
+			readonly type: "uint128"
+		}, {
+			readonly name: "sender"
+			readonly type: "principal"
+		}, {
+			readonly name: "recipient"
+			readonly type: "principal"
+		}, {
+			readonly name: "memo"
+			readonly type: {
+				readonly optional: {
+					readonly buff: {
+						readonly length: 34
+					}
+				}
+			}
+		}]
+		readonly outputs: {
+			readonly response: {
+				readonly ok: "bool"
+				readonly error: "uint128"
+			}
+		}
+	}, {
+		readonly name: "get-balance"
+		readonly access: "read-only"
+		readonly args: readonly [{
+			readonly name: "account"
+			readonly type: "principal"
+		}]
+		readonly outputs: {
+			readonly response: {
+				readonly ok: "uint128"
+				readonly error: "uint128"
+			}
+		}
+	}, {
+		readonly name: "get-total-supply"
+		readonly access: "read-only"
+		readonly args: readonly []
+		readonly outputs: {
+			readonly response: {
+				readonly ok: "uint128"
+				readonly error: "uint128"
+			}
+		}
+	}, {
+		readonly name: "get-name"
+		readonly access: "read-only"
+		readonly args: readonly []
+		readonly outputs: {
+			readonly response: {
+				readonly ok: {
+					readonly "string-ascii": {
+						readonly length: 32
+					}
+				}
+				readonly error: "uint128"
+			}
+		}
+	}, {
+		readonly name: "get-symbol"
+		readonly access: "read-only"
+		readonly args: readonly []
+		readonly outputs: {
+			readonly response: {
+				readonly ok: {
+					readonly "string-ascii": {
+						readonly length: 10
+					}
+				}
+				readonly error: "uint128"
+			}
+		}
+	}, {
+		readonly name: "get-decimals"
+		readonly access: "read-only"
+		readonly args: readonly []
+		readonly outputs: {
+			readonly response: {
+				readonly ok: "uint128"
+				readonly error: "uint128"
+			}
+		}
+	}, {
+		readonly name: "get-token-uri"
+		readonly access: "read-only"
+		readonly args: readonly []
+		readonly outputs: {
+			readonly response: {
+				readonly ok: {
+					readonly optional: {
+						readonly "string-utf8": {
+							readonly length: 256
+						}
+					}
+				}
+				readonly error: "uint128"
+			}
+		}
+	}]
+	readonly fungible_tokens: readonly [{
+		readonly name: "token"
+	}]
+};
+declare const SIP009_ABI: {
+	readonly functions: readonly [{
+		readonly name: "transfer"
+		readonly access: "public"
+		readonly args: readonly [{
+			readonly name: "id"
+			readonly type: "uint128"
+		}, {
+			readonly name: "sender"
+			readonly type: "principal"
+		}, {
+			readonly name: "recipient"
+			readonly type: "principal"
+		}]
+		readonly outputs: {
+			readonly response: {
+				readonly ok: "bool"
+				readonly error: "uint128"
+			}
+		}
+	}, {
+		readonly name: "get-owner"
+		readonly access: "read-only"
+		readonly args: readonly [{
+			readonly name: "id"
+			readonly type: "uint128"
+		}]
+		readonly outputs: {
+			readonly response: {
+				readonly ok: {
+					readonly optional: "principal"
+				}
+				readonly error: "uint128"
+			}
+		}
+	}, {
+		readonly name: "get-last-token-id"
+		readonly access: "read-only"
+		readonly args: readonly []
+		readonly outputs: {
+			readonly response: {
+				readonly ok: "uint128"
+				readonly error: "uint128"
+			}
+		}
+	}, {
+		readonly name: "get-token-uri"
+		readonly access: "read-only"
+		readonly args: readonly [{
+			readonly name: "id"
+			readonly type: "uint128"
+		}]
+		readonly outputs: {
+			readonly response: {
+				readonly ok: {
+					readonly optional: {
+						readonly "string-utf8": {
+							readonly length: 256
+						}
+					}
+				}
+				readonly error: "uint128"
+			}
+		}
+	}]
+	readonly non_fungible_tokens: readonly [{
+		readonly name: "nft"
+		readonly type: "uint128"
+	}]
+};
+declare const SIP013_ABI: {
+	readonly functions: readonly [{
+		readonly name: "transfer"
+		readonly access: "public"
+		readonly args: readonly [{
+			readonly name: "token-id"
+			readonly type: "uint128"
+		}, {
+			readonly name: "amount"
+			readonly type: "uint128"
+		}, {
+			readonly name: "sender"
+			readonly type: "principal"
+		}, {
+			readonly name: "recipient"
+			readonly type: "principal"
+		}]
+		readonly outputs: {
+			readonly response: {
+				readonly ok: "bool"
+				readonly error: "uint128"
+			}
+		}
+	}, {
+		readonly name: "transfer-memo"
+		readonly access: "public"
+		readonly args: readonly [{
+			readonly name: "token-id"
+			readonly type: "uint128"
+		}, {
+			readonly name: "amount"
+			readonly type: "uint128"
+		}, {
+			readonly name: "sender"
+			readonly type: "principal"
+		}, {
+			readonly name: "recipient"
+			readonly type: "principal"
+		}, {
+			readonly name: "memo"
+			readonly type: {
+				readonly buff: {
+					readonly length: 34
+				}
+			}
+		}]
+		readonly outputs: {
+			readonly response: {
+				readonly ok: "bool"
+				readonly error: "uint128"
+			}
+		}
+	}, {
+		readonly name: "transfer-many"
+		readonly access: "public"
+		readonly args: readonly [{
+			readonly name: "transfers"
+			readonly type: {
+				readonly list: {
+					readonly type: {
+						readonly tuple: readonly [{
+							readonly name: "token-id"
+							readonly type: "uint128"
+						}, {
+							readonly name: "amount"
+							readonly type: "uint128"
+						}, {
+							readonly name: "sender"
+							readonly type: "principal"
+						}, {
+							readonly name: "recipient"
+							readonly type: "principal"
+						}]
+					}
+					readonly length: 200
+				}
+			}
+		}]
+		readonly outputs: {
+			readonly response: {
+				readonly ok: "bool"
+				readonly error: "uint128"
+			}
+		}
+	}, {
+		readonly name: "transfer-many-memo"
+		readonly access: "public"
+		readonly args: readonly [{
+			readonly name: "transfers"
+			readonly type: {
+				readonly list: {
+					readonly type: {
+						readonly tuple: readonly [{
+							readonly name: "token-id"
+							readonly type: "uint128"
+						}, {
+							readonly name: "amount"
+							readonly type: "uint128"
+						}, {
+							readonly name: "sender"
+							readonly type: "principal"
+						}, {
+							readonly name: "recipient"
+							readonly type: "principal"
+						}, {
+							readonly name: "memo"
+							readonly type: {
+								readonly buff: {
+									readonly length: 34
+								}
+							}
+						}]
+					}
+					readonly length: 200
+				}
+			}
+		}]
+		readonly outputs: {
+			readonly response: {
+				readonly ok: "bool"
+				readonly error: "uint128"
+			}
+		}
+	}, {
+		readonly name: "get-balance"
+		readonly access: "read-only"
+		readonly args: readonly [{
+			readonly name: "token-id"
+			readonly type: "uint128"
+		}, {
+			readonly name: "account"
+			readonly type: "principal"
+		}]
+		readonly outputs: {
+			readonly response: {
+				readonly ok: "uint128"
+				readonly error: "uint128"
+			}
+		}
+	}, {
+		readonly name: "get-overall-balance"
+		readonly access: "read-only"
+		readonly args: readonly [{
+			readonly name: "account"
+			readonly type: "principal"
+		}]
+		readonly outputs: {
+			readonly response: {
+				readonly ok: "uint128"
+				readonly error: "uint128"
+			}
+		}
+	}, {
+		readonly name: "get-total-supply"
+		readonly access: "read-only"
+		readonly args: readonly [{
+			readonly name: "token-id"
+			readonly type: "uint128"
+		}]
+		readonly outputs: {
+			readonly response: {
+				readonly ok: "uint128"
+				readonly error: "uint128"
+			}
+		}
+	}, {
+		readonly name: "get-overall-supply"
+		readonly access: "read-only"
+		readonly args: readonly []
+		readonly outputs: {
+			readonly response: {
+				readonly ok: "uint128"
+				readonly error: "uint128"
+			}
+		}
+	}, {
+		readonly name: "get-decimals"
+		readonly access: "read-only"
+		readonly args: readonly [{
+			readonly name: "token-id"
+			readonly type: "uint128"
+		}]
+		readonly outputs: {
+			readonly response: {
+				readonly ok: "uint128"
+				readonly error: "uint128"
+			}
+		}
+	}, {
+		readonly name: "get-token-uri"
+		readonly access: "read-only"
+		readonly args: readonly [{
+			readonly name: "token-id"
+			readonly type: "uint128"
+		}]
+		readonly outputs: {
+			readonly response: {
+				readonly ok: {
+					readonly optional: {
+						readonly "string-utf8": {
+							readonly length: 256
+						}
+					}
+				}
+				readonly error: "uint128"
+			}
+		}
+	}]
+	readonly fungible_tokens: readonly []
+	readonly non_fungible_tokens: readonly []
+};
+declare const sip010Abi: unknown;
+declare const sip009Abi: unknown;
+declare const sip013Abi: unknown;
+/**
+* Convert a JS value to a ClarityValue using ABI type information.
+*/
+declare function jsToClarityValue(abiType: AbiType, value: unknown): ClarityValue;
+/**
+* Convert a ClarityValue back to a typed JS value using ABI type information.
+*/
+declare function clarityValueToJS<T extends AbiType>(abiType: T, cv: ClarityValue): AbiToTS<T>;
+export { validateArgsArray, validateArgs, uintCV, tupleCV, trueCV, toCamelCase, stringUtf8CV, stringAsciiCV, standardPrincipalCV, someCV, sip013Abi, sip010Abi, sip009Abi, serializeCVBytes, serializeCV, responseOkCV, responseErrorCV, prettyPrint, prepareArgs, noneCV, listCV, jsToClarityValue, jsToClarity, isUint8Array, isUint128, isTraitReference, isString, isStandardPrincipal, isResponse, isPrincipal, isOptional, isOkResponse, isInt128, isErrResponse, isContractPrincipal, isBool, isArray, isAbiTuple, isAbiTraitReference, isAbiStringUtf8, isAbiStringAscii, isAbiResponse, isAbiOptional, isAbiList, isAbiBuffer, intCV, falseCV, deserializeCVBytes, deserializeCV, cvToValue, cvToJSON, contractPrincipalCV, clarityValueToJS, clarityTypeFromByte, bufferCV, boolCV, VariableAccess, UIntCV, TupleData, TupleCV, TrueCV, TraitFunctionAccess, ToCamelCase, StringUtf8CV, StringAsciiCV, StandardPrincipalCV, SomeCV, SIP013_ABI, SIP010_ABI, SIP009_ABI, ResponseOkCV, ResponseOk, ResponseErrorCV, ResponseErr, ResponseCV, Response, PrincipalCV, OptionalCV, NoneCV, ListCV, IntCV, FunctionArg, FunctionAccess, FalseCV, ExtractVariableType, ExtractVariableNames, ExtractVariable, ExtractReadOnlyFunctions, ExtractPublicFunctions, ExtractPrivateFunctions, ExtractNonFungibleTokenNames, ExtractNFTAssetType, ExtractMapValue, ExtractMapNames, ExtractMapKey, ExtractMap, ExtractImplementedTraits, ExtractFungibleTokenNames, ExtractFunctionOutput, ExtractFunctionNames, ExtractFunctionArgs, ExtractFunction, ExtractDefinedTraitNames, ExtractDataVars, ExtractConstants, ContractPrincipalCV, ClarityWireType, ClarityValue, ClarityType, ClarityConversionError, Cl, CONTRACT_NAME_REGEX, BufferCV, BooleanCV, AbiVariable, AbiUInt128, AbiType, AbiTupleType, AbiTuple, AbiTraitReference, AbiTraitFunction, AbiTraitDefinition, AbiToTS, AbiStringUtf8, AbiStringAscii, AbiResponseType, AbiResponse, AbiPrincipal, AbiPrimitiveType, AbiOptionalType, AbiOptional, AbiNone, AbiNonFungibleToken, AbiMap, AbiListType, AbiList, AbiInt128, AbiFungibleToken, AbiFunction, AbiContract, AbiBuffer, AbiBool };