@clarigen/core 4.0.1 → 4.0.2-alpha.0

package/dist/index.d.cts

@@ -0,0 +1,557 @@
+import { h as SimnetDeploymentPlan, o as DeploymentPlan } from "./deployment-B3q-81ej.cjs";
+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;
+  };
+};
+type ClarityAbiTypeStringAscii = {
+  'string-ascii': {
+    length: number;
+  };
+};
+type ClarityAbiTypeStringUtf8 = {
+  'string-utf8': {
+    length: number;
+  };
+};
+type ClarityAbiTypeResponse = {
+  response: {
+    ok: ClarityAbiType;
+    error: ClarityAbiType;
+  };
+};
+type ClarityAbiTypeOptional = {
+  optional: ClarityAbiType;
+};
+type ClarityAbiTypeTuple = {
+  tuple: readonly {
+    name: string;
+    type: ClarityAbiType;
+  }[];
+};
+type ClarityAbiTypeList = {
+  list: {
+    type: ClarityAbiType;
+    length: number;
+  };
+};
+type ClarityAbiTypeUInt128 = 'uint128';
+type ClarityAbiTypeInt128 = 'int128';
+type ClarityAbiTypeBool = 'bool';
+type ClarityAbiTypePrincipal = 'principal';
+type ClarityAbiTypeTraitReference = 'trait_reference';
+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;
+}
+interface ClarityAbiFunction {
+  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$1> = ClarityAbiFunction & {
+  _t?: T;
+  _r?: R$1;
+};
+interface ClarityAbiVariable {
+  name: string;
+  access: 'variable' | 'constant';
+  type: ClarityAbiType;
+}
+type TypedAbiVariable<T> = ClarityAbiVariable & {};
+interface ClarityAbiMap {
+  name: string;
+  key: ClarityAbiType;
+  value: ClarityAbiType;
+}
+type TypedAbiMap<K$1, V$1> = ClarityAbiMap & {
+  _k?: K$1;
+  _v?: V$1;
+};
+interface ClarityAbiTypeFungibleToken {
+  name: string;
+}
+interface ClarityAbiTypeNonFungibleToken<T = unknown> {
+  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;
+}>;
+interface ResponseOk<T, E> {
+  value: T;
+  isOk: true;
+  _e?: E;
+}
+interface ResponseErr<T, E> {
+  value: E;
+  isOk: false;
+  _o?: T;
+}
+type Response<Ok, Err> = ResponseOk<Ok, Err> | ResponseErr<Ok, Err>;
+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;
+}
+declare function principalToString(principal: PrincipalCV): string;
+/**
+ * @param val - ClarityValue
+ * @param returnResponse - if true, this will return a "response" object.
+ * Otherwise, it returns the inner value of the response (whether ok or err)
+ */
+declare function cvToValue<T = any>(val: ClarityValue, returnResponse?: boolean): T;
+/**
+ * Converts a hex encoded string to the javascript clarity value object {type: string; value: any}
+ * @param hex - the hex encoded string with or without `0x` prefix
+ * @param jsonCompat - enable to serialize bigints to strings
+ */
+declare function hexToCvValue<T>(hex: string, jsonCompat?: boolean): any;
+type TupleInput = Record<string, any>;
+type CVInput = string | boolean | TupleInput | number | bigint;
+declare const isClarityAbiPrimitive: (val: ClarityAbiType) => val is ClarityAbiTypePrimitive;
+declare const isClarityAbiBuffer: (val: ClarityAbiType) => val is ClarityAbiTypeBuffer;
+declare const isClarityAbiStringAscii: (val: ClarityAbiType) => val is ClarityAbiTypeStringAscii;
+declare const isClarityAbiStringUtf8: (val: ClarityAbiType) => val is ClarityAbiTypeStringUtf8;
+declare const isClarityAbiResponse: (val: ClarityAbiType) => val is ClarityAbiTypeResponse;
+declare const isClarityAbiOptional: (val: ClarityAbiType) => val is ClarityAbiTypeOptional;
+declare const isClarityAbiTuple: (val: ClarityAbiType) => val is ClarityAbiTypeTuple$1;
+declare const isClarityAbiList: (val: ClarityAbiType) => val is ClarityAbiTypeList;
+declare const isClarityAbiTraitReference: (val: ClarityAbiType) => val is "trait_reference";
+declare function parseToCV(input: CVInput, type: ClarityAbiType): ClarityValue;
+declare function cvToString(val: ClarityValue, encoding?: 'tryAscii' | 'hex'): string;
+/**
+ * Convert a Clarity value to valid JSON. This does this same thing as
+ * `cvToValue`, except that integers are returned as strings, and buffers
+ * are returned as hex-encoded strings.
+ *
+ * @param val - ClarityValue
+ */
+declare function cvToJSON<T = any>(val: ClarityValue, returnResponse?: boolean): T;
+declare function transformObjectArgs(func: ClarityAbiFunction, args: Record<string, any>): ClarityValue[];
+declare function transformArgsArray(func: ClarityAbiFunction, args: any[]): ClarityValue[];
+declare function transformArgsToCV(func: ClarityAbiFunction, args: any[] | [Record<string, any>]): ClarityValue[];
+declare function findJsTupleKey(key: string, input: Record<string, any>): string;
+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] };
+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;
+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>>;
+}
+//#endregion
+//#region src/factory-types.d.ts
+interface ContractCall<T> {
+  function: ClarityAbiFunction;
+  nativeArgs: any[];
+  functionArgs: ClarityValue[];
+  contractAddress: string;
+  contractName: string;
+  functionName: string;
+  _r?: T;
+}
+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>;
+};
+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 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$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 FullContract<T> = T extends TypedAbi ? FunctionsToContractCalls<T['functions']> & T & {
+  identifier: string;
+} & {
+  contractFile: string;
+} : 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;
+}
+interface Contracts<T> {
+  [key: string]: Contract<T>;
+}
+interface ContractInstance<T> {
+  identifier: string;
+  contract: T;
+}
+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;
+declare function toKebabCase(input: string): string;
+declare function getContractName(identifier: string, camelCase?: boolean): string;
+declare const getContractNameFromPath: (path: string) => string;
+declare const getContractIdentifier: <T>(contract: Contract<T>) => string;
+declare const getContractPrincipalCV: <T>(contract: Contract<T>) => ContractPrincipalCV;
+declare function bootContractIdentifier(name: string, mainnet: boolean): string;
+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$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']> };
+declare function extractErrors<T extends TypedAbi>(contract: T): ErrorCodes<T['constants']>;
+declare function projectErrors<T extends {
+  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",
+}
+type NonStandardClarityValue = unknown;
+interface CoreNodeEventBase {
+  /** 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;
+  };
+}
+interface StxTransferEvent extends CoreNodeEventBase {
+  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;
+  };
+}
+interface StxBurnEvent extends CoreNodeEventBase {
+  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;
+  };
+}
+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;
+  };
+}
+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;
+  };
+}
+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;
+  };
+}
+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;
+  };
+}
+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;
+  };
+}
+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 CoreNodeEvent = SmartContractEvent | StxTransferEvent | StxMintEvent | StxBurnEvent | StxLockEvent | FtTransferEvent | FtMintEvent | FtBurnEvent | NftTransferEvent | NftMintEvent | NftBurnEvent;
+declare function filterEvents(events: CoreNodeEvent[], type: CoreNodeEventType.ContractEvent): SmartContractEvent[];
+declare function filterEvents(events: CoreNodeEvent[], type: CoreNodeEventType.StxTransferEvent): StxTransferEvent[];
+declare function filterEvents(events: CoreNodeEvent[], type: CoreNodeEventType.StxMintEvent): StxMintEvent[];
+declare function filterEvents(events: CoreNodeEvent[], type: CoreNodeEventType.StxBurnEvent): StxBurnEvent[];
+declare function filterEvents(events: CoreNodeEvent[], type: CoreNodeEventType.StxLockEvent): StxLockEvent[];
+declare function filterEvents(events: CoreNodeEvent[], type: CoreNodeEventType.NftTransferEvent): NftTransferEvent[];
+declare function filterEvents(events: CoreNodeEvent[], type: CoreNodeEventType.NftMintEvent): NftMintEvent[];
+declare function filterEvents(events: CoreNodeEvent[], type: CoreNodeEventType.NftBurnEvent): NftBurnEvent[];
+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;
+}
+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;
+}
+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;
+}
+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>;
+}
+declare const pureProxy: <T extends object>(target: PureContractInfo) => T;
+//#endregion
+//#region src/api/index.d.ts
+interface ApiOptionsUrl {
+  url: string;
+  network?: undefined;
+}
+type Network = StacksNetwork | StacksNetworkName;
+interface ApiOptionsNetwork {
+  network: StacksNetworkName | StacksNetwork;
+  url?: undefined;
+}
+type ApiOptionsBase = {
+  network: StacksNetwork | StacksNetworkName;
+  tip?: string;
+  latest?: boolean;
+  apiKey?: string;
+  headers?: Record<string, string>;
+};
+type ApiOptionsJsonize = ApiOptionsBase & {
+  json: true;
+};
+type ApiOptionsNoJson = ApiOptionsBase & {
+  json?: false | undefined;
+};
+type ApiOptions = ApiOptionsBase & {
+  json?: boolean;
+};
+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;
+}>;
+type ClientOptions = Omit<ApiOptions, 'network'>;
+type JsonIf<O extends ClientOptions, T> = JsonIfOption<O & ApiOptions, T>;
+declare class ClarigenClient {
+  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 Project<C extends AllContracts, D extends DeploymentsForContracts<C>> = {
+  contracts: C;
+  deployments: D;
+};
+type FullContractWithIdentifier<C extends TypedAbi, Id extends string> = FullContract<C> & {
+  identifier: Id;
+};
+type IsDeploymentNetwork<T> = T extends DeploymentNetwork ? DeploymentNetwork extends T ? true : false : never;
+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>;
+/**
+ * Provide a contract's types and it's contract identifier to generate
+ * a full contract object with all functions available.
+ *
+ * @param abi - The Clarigen-generated contract types
+ * @param identifier - The contract's identifier, like `SP000000000000000000002Q6VF78.bns`
+ * @returns
+ */
+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$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 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;
+//#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;
+//#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 };