@haneullabs/payment-kit 0.1.0

package/dist/cjs/contracts/payment_kit/config.d.ts

@@ -0,0 +1,14 @@
+import { MoveEnum } from '../utils/index.js';
+export declare const Value: MoveEnum<{
+    U64: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    Address: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    String: import("@haneullabs/haneul/bcs").BcsType<string, string, "string">;
+    AsciiString: import("@haneullabs/haneul/bcs").BcsType<string, string, "string">;
+    Bool: import("@haneullabs/haneul/bcs").BcsType<boolean, boolean, "bool">;
+    Bytes: import("@haneullabs/haneul/bcs").BcsType<number[], Iterable<number> & {
+        length: number;
+    }, string>;
+    Type: import("../utils/index.js").MoveStruct<{
+        name: import("@haneullabs/haneul/bcs").BcsType<string, string, "string">;
+    }, "std::type_name::TypeName">;
+}, "@haneullabs/payment-kit::config::Value">;

package/dist/cjs/contracts/payment_kit/config.js

@@ -0,0 +1,50 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var config_exports = {};
+__export(config_exports, {
+  Value: () => Value
+});
+module.exports = __toCommonJS(config_exports);
+var import_utils = require("../utils/index.js");
+var import_bcs = require("@haneullabs/haneul/bcs");
+var type_name = __toESM(require("./deps/std/type_name.js"));
+const $moduleName = "@haneullabs/payment-kit::config";
+const Value = new import_utils.MoveEnum({
+  name: `${$moduleName}::Value`,
+  fields: {
+    U64: import_bcs.bcs.u64(),
+    Address: import_bcs.bcs.Address,
+    String: import_bcs.bcs.string(),
+    AsciiString: import_bcs.bcs.string(),
+    Bool: import_bcs.bcs.bool(),
+    Bytes: import_bcs.bcs.vector(import_bcs.bcs.u8()),
+    Type: type_name.TypeName
+  }
+});
+//# sourceMappingURL=config.js.map

package/dist/cjs/contracts/payment_kit/config.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/contracts/payment_kit/config.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\nimport { MoveEnum } from '../utils/index.js';\nimport { bcs } from '@haneullabs/haneul/bcs';\nimport * as type_name from './deps/std/type_name.js';\nconst $moduleName = '@haneullabs/payment-kit::config';\nexport const Value = new MoveEnum({\n\tname: `${$moduleName}::Value`,\n\tfields: {\n\t\tU64: bcs.u64(),\n\t\tAddress: bcs.Address,\n\t\tString: bcs.string(),\n\t\tAsciiString: bcs.string(),\n\t\tBool: bcs.bool(),\n\t\tBytes: bcs.vector(bcs.u8()),\n\t\tType: type_name.TypeName,\n\t},\n});\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,mBAAyB;AACzB,iBAAoB;AACpB,gBAA2B;AAC3B,MAAM,cAAc;AACb,MAAM,QAAQ,IAAI,sBAAS;AAAA,EACjC,MAAM,GAAG,WAAW;AAAA,EACpB,QAAQ;AAAA,IACP,KAAK,eAAI,IAAI;AAAA,IACb,SAAS,eAAI;AAAA,IACb,QAAQ,eAAI,OAAO;AAAA,IACnB,aAAa,eAAI,OAAO;AAAA,IACxB,MAAM,eAAI,KAAK;AAAA,IACf,OAAO,eAAI,OAAO,eAAI,GAAG,CAAC;AAAA,IAC1B,MAAM,UAAU;AAAA,EACjB;AACD,CAAC;",
+  "names": []
+}

package/dist/cjs/contracts/payment_kit/deps/std/type_name.d.ts

