@clarigen/core 4.0.0 → 4.0.2-alpha.0

package/dist/index.d.mts

@@ -1,41 +1,43 @@
-import { ClarityAbi as ClarityAbi$1, PrincipalCV, ClarityValue, ClarityAbiTypeTuple as ClarityAbiTypeTuple$1, ContractPrincipalCV, StacksTransactionWire, NonFungiblePostCondition, FungiblePostCondition } from '@stacks/transactions';
-import { StacksNetwork, StacksNetworkName } from '@stacks/network';
+import { h as SimnetDeploymentPlan, o as DeploymentPlan } from "./deployment-bCip1x1p.mjs";
+import { ClarityAbi as ClarityAbi$1, ClarityAbiTypeTuple as ClarityAbiTypeTuple$1, ClarityValue, ContractPrincipalCV, FungiblePostCondition, NonFungiblePostCondition, PrincipalCV, StacksTransactionWire } from "@stacks/transactions";
+import { StacksNetwork, StacksNetworkName } from "@stacks/network";
 
+//#region src/abi-types.d.ts
 type ClarityAbiTypeBuffer = {
-    buffer: {
-        length: number;
-    };
+  buffer: {
+    length: number;
+  };
 };
 type ClarityAbiTypeStringAscii = {
-    'string-ascii': {
-        length: number;
-    };
+  'string-ascii': {
+    length: number;
+  };
 };
 type ClarityAbiTypeStringUtf8 = {
-    'string-utf8': {
-        length: number;
-    };
+  'string-utf8': {
+    length: number;
+  };
 };
 type ClarityAbiTypeResponse = {
-    response: {
-        ok: ClarityAbiType;
-        error: ClarityAbiType;
-    };
+  response: {
+    ok: ClarityAbiType;
+    error: ClarityAbiType;
+  };
 };
 type ClarityAbiTypeOptional = {
-    optional: ClarityAbiType;
+  optional: ClarityAbiType;
 };
 type ClarityAbiTypeTuple = {
-    tuple: readonly {
-        name: string;
-        type: ClarityAbiType;
-    }[];
+  tuple: readonly {
+    name: string;
+    type: ClarityAbiType;
+  }[];
 };
 type ClarityAbiTypeList = {
-    list: {
-        type: ClarityAbiType;
-        length: number;
-    };
+  list: {
+    type: ClarityAbiType;
+    length: number;
+  };
 };
 type ClarityAbiTypeUInt128 = 'uint128';
 type ClarityAbiTypeInt128 = 'int128';
@@ -46,88 +48,89 @@ type ClarityAbiTypeNone = 'none';
 type ClarityAbiTypePrimitive = ClarityAbiTypeUInt128 | ClarityAbiTypeInt128 | ClarityAbiTypeBool | ClarityAbiTypePrincipal | ClarityAbiTypeTraitReference | ClarityAbiTypeNone;
 type ClarityAbiType = ClarityAbiTypePrimitive | ClarityAbiTypeBuffer | ClarityAbiTypeResponse | ClarityAbiTypeOptional | ClarityAbiTypeTuple | ClarityAbiTypeList | ClarityAbiTypeStringAscii | ClarityAbiTypeStringUtf8 | ClarityAbiTypeTraitReference;
 interface ClarityAbiArg {
-    name: string;
-    type: ClarityAbiType;
+  name: string;
+  type: ClarityAbiType;
 }
 interface ClarityAbiFunction {
-    name: string;
-    access: 'private' | 'public' | 'read_only';
-    args: ClarityAbiArg[];
-    outputs: {
-        type: ClarityAbiType;
-    };
-}
-type TypedAbiArg<T, N extends string> = {
-    _t?: T;
-    name: N;
+  name: string;
+  access: 'private' | 'public' | 'read_only';
+  args: ClarityAbiArg[];
+  outputs: {
+    type: ClarityAbiType;
+  };
+}
+type TypedAbiArg<T, N$1 extends string> = {
+  _t?: T;
+  name: N$1;
 };