@@ -0,0 +1,14 @@
+/** Functionality for converting Move types into values. Use with care! */
+import { MoveStruct } from '../../../utils/index.js';
+export declare const TypeName: MoveStruct<{
+    /**
+     * String representation of the type. All types are represented using their source
+     * syntax: "u8", "u64", "bool", "address", "vector", and so on for primitive types.
+     * Struct types are represented as fully qualified type names; e.g.
+     * `00000000000000000000000000000001::string::String` or
+     * `0000000000000000000000000000000a::module_name1::type_name1<0000000000000000000000000000000a::module_name2::type_name2<u64>>`
+     * Addresses are hex-encoded lowercase values of length ADDRESS_LENGTH (16, 20, or
+     * 32 depending on the Move platform)
+     */
+    name: import("@haneullabs/haneul/bcs").BcsType<string, string, "string">;
+}, "std::type_name::TypeName">;

package/dist/cjs/contracts/payment_kit/deps/std/type_name.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var type_name_exports = {};
+__export(type_name_exports, {
+  TypeName: () => TypeName
+});
+module.exports = __toCommonJS(type_name_exports);
+var import_utils = require("../../../utils/index.js");
+var import_bcs = require("@haneullabs/haneul/bcs");
+const $moduleName = "std::type_name";
+const TypeName = new import_utils.MoveStruct({
+  name: `${$moduleName}::TypeName`,
+  fields: {
+    /**
+     * String representation of the type. All types are represented using their source
+     * syntax: "u8", "u64", "bool", "address", "vector", and so on for primitive types.
+     * Struct types are represented as fully qualified type names; e.g.
+     * `00000000000000000000000000000001::string::String` or
+     * `0000000000000000000000000000000a::module_name1::type_name1<0000000000000000000000000000000a::module_name2::type_name2<u64>>`
+     * Addresses are hex-encoded lowercase values of length ADDRESS_LENGTH (16, 20, or
+     * 32 depending on the Move platform)
+     */
+    name: import_bcs.bcs.string()
+  }
+});
+//# sourceMappingURL=type_name.js.map

package/dist/cjs/contracts/payment_kit/deps/std/type_name.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/contracts/payment_kit/deps/std/type_name.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\n/** Functionality for converting Move types into values. Use with care! */\n\nimport { MoveStruct } from '../../../utils/index.js';\nimport { bcs } from '@haneullabs/haneul/bcs';\nconst $moduleName = 'std::type_name';\nexport const TypeName = new MoveStruct({\n\tname: `${$moduleName}::TypeName`,\n\tfields: {\n\t\t/**\n\t\t * String representation of the type. All types are represented using their source\n\t\t * syntax: \"u8\", \"u64\", \"bool\", \"address\", \"vector\", and so on for primitive types.\n\t\t * Struct types are represented as fully qualified type names; e.g.\n\t\t * `00000000000000000000000000000001::string::String` or\n\t\t * `0000000000000000000000000000000a::module_name1::type_name1<0000000000000000000000000000000a::module_name2::type_name2<u64>>`\n\t\t * Addresses are hex-encoded lowercase values of length ADDRESS_LENGTH (16, 20, or\n\t\t * 32 depending on the Move platform)\n\t\t */\n\t\tname: bcs.string(),\n\t},\n});\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,mBAA2B;AAC3B,iBAAoB;AACpB,MAAM,cAAc;AACb,MAAM,WAAW,IAAI,wBAAW;AAAA,EACtC,MAAM,GAAG,WAAW;AAAA,EACpB,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAUP,MAAM,eAAI,OAAO;AAAA,EAClB;AACD,CAAC;",
+  "names": []
+}

package/dist/cjs/contracts/payment_kit/deps/sui/object.d.ts

@@ -0,0 +1,5 @@
+/** Sui object identifiers */
+import { MoveStruct } from '../../../utils/index.js';
+export declare const UID: MoveStruct<{
+    id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+}, "0x2::object::UID">;

package/dist/cjs/contracts/payment_kit/deps/sui/object.js

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var object_exports = {};
+__export(object_exports, {
+  UID: () => UID
+});
+module.exports = __toCommonJS(object_exports);
+var import_utils = require("../../../utils/index.js");
+var import_bcs = require("@haneullabs/haneul/bcs");
+const $moduleName = "0x2::object";
+const UID = new import_utils.MoveStruct({
+  name: `${$moduleName}::UID`,
+  fields: {
+    id: import_bcs.bcs.Address
+  }
+});
+//# sourceMappingURL=object.js.map

package/dist/cjs/contracts/payment_kit/deps/sui/object.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/contracts/payment_kit/deps/sui/object.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\n/** Sui object identifiers */\n\nimport { MoveStruct } from '../../../utils/index.js';\nimport { bcs } from '@haneullabs/haneul/bcs';\nconst $moduleName = '0x2::object';\nexport const UID = new MoveStruct({\n\tname: `${$moduleName}::UID`,\n\tfields: {\n\t\tid: bcs.Address,\n\t},\n});\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,mBAA2B;AAC3B,iBAAoB;AACpB,MAAM,cAAc;AACb,MAAM,MAAM,IAAI,wBAAW;AAAA,EACjC,MAAM,GAAG,WAAW;AAAA,EACpB,QAAQ;AAAA,IACP,IAAI,eAAI;AAAA,EACT;AACD,CAAC;",
+  "names": []
+}

package/dist/cjs/contracts/payment_kit/deps/sui/vec_map.d.ts

@@ -0,0 +1,27 @@
+import type { BcsType } from '@haneullabs/haneul/bcs';
+import { MoveStruct } from '../../../utils/index.js';
+/** An entry in the map */
+export declare function Entry<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [K, V]): MoveStruct<{
+    key: K;
+    value: V;
+}, `0x2::vec_map::Entry<${K["name"]}, ${V["name"]}>`>;
+/**
+ * A map data structure backed by a vector. The map is guaranteed not to contain
+ * duplicate keys, but entries are _not_ sorted by key--entries are included in
+ * insertion order. All operations are O(N) in the size of the map--the intention
+ * of this data structure is only to provide the convenience of programming against
+ * a map API. Large maps should use handwritten parent/child relationships instead.
+ * Maps that need sorted iteration rather than insertion order iteration should
+ * also be handwritten.
+ */
+export declare function VecMap<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [K, V]): MoveStruct<{
+    contents: BcsType<{
+        key: K extends BcsType<infer U, any, string> ? U : never;
+        value: V extends BcsType<infer U, any, string> ? U : never;
+    }[], Iterable<{
+        key: K extends BcsType<any, infer U_1, string> ? U_1 : never;
+        value: V extends BcsType<any, infer U_1, string> ? U_1 : never;
+    }> & {
+        length: number;
+    }, string>;
+}, `0x2::vec_map::VecMap<${K["name"]}, ${V["name"]}>`>;

package/dist/cjs/contracts/payment_kit/deps/sui/vec_map.js

@@ -0,0 +1,45 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vec_map_exports = {};
+__export(vec_map_exports, {
+  Entry: () => Entry,
+  VecMap: () => VecMap
+});
+module.exports = __toCommonJS(vec_map_exports);
+var import_bcs = require("@haneullabs/haneul/bcs");
+var import_utils = require("../../../utils/index.js");
+const $moduleName = "0x2::vec_map";
+function Entry(...typeParameters) {
+  return new import_utils.MoveStruct({
+    name: `${$moduleName}::Entry<${typeParameters[0].name}, ${typeParameters[1].name}>`,
+    fields: {
+      key: typeParameters[0],
+      value: typeParameters[1]
+    }
+  });
+}
+function VecMap(...typeParameters) {
+  return new import_utils.MoveStruct({
+    name: `${$moduleName}::VecMap<${typeParameters[0].name}, ${typeParameters[1].name}>`,
+    fields: {
+      contents: import_bcs.bcs.vector(Entry(typeParameters[0], typeParameters[1]))
+    }
+  });
+}
+//# sourceMappingURL=vec_map.js.map