-type TypedAbiFunction<T extends TypedAbiArg<unknown, string>[], R> = ClarityAbiFunction & {
-    _t?: T;
-    _r?: R;
+type TypedAbiFunction<T extends TypedAbiArg<unknown, string>[], R$1> = ClarityAbiFunction & {
+  _t?: T;
+  _r?: R$1;
 };
 interface ClarityAbiVariable {
-    name: string;
-    access: 'variable' | 'constant';
-    type: ClarityAbiType;
+  name: string;
+  access: 'variable' | 'constant';
+  type: ClarityAbiType;
 }
 type TypedAbiVariable<T> = ClarityAbiVariable & {};
 interface ClarityAbiMap {
-    name: string;
-    key: ClarityAbiType;
-    value: ClarityAbiType;
+  name: string;
+  key: ClarityAbiType;
+  value: ClarityAbiType;
 }
-type TypedAbiMap<K, V> = ClarityAbiMap & {
-    _k?: K;
-    _v?: V;
+type TypedAbiMap<K$1, V$1> = ClarityAbiMap & {
+  _k?: K$1;
+  _v?: V$1;
 };
 interface ClarityAbiTypeFungibleToken {
-    name: string;
+  name: string;
 }
 interface ClarityAbiTypeNonFungibleToken<T = unknown> {
-    name: string;
-    type: ClarityAbiType;
-    _t?: T;
+  name: string;
+  type: ClarityAbiType;
+  _t?: T;
 }
 type StacksEpochId = 'Epoch10' | 'Epoch20' | 'Epoch2_05' | 'Epoch21' | 'Epoch22' | 'Epoch23' | 'Epoch24' | 'Epoch25' | 'Epoch30' | 'Epoch31' | 'Epoch32' | 'Epoch33';
 type ClarityVersion = 'Clarity1' | 'Clarity2' | 'Clarity3' | 'Clarity4';
 type TypedAbi = Readonly<{
-    functions: {
-        [key: string]: TypedAbiFunction<TypedAbiArg<unknown, string>[], unknown>;
-    };
-    variables: {
-        [key: string]: TypedAbiVariable<unknown>;
-    };
-    maps: {
-        [key: string]: TypedAbiMap<unknown, unknown>;
-    };
-    constants: {
-        [key: string]: unknown;
-    };
-    fungible_tokens: Readonly<ClarityAbiTypeFungibleToken[]>;
-    non_fungible_tokens: Readonly<ClarityAbiTypeNonFungibleToken<unknown>[]>;
-    contractName: string;
-    contractFile?: string;
+  functions: {
+    [key: string]: TypedAbiFunction<TypedAbiArg<unknown, string>[], unknown>;
+  };
+  variables: {
+    [key: string]: TypedAbiVariable<unknown>;
+  };
+  maps: {
+    [key: string]: TypedAbiMap<unknown, unknown>;
+  };
+  constants: {
+    [key: string]: unknown;
+  };
+  fungible_tokens: Readonly<ClarityAbiTypeFungibleToken[]>;
+  non_fungible_tokens: Readonly<ClarityAbiTypeNonFungibleToken<unknown>[]>;
+  contractName: string;
+  contractFile?: string;
 }>;
 interface ResponseOk<T, E> {
-    value: T;
-    isOk: true;
-    _e?: E;
+  value: T;
+  isOk: true;
+  _e?: E;
 }
 interface ResponseErr<T, E> {
-    value: E;
-    isOk: false;
-    _o?: T;
+  value: E;
+  isOk: false;
+  _o?: T;
 }
 type Response<Ok, Err> = ResponseOk<Ok, Err> | ResponseErr<Ok, Err>;
-type OkType<R> = R extends ResponseOk<infer V, unknown> ? V : never;
-type ErrType<R> = R extends ResponseErr<unknown, infer V> ? V : never;
-
+type OkType<R$1> = R$1 extends ResponseOk<infer V, unknown> ? V : never;
+type ErrType<R$1> = R$1 extends ResponseErr<unknown, infer V> ? V : never;
+//#endregion
+//#region src/clarity-types.d.ts
 declare function ok<T, Err = never>(value: T): ResponseOk<T, Err>;
 declare function err<Ok = never, T = unknown>(value: T): ResponseErr<Ok, T>;
 declare function isResponse<T>(value: Response<T, T> | T): value is Response<T, T>;
 interface ClarityAbi extends ClarityAbi$1 {
-    epoch: StacksEpochId;
-    clarity_version: ClarityVersion;
+  epoch: StacksEpochId;
+  clarity_version: ClarityVersion;
 }
 declare function principalToString(principal: PrincipalCV): string;
 /**
@@ -171,106 +174,88 @@ declare function expectOk<Ok>(response: Response<Ok, any>): Ok;
 declare function expectErr<Err>(response: Response<any, Err>): Err;
 type AbiPrimitiveTo<T extends ClarityAbiTypePrimitive> = T extends ClarityAbiTypeInt128 ? bigint : T extends ClarityAbiTypeUInt128 ? bigint : T extends ClarityAbiTypeBool ? boolean : T extends ClarityAbiTypePrincipal ? string : T extends ClarityAbiTypeTraitReference ? string : T extends ClarityAbiTypeNone ? never : T;
 type ReadonlyTuple = {
-    readonly tuple: Readonly<ClarityAbiTypeTuple$1['tuple']>;
-};
-type TupleTypeUnion<T> = T extends Readonly<ClarityAbiTypeTuple$1['tuple'][number]> ? {
-    -readonly [Z in T['name']]: AbiTypeTo<T['type']>;
-} : never;
-type UnionToIntersection$1<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-type Compact$1<T> = {
-    [K in keyof T]: T[K];
+  readonly tuple: Readonly<ClarityAbiTypeTuple$1['tuple']>;
 };
+type TupleTypeUnion<T> = T extends Readonly<ClarityAbiTypeTuple$1['tuple'][number]> ? { -readonly [Z in T['name']]: AbiTypeTo<T['type']> } : never;
+type UnionToIntersection$1<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type Compact$1<T> = { [K in keyof T]: T[K] };
 type AbiTupleTo<T extends ReadonlyTuple> = Compact$1<UnionToIntersection$1<TupleTypeUnion<T['tuple'][number]>>>;
 type AbiTypeTo<T extends ClarityAbiType | ReadonlyTuple> = T extends ClarityAbiTypePrimitive ? AbiPrimitiveTo<T> : T extends ClarityAbiTypeBuffer ? Uint8Array : T extends ClarityAbiTypeStringAscii ? string : T extends ClarityAbiTypeStringUtf8 ? string : T extends ClarityAbiTypeList ? AbiTypeTo<T['list']['type']>[] : T extends ClarityAbiTypeOptional ? AbiTypeTo<T['optional']> | null : T extends ClarityAbiTypeResponse ? Response<AbiTypeTo<T['response']['ok']>, AbiTypeTo<T['response']['error']>> : T extends ReadonlyTuple ? AbiTupleTo<T> : never;
 type FunctionReturnType<T> = T extends TypedAbiFunction<TypedAbiArg<unknown, string>[], infer R> ? R : never;
-type Jsonize<T> = T extends BigInt ? string : T extends Uint8Array ? string : T extends (infer V)[] ? Jsonize<V>[] : T extends Record<keyof T, unknown> ? {
-    [K in keyof T as K]: Jsonize<T[K]>;
-} : T;
+type Jsonize<T> = T extends BigInt ? string : T extends Uint8Array ? string : T extends (infer V)[] ? Jsonize<V>[] : T extends Record<keyof T, unknown> ? { [K in keyof T as K]: Jsonize<T[K]> } : T;
 declare function getTypeString(val: ClarityAbiType): string;
-
+//#endregion
+//#region src/transaction.d.ts
 interface ResultAssets {
-    stx: Record<string, string>;
-    burns: Record<string, string>;
-    tokens: Record<string, Record<string, string>>;
-    assets: Record<string, Record<string, string>>;
+  stx: Record<string, string>;
+  burns: Record<string, string>;
+  tokens: Record<string, Record<string, string>>;
+  assets: Record<string, Record<string, string>>;
 }
-
+//#endregion
+//#region src/factory-types.d.ts
 interface ContractCall<T> {
-    function: ClarityAbiFunction;
-    nativeArgs: any[];
-    functionArgs: ClarityValue[];
-    contractAddress: string;
-    contractName: string;
-    functionName: string;
-    _r?: T;
+  function: ClarityAbiFunction;
+  nativeArgs: any[];
+  functionArgs: ClarityValue[];
+  contractAddress: string;
+  contractName: string;
+  functionName: string;
+  _r?: T;
 }
-interface ContractCallTyped<Args extends UnknownArgs, R> extends Omit<ContractCall<R>, 'nativeArgs'> {
-    nativeArgs: ArgsType<Args>;
+interface ContractCallTyped<Args$1 extends UnknownArgs, R$1> extends Omit<ContractCall<R$1>, 'nativeArgs'> {
+  nativeArgs: ArgsType<Args$1>;
 }
 type ContractFunctions = {
-    [key: string]: TypedAbiFunction<UnknownArgs, unknown>;
+  [key: string]: TypedAbiFunction<UnknownArgs, unknown>;
 };
 type AllContracts = Record<string, TypedAbi>;
 type UnknownArg = TypedAbiArg<unknown, string>;
 type UnknownArgs = UnknownArg[];
-type ArgsTuple<T extends UnknownArgs> = {
-    [K in keyof T]: T[K] extends TypedAbiArg<infer A, string> ? A : never;
-};
-type ArgsRecordUnion<T extends TypedAbiArg<unknown, string>> = T extends TypedAbiArg<infer A, infer N> ? {
-    [K in T as N]: A;
-} : never;
-type InnerUnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-type Compact<T> = {
-    [K in keyof T]: T[K];
-};
+type ArgsTuple<T extends UnknownArgs> = { [K in keyof T]: T[K] extends TypedAbiArg<infer A, string> ? A : never };
+type ArgsRecordUnion<T extends TypedAbiArg<unknown, string>> = T extends TypedAbiArg<infer A, infer N> ? { [K in T as N]: A } : never;
+type InnerUnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type Compact<T> = { [K in keyof T]: T[K] };
 type UnionToIntersection<T> = Compact<InnerUnionToIntersection<T>>;
 type ArgsRecord<T extends UnknownArgs> = UnionToIntersection<ArgsRecordUnion<T[number]>>;
 type ArgsType<T extends UnknownArgs> = [ArgsRecord<T>] | ArgsTuple<T>;
-type ContractCallFunction<Args extends UnknownArgs, R> = {
-    (...args: ArgsType<Args>): ContractCallTyped<Args, R>;
-    abi: TypedAbiFunction<Args, R>;
+type ContractCallFunction<Args$1 extends UnknownArgs, R$1> = {
+  (...args: ArgsType<Args$1>): ContractCallTyped<Args$1, R$1>;
+  abi: TypedAbiFunction<Args$1, R$1>;
 };
 type FnToContractCall<T> = T extends TypedAbiFunction<infer Arg, infer R> ? ContractCallFunction<Arg, R> : never;
-type FunctionsToContractCalls<T> = T extends ContractFunctions ? {
-    [key in keyof T]: FnToContractCall<T[key]>;
-} : never;
-type ContractsToContractCalls<T> = T extends AllContracts ? {
-    [key in keyof T]: FunctionsToContractCalls<T[key]['functions']>;
-} : never;
+type FunctionsToContractCalls<T> = T extends ContractFunctions ? { [key in keyof T]: FnToContractCall<T[key]> } : never;
+type ContractsToContractCalls<T> = T extends AllContracts ? { [key in keyof T]: FunctionsToContractCalls<T[key]['functions']> } : never;
 type FullContract<T> = T extends TypedAbi ? FunctionsToContractCalls<T['functions']> & T & {
-    identifier: string;
+  identifier: string;
 } & {
-    contractFile: string;
+  contractFile: string;
 } : never;
-type ContractFactory<T extends AllContracts> = {
-    [key in keyof T]: FullContract<T[key]>;
-};
-
-type Kebab<T extends string, A extends string = ''> = T extends `${infer F}${infer R}` ? Kebab<R, `${A}${F extends Lowercase<F> ? '' : '-'}${Lowercase<F>}`> : A;
-type KebabObject<T> = T extends Uint8Array ? T : T extends Record<string, unknown> ? {
-    [K in keyof T as K extends string ? Kebab<K> : K]: KebabObject<T[K]>;
-} : T;
-type ExtractArgs<F> = F extends TypedAbiFunction<infer Args, unknown> ? ArgsTuple<Args> : never;
-type ExtractArgsRecord<F> = F extends TypedAbiFunction<infer Args, unknown> ? ArgsRecord<Args> : never;
+type ContractFactory<T extends AllContracts> = { [key in keyof T]: FullContract<T[key]> };
+//#endregion
+//#region src/types.d.ts
+type Kebab<T extends string, A$1 extends string = ''> = T extends `${infer F}${infer R}` ? Kebab<R, `${A$1}${F extends Lowercase<F> ? '' : '-'}${Lowercase<F>}`> : A$1;
+type KebabObject<T> = T extends Uint8Array ? T : T extends Record<string, unknown> ? { [K in keyof T as K extends string ? Kebab<K> : K]: KebabObject<T[K]> } : T;
+type ExtractArgs<F$1> = F$1 extends TypedAbiFunction<infer Args, unknown> ? ArgsTuple<Args> : never;
+type ExtractArgsRecord<F$1> = F$1 extends TypedAbiFunction<infer Args, unknown> ? ArgsRecord<Args> : never;
 type ContractBuilder<T> = (contractAddress: string, contractName: string) => T;
 interface Contract<T> {
-    address: string;
-    contractFile: string;
-    contract: ContractBuilder<T>;
-    abi: ClarityAbi;
-    name: string;
+  address: string;
+  contractFile: string;
+  contract: ContractBuilder<T>;
+  abi: ClarityAbi;
+  name: string;
 }
 interface Contracts<T> {
-    [key: string]: Contract<T>;
+  [key: string]: Contract<T>;
 }
 interface ContractInstance<T> {
-    identifier: string;
-    contract: T;
+  identifier: string;
+  contract: T;
 }
-type ContractInstances<T extends Contracts<any>> = {
-    [Name in keyof T]: ContractInstance<ReturnType<T[Name]['contract']>>;
-};
-
+type ContractInstances<T extends Contracts<any>> = { [Name in keyof T]: ContractInstance<ReturnType<T[Name]['contract']>> };
+//#endregion
+//#region src/utils.d.ts
 declare const TESTNET_BURN_ADDRESS = "ST000000000000000000002AMW42H";
 declare const MAINNET_BURN_ADDRESS = "SP000000000000000000002Q6VF78";
 declare const toCamelCase: (input: string | number | symbol, titleCase?: boolean) => string;
@@ -284,150 +269,147 @@ declare function bytesToHex(bytes: Uint8Array): string;
 declare function hexToBytes(hexString: string): Uint8Array;
 declare function bytesToAscii(bytes: Uint8Array): string;
 declare const isNumber: (value: number | string) => value is number;
-type ErrorKeyCheck<K> = K extends string ? Lowercase<K> extends `err${string}` ? K : never : never;
-type ErrorCodes<C extends TypedAbi['constants']> = {
-    [K in keyof C as ErrorKeyCheck<K>]: C[K] extends {
-        isOk: boolean;
-        value: infer V;
-    } ? V : C[K];
-};
+type ErrorKeyCheck<K$1> = K$1 extends string ? Lowercase<K$1> extends `err${string}` ? K$1 : never : never;
+type ErrorCodes<C extends TypedAbi['constants']> = { [K in keyof C as ErrorKeyCheck<K>]: C[K] extends {
+  isOk: boolean;
+  value: infer V;
+} ? V : C[K] };
 type ProjectErrors<T extends {
-    contracts: AllContracts;
-}> = {
-    [K in keyof T['contracts']]: ErrorCodes<T['contracts'][K]['constants']>;
-};
+  contracts: AllContracts;
+}> = { [K in keyof T['contracts']]: ErrorCodes<T['contracts'][K]['constants']> };
 declare function extractErrors<T extends TypedAbi>(contract: T): ErrorCodes<T['constants']>;
 declare function projectErrors<T extends {
-    contracts: AllContracts;
+  contracts: AllContracts;
 }>(project: T): ProjectErrors<T>;
-
+//#endregion
+//#region src/events.d.ts
 declare enum CoreNodeEventType {
-    ContractEvent = "contract_event",
-    StxTransferEvent = "stx_transfer_event",
-    StxMintEvent = "stx_mint_event",
-    StxBurnEvent = "stx_burn_event",
-    StxLockEvent = "stx_lock_event",
-    NftTransferEvent = "nft_transfer_event",
-    NftMintEvent = "nft_mint_event",
-    NftBurnEvent = "nft_burn_event",
-    FtTransferEvent = "ft_transfer_event",
-    FtMintEvent = "ft_mint_event",
-    FtBurnEvent = "ft_burn_event"
+  ContractEvent = "contract_event",
+  StxTransferEvent = "stx_transfer_event",
+  StxMintEvent = "stx_mint_event",
+  StxBurnEvent = "stx_burn_event",
+  StxLockEvent = "stx_lock_event",
+  NftTransferEvent = "nft_transfer_event",
+  NftMintEvent = "nft_mint_event",
+  NftBurnEvent = "nft_burn_event",
+  FtTransferEvent = "ft_transfer_event",
+  FtMintEvent = "ft_mint_event",
+  FtBurnEvent = "ft_burn_event",
 }
 type NonStandardClarityValue = unknown;
 interface CoreNodeEventBase {
-    /** 0x-prefix transaction hash. */
-    txid: string;
-    event_index: number;
-    committed: boolean;
+  /** 0x-prefix transaction hash. */
+  txid: string;
+  event_index: number;
+  committed: boolean;
 }
 interface SmartContractEvent extends CoreNodeEventBase {
-    type: CoreNodeEventType.ContractEvent;
-    contract_event: {
-        /** Fully qualified contract ID, e.g. "ST2ZRX0K27GW0SP3GJCEMHD95TQGJMKB7G9Y0X1MH.kv-store" */
-        contract_identifier: string;
-        topic: string;
-        value: NonStandardClarityValue;
-        /** Hex encoded Clarity value. */
-        raw_value: string;
-    };
+  type: CoreNodeEventType.ContractEvent;
+  contract_event: {
+    /** Fully qualified contract ID, e.g. "ST2ZRX0K27GW0SP3GJCEMHD95TQGJMKB7G9Y0X1MH.kv-store" */
+    contract_identifier: string;
+    topic: string;
+    value: NonStandardClarityValue;
+    /** Hex encoded Clarity value. */
+    raw_value: string;
+  };
 }
 interface StxTransferEvent extends CoreNodeEventBase {
-    type: CoreNodeEventType.StxTransferEvent;
-    stx_transfer_event: {
-        recipient: string;
-        sender: string;
-        amount: string;
-    };
+  type: CoreNodeEventType.StxTransferEvent;
+  stx_transfer_event: {
+    recipient: string;
+    sender: string;
+    amount: string;
+  };
 }
 interface StxMintEvent extends CoreNodeEventBase {
-    type: CoreNodeEventType.StxMintEvent;
-    stx_mint_event: {
-        recipient: string;
-        amount: string;
-    };
+  type: CoreNodeEventType.StxMintEvent;
+  stx_mint_event: {
+    recipient: string;
+    amount: string;
+  };
 }
 interface StxBurnEvent extends CoreNodeEventBase {
-    type: CoreNodeEventType.StxBurnEvent;
-    stx_burn_event: {
-        sender: string;
-        amount: string;
-    };
+  type: CoreNodeEventType.StxBurnEvent;
+  stx_burn_event: {
+    sender: string;
+    amount: string;
+  };
 }
 interface StxLockEvent extends CoreNodeEventBase {
-    type: CoreNodeEventType.StxLockEvent;
-    /** TODO: what dis? */
-    committed: boolean;
-    stx_lock_event: {
-        /** String quoted base10 integer. */
-        locked_amount: string;
-        /** String quoted base10 integer. */
-        unlock_height: string;
-        /** STX principal associated with the locked tokens. */
-        locked_address: string;
-    };
+  type: CoreNodeEventType.StxLockEvent;
+  /** TODO: what dis? */
+  committed: boolean;
+  stx_lock_event: {
+    /** String quoted base10 integer. */
+    locked_amount: string;
+    /** String quoted base10 integer. */
+    unlock_height: string;
+    /** STX principal associated with the locked tokens. */
+    locked_address: string;
+  };
 }
 interface NftTransferEvent extends CoreNodeEventBase {
-    type: CoreNodeEventType.NftTransferEvent;
-    nft_transfer_event: {
-        /** Fully qualified asset ID, e.g. "ST2ZRX0K27GW0SP3GJCEMHD95TQGJMKB7G9Y0X1MH.contract-name.asset-name" */
-        asset_identifier: string;
-        recipient: string;
-        sender: string;
-        value: NonStandardClarityValue;
-        /** Hex encoded Clarity value. */
-        raw_value: string;
-    };
+  type: CoreNodeEventType.NftTransferEvent;
+  nft_transfer_event: {
+    /** Fully qualified asset ID, e.g. "ST2ZRX0K27GW0SP3GJCEMHD95TQGJMKB7G9Y0X1MH.contract-name.asset-name" */
+    asset_identifier: string;
+    recipient: string;
+    sender: string;
+    value: NonStandardClarityValue;
+    /** Hex encoded Clarity value. */
+    raw_value: string;
+  };
 }
 interface NftMintEvent extends CoreNodeEventBase {
-    type: CoreNodeEventType.NftMintEvent;
-    nft_mint_event: {
-        /** Fully qualified asset ID, e.g. "ST2ZRX0K27GW0SP3GJCEMHD95TQGJMKB7G9Y0X1MH.contract-name.asset-name" */
-        asset_identifier: string;
-        recipient: string;
-        value: NonStandardClarityValue;
-        /** Hex encoded Clarity value. */
-        raw_value: string;
-    };
+  type: CoreNodeEventType.NftMintEvent;
+  nft_mint_event: {
+    /** Fully qualified asset ID, e.g. "ST2ZRX0K27GW0SP3GJCEMHD95TQGJMKB7G9Y0X1MH.contract-name.asset-name" */
+    asset_identifier: string;
+    recipient: string;
+    value: NonStandardClarityValue;
+    /** Hex encoded Clarity value. */
+    raw_value: string;
+  };
 }
 interface NftBurnEvent extends CoreNodeEventBase {
-    type: CoreNodeEventType.NftBurnEvent;
-    nft_burn_event: {
-        /** Fully qualified asset ID, e.g. "ST2ZRX0K27GW0SP3GJCEMHD95TQGJMKB7G9Y0X1MH.contract-name.asset-name" */
-        asset_identifier: string;
-        sender: string;
-        value: NonStandardClarityValue;
-        /** Hex encoded Clarity value. */
-        raw_value: string;
-    };
+  type: CoreNodeEventType.NftBurnEvent;
+  nft_burn_event: {
+    /** Fully qualified asset ID, e.g. "ST2ZRX0K27GW0SP3GJCEMHD95TQGJMKB7G9Y0X1MH.contract-name.asset-name" */
+    asset_identifier: string;
+    sender: string;
+    value: NonStandardClarityValue;
+    /** Hex encoded Clarity value. */
+    raw_value: string;
+  };
 }
 interface FtTransferEvent extends CoreNodeEventBase {
-    type: CoreNodeEventType.FtTransferEvent;
-    ft_transfer_event: {
-        /** Fully qualified asset ID, e.g. "ST2ZRX0K27GW0SP3GJCEMHD95TQGJMKB7G9Y0X1MH.contract-name.asset-name" */
-        asset_identifier: string;
-        recipient: string;
-        sender: string;
-        amount: string;
-    };
+  type: CoreNodeEventType.FtTransferEvent;
+  ft_transfer_event: {
+    /** Fully qualified asset ID, e.g. "ST2ZRX0K27GW0SP3GJCEMHD95TQGJMKB7G9Y0X1MH.contract-name.asset-name" */
+    asset_identifier: string;
+    recipient: string;
+    sender: string;
+    amount: string;
+  };
 }
 interface FtMintEvent extends CoreNodeEventBase {
-    type: CoreNodeEventType.FtMintEvent;
-    ft_mint_event: {
-        /** Fully qualified asset ID, e.g. "ST2ZRX0K27GW0SP3GJCEMHD95TQGJMKB7G9Y0X1MH.contract-name.asset-name" */
-        asset_identifier: string;
-        recipient: string;
-        amount: string;
-    };
+  type: CoreNodeEventType.FtMintEvent;
+  ft_mint_event: {
+    /** Fully qualified asset ID, e.g. "ST2ZRX0K27GW0SP3GJCEMHD95TQGJMKB7G9Y0X1MH.contract-name.asset-name" */
+    asset_identifier: string;
+    recipient: string;
+    amount: string;
+  };
 }
 interface FtBurnEvent extends CoreNodeEventBase {
-    type: CoreNodeEventType.FtBurnEvent;
-    ft_burn_event: {
-        /** Fully qualified asset ID, e.g. "ST2ZRX0K27GW0SP3GJCEMHD95TQGJMKB7G9Y0X1MH.contract-name.asset-name" */
-        asset_identifier: string;
-        sender: string;
-        amount: string;
-    };
+  type: CoreNodeEventType.FtBurnEvent;
+  ft_burn_event: {
+    /** Fully qualified asset ID, e.g. "ST2ZRX0K27GW0SP3GJCEMHD95TQGJMKB7G9Y0X1MH.contract-name.asset-name" */
+    asset_identifier: string;
+    sender: string;
+    amount: string;
+  };
 }
 type CoreNodeEvent = SmartContractEvent | StxTransferEvent | StxMintEvent | StxBurnEvent | StxLockEvent | FtTransferEvent | FtMintEvent | FtBurnEvent | NftTransferEvent | NftMintEvent | NftBurnEvent;
 declare function filterEvents(events: CoreNodeEvent[], type: CoreNodeEventType.ContractEvent): SmartContractEvent[];
@@ -441,188 +423,102 @@ declare function filterEvents(events: CoreNodeEvent[], type: CoreNodeEventType.N
 declare function filterEvents(events: CoreNodeEvent[], type: CoreNodeEventType.FtTransferEvent): FtTransferEvent[];
 declare function filterEvents(events: CoreNodeEvent[], type: CoreNodeEventType.FtMintEvent): FtMintEvent[];
 declare function filterEvents(events: CoreNodeEvent[], type: CoreNodeEventType.FtBurnEvent): FtBurnEvent[];
-
+//#endregion
+//#region src/contracts.d.ts
 interface MakeContractsOptions {
-    deployerAddress?: string;
+  deployerAddress?: string;
 }
 declare function makeContracts<T extends Contracts<any>>(contracts: T, options?: MakeContractsOptions): ContractInstances<T>;
-
+//#endregion
+//#region src/pure/index.d.ts
 interface PureContractInfo {
-    abi: ClarityAbi;
-    contractAddress: string;
-    contractName: string;
+  abi: ClarityAbi;
+  contractAddress: string;
+  contractName: string;
 }
 type ContractFn<T> = (args: any) => T;
 type ContractReturn<C extends ContractFn<ContractCalls.ReadOnly<any>>> = C extends ContractFn<ContractCalls.ReadOnly<infer T>> ? T : unknown;
 type ContractReturnOk<C extends ContractFn<ContractCalls.ReadOnly<any>>> = ContractReturn<C> extends Response<infer O, any> ? O : unknown;
 type ContractReturnErr<C extends ContractFn<ContractCalls.ReadOnly<any>>> = ContractReturn<C> extends Response<any, infer E> ? E : unknown;
 interface MapGet<Key, Val> {
-    map: ClarityAbiMap;
-    nativeKey: Key;
-    key: ClarityValue;
-    contractAddress: string;
-    contractName: string;
+  map: ClarityAbiMap;
+  nativeKey: Key;
+  key: ClarityValue;
+  contractAddress: string;
+  contractName: string;
 }
 declare namespace ContractCalls {
-    type ReadOnly<T> = ContractCall<T>;
-    type Public<Ok, Err> = ContractCall<Response<Ok, Err>>;
-    type Private<T> = ContractCall<T>;
-    type Map<Key, Val> = MapGet<Key, Val>;
+  type ReadOnly<T> = ContractCall<T>;
+  type Public<Ok, Err> = ContractCall<Response<Ok, Err>>;
+  type Private<T> = ContractCall<T>;
+  type Map<Key, Val> = MapGet<Key, Val>;
 }
 declare const pureProxy: <T extends object>(target: PureContractInfo) => T;
-
+//#endregion
+//#region src/api/index.d.ts
 interface ApiOptionsUrl {
-    url: string;
-    network?: undefined;
+  url: string;
+  network?: undefined;
 }
 type Network = StacksNetwork | StacksNetworkName;
 interface ApiOptionsNetwork {
-    network: StacksNetworkName | StacksNetwork;
-    url?: undefined;
+  network: StacksNetworkName | StacksNetwork;
+  url?: undefined;
 }
 type ApiOptionsBase = {
-    network: StacksNetwork | StacksNetworkName;
-    tip?: string;
-    latest?: boolean;
-    apiKey?: string;
+  network: StacksNetwork | StacksNetworkName;
+  tip?: string;
+  latest?: boolean;
+  apiKey?: string;
+  headers?: Record<string, string>;
 };
 type ApiOptionsJsonize = ApiOptionsBase & {
-    json: true;
+  json: true;
 };
 type ApiOptionsNoJson = ApiOptionsBase & {
-    json?: false | undefined;
+  json?: false | undefined;
 };
 type ApiOptions = ApiOptionsBase & {
-    json?: boolean;
+  json?: boolean;
 };
-type JsonIfOption<O extends ApiOptions, R> = O extends ApiOptionsJsonize ? Jsonize<R> : R;
+type JsonIfOption<O extends ApiOptions, R$1> = O extends ApiOptionsJsonize ? Jsonize<R$1> : R$1;
 declare function ro<O extends ApiOptions, T>(tx: ContractCall<T>, options: O): Promise<JsonIfOption<O, T>>;
 declare function roOk<O extends ApiOptions, Ok>(tx: ContractCall<Response<Ok, any>>, options: O): Promise<JsonIfOption<O, Ok>>;
 declare function roErr<O extends ApiOptions, Err>(tx: ContractCall<Response<any, Err>>, options: O): Promise<JsonIfOption<O, Err>>;
 declare function getApiUrl(opts: ApiOptions): string;
 declare function fetchMapGet<Key, Val>(contractId: string, map: TypedAbiMap<Key, Val>, key: Key, options: ApiOptions): Promise<Val | null>;
 declare function broadcast(transaction: StacksTransactionWire, options: ApiOptions): Promise<{
-    txId: string;
-    stacksTransaction: StacksTransactionWire;
+  txId: string;
+  stacksTransaction: StacksTransactionWire;
 }>;
 type ClientOptions = Omit<ApiOptions, 'network'>;
 type JsonIf<O extends ClientOptions, T> = JsonIfOption<O & ApiOptions, T>;
 declare class ClarigenClient {
-    network: StacksNetwork | StacksNetworkName;
-    apiKey?: string;
-    constructor(networkOrUrl: StacksNetwork | StacksNetworkName, apiKey?: string);
-    private roOptions;
-    ro<T, O extends ClientOptions>(tx: ContractCall<T>, options?: O): Promise<JsonIf<O, T>>;
-    roOk<T, O extends ClientOptions>(tx: ContractCall<Response<T, any>>, options?: O): Promise<JsonIf<O, T>>;
-    roErr<T, O extends ClientOptions>(tx: ContractCall<Response<any, T>>, options?: O): Promise<JsonIf<O, T>>;
-}
-
-interface EmulatedContractPublishTransaction {
-    'emulated-contract-publish': {
-        'contract-name': string;
-        'emulated-sender': string;
-        path: string;
-    };
-}
-interface RequirementPublishTransaction {
-    'requirement-publish': {
-        'contract-id': string;
-        'remap-sender': string;
-        'remap-principals': Record<string, string>;
-        path: string;
-    };
-}
-interface ContractPublishTransaction {
-    'contract-publish': {
-        'contract-name': string;
-        'expected-sender': string;
-        path: string;
-    };
-}
-interface ContractCallTransaction {
-    'contract-call': {
-        'contract-id': string;
-        'expected-sender': string;
-        parameters: Readonly<string[]>;
-        method: string;
-    };
-}
-interface EmulatedContractCallTransaction {
-    'emulated-contract-call': {
-        'contract-id': string;
-        'emulated-sender': string;
-        parameters: Readonly<string[]>;
-        method: string;
-    };
-}
-interface BtcTransferTransaction {
-    'btc-transfer': {
-        'expected-sender': string;
-        recipient: string;
-        'sats-per-byte': string;
-        'sats-amount': string;
-    };
-}
-type Transaction = EmulatedContractPublishTransaction | RequirementPublishTransaction | ContractPublishTransaction | EmulatedContractCallTransaction | BtcTransferTransaction | ContractCallTransaction;
-interface Batch<T extends Transaction> {
-    id: number;
-    transactions: Readonly<T[]>;
-}
-interface SimnetAccount {
-    address: string;
-    name: string;
-    balance: string;
-}
-interface SimnetAccountDeployer extends SimnetAccount {
-    name: 'deployer';
-}
-interface SimnetDeploymentPlan {
-    network: 'simnet';
-    genesis: {
-        wallets: Readonly<[SimnetAccountDeployer, ...SimnetAccount[]]>;
-        contracts: Readonly<string[]>;
-    };
-    plan: {
-        batches: Readonly<Batch<EmulatedContractPublishTransaction | EmulatedContractCallTransaction>[]>;
-    };
-}
-interface DevnetDeploymentPlan {
-    network: 'devnet';
-    plan: {
-        batches: Readonly<Batch<RequirementPublishTransaction | ContractPublishTransaction | ContractCallTransaction | BtcTransferTransaction>[]>;
-    };
-}
-type TestnetDeploymentPlan = Omit<DevnetDeploymentPlan, 'network'> & {
-    network: 'testnet';
-};
-interface MainnetDeploymentPlan {
-    network: 'mainnet';
-    plan: {
-        batches: Readonly<Batch<ContractPublishTransaction | ContractCallTransaction | BtcTransferTransaction>[]>;
-    };
-}
-type DeploymentPlan = SimnetDeploymentPlan | DevnetDeploymentPlan | TestnetDeploymentPlan | MainnetDeploymentPlan;
-
+  apiKey?: string | undefined;
+  headers?: Record<string, string> | undefined;
+  network: StacksNetwork | StacksNetworkName;
+  constructor(networkOrUrl: StacksNetwork | StacksNetworkName, apiKey?: string | undefined, headers?: Record<string, string> | undefined);
+  private roOptions;
+  ro<T, O extends ClientOptions>(tx: ContractCall<T>, options?: O): Promise<JsonIf<O, T>>;
+  roOk<T, O extends ClientOptions>(tx: ContractCall<Response<T, any>>, options?: O): Promise<JsonIf<O, T>>;
+  roErr<T, O extends ClientOptions>(tx: ContractCall<Response<any, T>>, options?: O): Promise<JsonIf<O, T>>;
+}
+//#endregion
+//#region src/factory.d.ts
 declare const DEPLOYMENT_NETWORKS: readonly ["devnet", "simnet", "testnet", "mainnet"];
 type DeploymentNetwork = (typeof DEPLOYMENT_NETWORKS)[number];
-type DeploymentsForContracts<C extends AllContracts> = {
-    [K in keyof C]: ContractDeployments;
-};
-type ContractDeployments = {
-    [key in DeploymentNetwork]: string | null;
-};
+type DeploymentsForContracts<C extends AllContracts> = { [K in keyof C]: ContractDeployments };
+type ContractDeployments = { [key in DeploymentNetwork]: string | null };
 type Project<C extends AllContracts, D extends DeploymentsForContracts<C>> = {
-    contracts: C;
-    deployments: D;
+  contracts: C;
+  deployments: D;
 };
 type FullContractWithIdentifier<C extends TypedAbi, Id extends string> = FullContract<C> & {
-    identifier: Id;
+  identifier: Id;
 };
 type IsDeploymentNetwork<T> = T extends DeploymentNetwork ? DeploymentNetwork extends T ? true : false : never;
-type ProjectFactory<P extends Project<any, any>, N extends DeploymentNetwork> = {
-    [ContractName in keyof P['contracts']]: FullContractWithIdentifier<P['contracts'][ContractName], IsDeploymentNetwork<N> extends true ? '' : NonNullable<P['deployments'][ContractName][N]>>;
-};
-declare function projectFactory<P extends Project<C, D>, N extends DeploymentNetwork, C extends AllContracts, D extends DeploymentsForContracts<C>>(project: P, network: N): ProjectFactory<P, N>;
+type ProjectFactory<P extends Project<any, any>, N$1 extends DeploymentNetwork> = { [ContractName in keyof P['contracts']]: FullContractWithIdentifier<P['contracts'][ContractName], IsDeploymentNetwork<N$1> extends true ? '' : NonNullable<P['deployments'][ContractName][N$1]>> };
+declare function projectFactory<P extends Project<C, D>, N$1 extends DeploymentNetwork, C extends AllContracts, D extends DeploymentsForContracts<C>>(project: P, network: N$1): ProjectFactory<P, N$1>;
 declare function contractsFactory<T extends AllContracts>(contracts: T, deployer: string): ContractFactory<T>;
 declare function functionsFactory<T extends ContractFunctions>(functions: T, identifier: string): FunctionsToContractCalls<T>;
 /**
@@ -635,25 +531,27 @@ declare function functionsFactory<T extends ContractFunctions>(functions: T, ide
  */
 declare function contractFactory<T extends TypedAbi, Id extends string>(abi: T, identifier: Id): FullContractWithIdentifier<T, Id>;
 declare function deploymentFactory<T extends AllContracts>(contracts: T, deployer: DeploymentPlan): ContractFactory<T>;
-type MapFactory<M extends TypedAbiMap<K, V>, K, V> = {
-    key: K;
-    _v?: V;
-    keyCV: ClarityValue;
-    map: M;
+type MapFactory<M extends TypedAbiMap<K$1, V$1>, K$1, V$1> = {
+  key: K$1;
+  _v?: V$1;
+  keyCV: ClarityValue;
+  map: M;
 };
 declare function mapFactory<Key, Val>(map: TypedAbiMap<Key, Val>, key: Key): MapFactory<TypedAbiMap<Key, Val>, Key, Val>;
-
+//#endregion
+//#region src/post-conditions.d.ts
 type AbiWithAssets = Pick<FullContract<TypedAbi>, 'non_fungible_tokens' | 'fungible_tokens' | 'identifier'>;
 type AssetNames<T extends AbiWithAssets> = T['non_fungible_tokens'][number]['name'] | T['fungible_tokens'][number]['name'];
 declare function createAssetInfo<T extends AbiWithAssets>(contract: T, asset: AssetNames<T>): `${string}.${string}::${string}`;
 type NftAssetType<T extends AbiWithAssets> = T['non_fungible_tokens'][0] extends {
-    type: infer Type;
+  type: infer Type;
 } ? Type extends ClarityAbiType | ReadonlyTuple ? AbiTypeTo<Type> : never : never;
 declare function makeNonFungiblePostCondition<T extends AbiWithAssets>(contract: T, sender: string, condition: 'sent' | 'not-sent', value: NftAssetType<T>): NonFungiblePostCondition;
 declare function makeFungiblePostCondition<T extends AbiWithAssets>(contract: T, sender: string, condition: 'eq' | 'gt' | 'gte' | 'lt' | 'lte', amount: number | bigint | string): FungiblePostCondition;
-
-type RawClarityTypeTo<T extends ClarityAbiType, A = any> = T extends ClarityAbiTypePrimitive ? AbiPrimitiveTo<T> : A;
-type ResponseType<F extends TypedAbiFunction<UnknownArgs, any>> = F extends TypedAbiFunction<infer A, infer R> ? R : never;
+//#endregion
+//#region src/raw-clarity.d.ts
+type RawClarityTypeTo<T extends ClarityAbiType, A$1 = any> = T extends ClarityAbiTypePrimitive ? AbiPrimitiveTo<T> : A$1;
+type ResponseType<F$1 extends TypedAbiFunction<UnknownArgs, any>> = F$1 extends TypedAbiFunction<infer A, infer R> ? R : never;
 declare function rawClarityToValue<T = any>(input: string, type: ClarityAbiType): T;
-
-export { type AbiPrimitiveTo, type AbiTupleTo, type AbiTypeTo, type AllContracts, type ApiOptions, type ApiOptionsBase, type ApiOptionsJsonize, type ApiOptionsNetwork, type ApiOptionsNoJson, type ApiOptionsUrl, type ArgsRecord, type ArgsTuple, type ArgsType, type AssetNames, type CVInput, ClarigenClient, type ClarityAbi, type ClarityAbiArg, type ClarityAbiFunction, type ClarityAbiMap, type ClarityAbiType, type ClarityAbiTypeBool, type ClarityAbiTypeBuffer, type ClarityAbiTypeFungibleToken, type ClarityAbiTypeInt128, type ClarityAbiTypeList, type ClarityAbiTypeNonFungibleToken, type ClarityAbiTypeNone, type ClarityAbiTypeOptional, type ClarityAbiTypePrimitive, type ClarityAbiTypePrincipal, type ClarityAbiTypeResponse, type ClarityAbiTypeStringAscii, type ClarityAbiTypeStringUtf8, type ClarityAbiTypeTraitReference, type ClarityAbiTypeTuple, type ClarityAbiTypeUInt128, type ClarityAbiVariable, type ClarityVersion, type Contract, type ContractBuilder, type ContractCall, type ContractCallFunction, type ContractCallTyped, ContractCalls, type ContractDeployments, type ContractFactory, type ContractFn, type ContractFunctions, type ContractInstance, type ContractInstances, type ContractReturn, type ContractReturnErr, type ContractReturnOk, type Contracts, type ContractsToContractCalls, type CoreNodeEvent, type CoreNodeEventBase, CoreNodeEventType, DEPLOYMENT_NETWORKS, type DeploymentNetwork, type DeploymentPlan, type DeploymentsForContracts, type ErrType, type ErrorCodes, type ExtractArgs, type ExtractArgsRecord, type FnToContractCall, type FtBurnEvent, type FtMintEvent, type FtTransferEvent, type FullContract, type FullContractWithIdentifier, type FunctionReturnType, type FunctionsToContractCalls, type JsonIfOption, type Jsonize, type Kebab, type KebabObject, MAINNET_BURN_ADDRESS, type MapFactory, type Network, type NftAssetType, type NftBurnEvent, type NftMintEvent, type NftTransferEvent, type NonStandardClarityValue, type OkType, type Project, type ProjectErrors, type ProjectFactory, type RawClarityTypeTo, type ReadonlyTuple, type Response, type ResponseErr, type ResponseOk, type ResponseType, type ResultAssets, type SimnetDeploymentPlan, type SmartContractEvent, type StacksEpochId, type StxBurnEvent, type StxLockEvent, type StxMintEvent, type StxTransferEvent, TESTNET_BURN_ADDRESS, type TupleInput, type TypedAbi, type TypedAbiArg, type TypedAbiFunction, type TypedAbiMap, type TypedAbiVariable, type UnionToIntersection, type UnknownArg, type UnknownArgs, bootContractIdentifier, broadcast, bytesToAscii, bytesToHex, contractFactory, contractsFactory, createAssetInfo, cvToJSON, cvToString, cvToValue, deploymentFactory, err, expectErr, expectOk, extractErrors, fetchMapGet, filterEvents, findJsTupleKey, functionsFactory, getApiUrl, getContractIdentifier, getContractName, getContractNameFromPath, getContractPrincipalCV, getTypeString, hexToBytes, hexToCvValue, isClarityAbiBuffer, isClarityAbiList, isClarityAbiOptional, isClarityAbiPrimitive, isClarityAbiResponse, isClarityAbiStringAscii, isClarityAbiStringUtf8, isClarityAbiTraitReference, isClarityAbiTuple, isNumber, isResponse, makeContracts, makeFungiblePostCondition, makeNonFungiblePostCondition, mapFactory, ok, parseToCV, principalToString, projectErrors, projectFactory, pureProxy, rawClarityToValue, ro, roErr, roOk, toCamelCase, toKebabCase, transformArgsArray, transformArgsToCV, transformObjectArgs };
+//#endregion
+export { AbiPrimitiveTo, AbiTupleTo, AbiTypeTo, AllContracts, ApiOptions, ApiOptionsBase, ApiOptionsJsonize, ApiOptionsNetwork, ApiOptionsNoJson, ApiOptionsUrl, ArgsRecord, ArgsTuple, ArgsType, AssetNames, CVInput, ClarigenClient, type ClarityAbi, ClarityAbiArg, ClarityAbiFunction, ClarityAbiMap, ClarityAbiType, ClarityAbiTypeBool, ClarityAbiTypeBuffer, ClarityAbiTypeFungibleToken, ClarityAbiTypeInt128, ClarityAbiTypeList, ClarityAbiTypeNonFungibleToken, ClarityAbiTypeNone, ClarityAbiTypeOptional, ClarityAbiTypePrimitive, ClarityAbiTypePrincipal, ClarityAbiTypeResponse, ClarityAbiTypeStringAscii, ClarityAbiTypeStringUtf8, ClarityAbiTypeTraitReference, ClarityAbiTypeTuple, ClarityAbiTypeUInt128, ClarityAbiVariable, ClarityVersion, Contract, ContractBuilder, ContractCall, ContractCallFunction, ContractCallTyped, type ContractCalls, ContractDeployments, ContractFactory, type ContractFn, ContractFunctions, ContractInstance, ContractInstances, type ContractReturn, type ContractReturnErr, type ContractReturnOk, Contracts, ContractsToContractCalls, CoreNodeEvent, CoreNodeEventBase, CoreNodeEventType, DEPLOYMENT_NETWORKS, DeploymentNetwork, type DeploymentPlan, DeploymentsForContracts, ErrType, ErrorCodes, ExtractArgs, ExtractArgsRecord, FnToContractCall, FtBurnEvent, FtMintEvent, FtTransferEvent, FullContract, FullContractWithIdentifier, FunctionReturnType, FunctionsToContractCalls, JsonIfOption, Jsonize, Kebab, KebabObject, MAINNET_BURN_ADDRESS, MapFactory, Network, NftAssetType, NftBurnEvent, NftMintEvent, NftTransferEvent, NonStandardClarityValue, OkType, Project, ProjectErrors, ProjectFactory, RawClarityTypeTo, ReadonlyTuple, Response, ResponseErr, ResponseOk, ResponseType, ResultAssets, type SimnetDeploymentPlan, SmartContractEvent, StacksEpochId, StxBurnEvent, StxLockEvent, StxMintEvent, StxTransferEvent, TESTNET_BURN_ADDRESS, TupleInput, TypedAbi, TypedAbiArg, TypedAbiFunction, TypedAbiMap, TypedAbiVariable, UnionToIntersection, UnknownArg, UnknownArgs, bootContractIdentifier, broadcast, bytesToAscii, bytesToHex, contractFactory, contractsFactory, createAssetInfo, cvToJSON, cvToString, cvToValue, deploymentFactory, err, expectErr, expectOk, extractErrors, fetchMapGet, filterEvents, findJsTupleKey, functionsFactory, getApiUrl, getContractIdentifier, getContractName, getContractNameFromPath, getContractPrincipalCV, getTypeString, hexToBytes, hexToCvValue, isClarityAbiBuffer, isClarityAbiList, isClarityAbiOptional, isClarityAbiPrimitive, isClarityAbiResponse, isClarityAbiStringAscii, isClarityAbiStringUtf8, isClarityAbiTraitReference, isClarityAbiTuple, isNumber, isResponse, makeContracts, makeFungiblePostCondition, makeNonFungiblePostCondition, mapFactory, ok, parseToCV, principalToString, projectErrors, projectFactory, pureProxy, rawClarityToValue, ro, roErr, roOk, toCamelCase, toKebabCase, transformArgsArray, transformArgsToCV, transformObjectArgs };