package/dist/cjs/contracts/payment_kit/deps/sui/vec_map.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/contracts/payment_kit/deps/sui/vec_map.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\nimport { bcs } from '@haneullabs/haneul/bcs';\nimport type { BcsType } from '@haneullabs/haneul/bcs';\nimport { MoveStruct } from '../../../utils/index.js';\nconst $moduleName = '0x2::vec_map';\n/** An entry in the map */\nexport function Entry<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [K, V]) {\n\treturn new MoveStruct({\n\t\tname: `${$moduleName}::Entry<${typeParameters[0].name as K['name']}, ${typeParameters[1].name as V['name']}>`,\n\t\tfields: {\n\t\t\tkey: typeParameters[0],\n\t\t\tvalue: typeParameters[1],\n\t\t},\n\t});\n}\n/**\n * A map data structure backed by a vector. The map is guaranteed not to contain\n * duplicate keys, but entries are _not_ sorted by key--entries are included in\n * insertion order. All operations are O(N) in the size of the map--the intention\n * of this data structure is only to provide the convenience of programming against\n * a map API. Large maps should use handwritten parent/child relationships instead.\n * Maps that need sorted iteration rather than insertion order iteration should\n * also be handwritten.\n */\nexport function VecMap<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [K, V]) {\n\treturn new MoveStruct({\n\t\tname: `${$moduleName}::VecMap<${typeParameters[0].name as K['name']}, ${typeParameters[1].name as V['name']}>`,\n\t\tfields: {\n\t\t\tcontents: bcs.vector(Entry(typeParameters[0], typeParameters[1])),\n\t\t},\n\t});\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,iBAAoB;AAEpB,mBAA2B;AAC3B,MAAM,cAAc;AAEb,SAAS,SAAyD,gBAAwB;AAChG,SAAO,IAAI,wBAAW;AAAA,IACrB,MAAM,GAAG,WAAW,WAAW,eAAe,CAAC,EAAE,IAAiB,KAAK,eAAe,CAAC,EAAE,IAAiB;AAAA,IAC1G,QAAQ;AAAA,MACP,KAAK,eAAe,CAAC;AAAA,MACrB,OAAO,eAAe,CAAC;AAAA,IACxB;AAAA,EACD,CAAC;AACF;AAUO,SAAS,UAA0D,gBAAwB;AACjG,SAAO,IAAI,wBAAW;AAAA,IACrB,MAAM,GAAG,WAAW,YAAY,eAAe,CAAC,EAAE,IAAiB,KAAK,eAAe,CAAC,EAAE,IAAiB;AAAA,IAC3G,QAAQ;AAAA,MACP,UAAU,eAAI,OAAO,MAAM,eAAe,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC;AAAA,IACjE;AAAA,EACD,CAAC;AACF;",
+  "names": []
+}

package/dist/cjs/contracts/payment_kit/payment_kit.d.ts

@@ -0,0 +1,233 @@
+import { MoveStruct, MoveEnum, MoveTuple } from '../utils/index.js';
+import type { RawTransactionArgument } from '../utils/index.js';
+import type { Transaction } from '@haneullabs/haneul/transactions';
+export declare const Namespace: MoveStruct<{
+    id: MoveStruct<{
+        id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+}, "@haneullabs/payment-kit::payment_kit::Namespace">;
+export declare const PaymentRegistry: MoveStruct<{
+    id: MoveStruct<{
+        id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    cap_id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    config: MoveStruct<{
+        contents: import("@haneullabs/haneul/bcs").BcsType<{
+            key: string;
+            value: import("@haneullabs/bcs").EnumOutputShapeWithKeys<{
+                U64: string;
+                Address: string;
+                String: string;
+                AsciiString: string;
+                Bool: boolean;
+                Bytes: number[];
+                Type: {
+                    name: string;
+                };
+            }, "String" | "U64" | "Address" | "AsciiString" | "Bool" | "Bytes" | "Type">;
+        }[], Iterable<{
+            key: string;
+            value: import("@haneullabs/bcs").EnumInputShape<{
+                U64: string | number | bigint;
+                Address: string | Uint8Array<ArrayBufferLike>;
+                String: string;
+                AsciiString: string;
+                Bool: boolean;
+                Bytes: Iterable<number> & {
+                    length: number;
+                };
+                Type: {
+                    name: string;
+                };
+            }>;
+        }> & {
+            length: number;
+        }, string>;
+    }, "0x2::vec_map::VecMap<string, @haneullabs/payment-kit::config::Value>">;
+    version: import("@haneullabs/haneul/bcs").BcsType<number, number, "u16">;
+}, "@haneullabs/payment-kit::payment_kit::PaymentRegistry">;
+export declare const RegistryAdminCap: MoveStruct<{
+    id: MoveStruct<{
+        id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    registry_id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+}, "@haneullabs/payment-kit::payment_kit::RegistryAdminCap">;
+/**
+ * Enum representing the type of payment: Ephemeral (one-time) or Registry (tracked
+ * in a registry).
+ */
+export declare const PaymentType: MoveEnum<{
+    Ephemeral: null;
+    Registry: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+}, "@haneullabs/payment-kit::payment_kit::PaymentType">;
+export declare const PaymentReceipt: MoveStruct<{
+    payment_type: MoveEnum<{
+        Ephemeral: null;
+        Registry: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "@haneullabs/payment-kit::payment_kit::PaymentType">;
+    nonce: import("@haneullabs/haneul/bcs").BcsType<string, string, "string">;
+    payment_amount: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    receiver: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    coin_type: import("@haneullabs/haneul/bcs").BcsType<string, string, "string">;
+    timestamp_ms: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@haneullabs/payment-kit::payment_kit::PaymentReceipt">;
+export declare const PaymentKey: MoveStruct<{
+    nonce: import("@haneullabs/haneul/bcs").BcsType<string, string, "string">;
+    payment_amount: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    receiver: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+}, "@haneullabs/payment-kit::payment_kit::PaymentKey">;
+export declare const PaymentRecord: MoveStruct<{
+    epoch_at_time_of_record: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@haneullabs/payment-kit::payment_kit::PaymentRecord">;
+export declare const BalanceKey: MoveTuple<import("@haneullabs/haneul/bcs").BcsType<boolean, boolean, "bool">[], "@haneullabs/payment-kit::payment_kit::BalanceKey">;
+export interface CreateRegistryArguments {
+    namespace: RawTransactionArgument<string>;
+    name: RawTransactionArgument<string>;
+}
+export interface CreateRegistryOptions {
+    package?: string;
+    arguments: CreateRegistryArguments | [namespace: RawTransactionArgument<string>, name: RawTransactionArgument<string>];
+}
+/**
+ * Creates a new payment registry with a supplied label. Label is used to derive
+ * the registry's ID.
+ */
+export declare function createRegistry(options: CreateRegistryOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface ProcessEphemeralPaymentArguments {
+    nonce: RawTransactionArgument<string>;
+    paymentAmount: RawTransactionArgument<number | bigint>;
+    coin: RawTransactionArgument<string>;
+    receiver: RawTransactionArgument<string>;
+}
+export interface ProcessEphemeralPaymentOptions {
+    package?: string;
+    arguments: ProcessEphemeralPaymentArguments | [
+        nonce: RawTransactionArgument<string>,
+        paymentAmount: RawTransactionArgument<number | bigint>,
+        coin: RawTransactionArgument<string>,
+        receiver: RawTransactionArgument<string>
+    ];
+    typeArguments: [string];
+}
+/**
+ * Processes a payment (without the use of a Registry), emitting a payment receipt
+ * event.
+ */
+export declare function processEphemeralPayment(options: ProcessEphemeralPaymentOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface ProcessRegistryPaymentArguments {
+    registry: RawTransactionArgument<string>;
+    nonce: RawTransactionArgument<string>;
+    paymentAmount: RawTransactionArgument<number | bigint>;
+    coin: RawTransactionArgument<string>;
+    receiver: RawTransactionArgument<string | null>;
+}
+export interface ProcessRegistryPaymentOptions {
+    package?: string;
+    arguments: ProcessRegistryPaymentArguments | [
+        registry: RawTransactionArgument<string>,
+        nonce: RawTransactionArgument<string>,
+        paymentAmount: RawTransactionArgument<number | bigint>,
+        coin: RawTransactionArgument<string>,
+        receiver: RawTransactionArgument<string | null>
+    ];
+    typeArguments: [string];
+}
+/**
+ * Processes a payment via a payment registry, writing a receipt to the registry
+ * and protecting from double spending for the same key.
+ */
+export declare function processRegistryPayment(options: ProcessRegistryPaymentOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface WithdrawFromRegistryArguments {
+    registry: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+}
+export interface WithdrawFromRegistryOptions {
+    package?: string;
+    arguments: WithdrawFromRegistryArguments | [registry: RawTransactionArgument<string>, cap: RawTransactionArgument<string>];
+    typeArguments: [string];
+}
+/**
+ * If the registry is configured to manage funds, withdraw all funds of the
+ * specified coin from the registry.
+ */
+export declare function withdrawFromRegistry(options: WithdrawFromRegistryOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface DeletePaymentRecordArguments {
+    registry: RawTransactionArgument<string>;
+    paymentKey: RawTransactionArgument<string>;
+}
+export interface DeletePaymentRecordOptions {
+    package?: string;
+    arguments: DeletePaymentRecordArguments | [registry: RawTransactionArgument<string>, paymentKey: RawTransactionArgument<string>];
+    typeArguments: [string];
+}
+/** Removes an expired Payment Record from the Registry. */
+export declare function deletePaymentRecord(options: DeletePaymentRecordOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface CreatePaymentKeyArguments {
+    nonce: RawTransactionArgument<string>;
+    paymentAmount: RawTransactionArgument<number | bigint>;
+    receiver: RawTransactionArgument<string>;
+}
+export interface CreatePaymentKeyOptions {
+    package?: string;
+    arguments: CreatePaymentKeyArguments | [
+        nonce: RawTransactionArgument<string>,
+        paymentAmount: RawTransactionArgument<number | bigint>,
+        receiver: RawTransactionArgument<string>
+    ];
+    typeArguments: [string];
+}
+/** Creates a PaymentKey from payment parameters. */
+export declare function createPaymentKey(options: CreatePaymentKeyOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface SetConfigEpochExpirationDurationArguments {
+    registry: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    epochExpirationDuration: RawTransactionArgument<number | bigint>;
+}
+export interface SetConfigEpochExpirationDurationOptions {
+    package?: string;
+    arguments: SetConfigEpochExpirationDurationArguments | [
+        registry: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        epochExpirationDuration: RawTransactionArgument<number | bigint>
+    ];
+}
+/**
+ * Sets the epoch expiration duration configuration for the registry. If set,
+ * payment records will expire after the specified number of epochs. If not set,
+ * payment records will expire 30 epochs after their creation.
+ */
+export declare function setConfigEpochExpirationDuration(options: SetConfigEpochExpirationDurationOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface SetConfigRegistryManagedFundsArguments {
+    registry: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    registryManagedFunds: RawTransactionArgument<boolean>;
+}
+export interface SetConfigRegistryManagedFundsOptions {
+    package?: string;
+    arguments: SetConfigRegistryManagedFundsArguments | [
+        registry: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        registryManagedFunds: RawTransactionArgument<boolean>
+    ];
+}
+/**
+ * Sets whether the registry should manage funds itself. If true, payments
+ * processed via the registry will be collected into the registry's balance. If
+ * false, payments will be transferred directly to the specified receiver.
+ */
+export declare function setConfigRegistryManagedFunds(options: SetConfigRegistryManagedFundsOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface ShareArguments {
+    registry: RawTransactionArgument<string>;
+}
+export interface ShareOptions {
+    package?: string;
+    arguments: ShareArguments | [registry: RawTransactionArgument<string>];
+}
+/**
+ * Enforce that a registry will always be shared.
+ *
+ * # Parameters
+ *
+ * - `registry` - The PaymentRegistry to share
+ */
+export declare function share(options: ShareOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;