nano-sdk 1.0.0

package/dist/nano/rpc/requests/process.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessRequest = ProcessRequest;
+const zod_1 = require("zod");
+const state_block_1 = require("../../blocks/state-block");
+const boolean_1 = require("../../types/boolean");
+const subtype_1 = require("../../types/subtype");
+function ProcessRequest() {
+    return zod_1.z.union([
+        zod_1.z.object({
+            action: zod_1.z.literal("process"),
+            json_block: zod_1.z.literal(true),
+            subtype: (0, subtype_1.SubtypeString)().or((0, subtype_1.SubtypeOpenString)()),
+            block: (0, state_block_1.StateBlock)(),
+            force: (0, boolean_1.BooleanString)().or(zod_1.z.boolean()).optional(),
+            async: (0, boolean_1.BooleanString)().or(zod_1.z.boolean()).optional(),
+        }),
+        zod_1.z.object({
+            action: zod_1.z.literal("process"),
+            json_block: zod_1.z.literal(false),
+            subtype: (0, subtype_1.SubtypeString)().or((0, subtype_1.SubtypeOpenString)()),
+            block: zod_1.z.string(),
+            force: (0, boolean_1.BooleanString)().or(zod_1.z.boolean()).optional(),
+            async: (0, boolean_1.BooleanString)().or(zod_1.z.boolean()).optional(),
+        }),
+    ]);
+}

package/dist/nano/rpc/requests/raw-to-nano.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export declare function RawToNanoRequest(): z.ZodObject<{
+    action: z.ZodLiteral<"raw_to_nano">;
+    amount: z.ZodString;
+}, z.core.$strip>;
+export type RawToNanoRequest = z.infer<ReturnType<typeof RawToNanoRequest>>;

package/dist/nano/rpc/requests/raw-to-nano.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RawToNanoRequest = RawToNanoRequest;
+const zod_1 = require("zod");
+const amount_1 = require("../../types/amount");
+function RawToNanoRequest() {
+    return zod_1.z.object({
+        action: zod_1.z.literal("raw_to_nano"),
+        amount: (0, amount_1.RawAmountString)(),
+    });
+}

package/dist/nano/rpc/requests/receivable-exists.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare function ReceivableExistsRequest(): z.ZodObject<{
+    action: z.ZodLiteral<"receivable_exists">;
+    hash: z.ZodString;
+    include_active: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>, z.ZodBoolean]>>;
+    include_only_confirmed: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>, z.ZodBoolean]>>;
+}, z.core.$strip>;
+export type ReceivableExistsRequest = z.infer<ReturnType<typeof ReceivableExistsRequest>>;

package/dist/nano/rpc/requests/receivable-exists.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReceivableExistsRequest = ReceivableExistsRequest;
+const zod_1 = require("zod");
+const boolean_1 = require("../../types/boolean");
+const hash_1 = require("../../types/hash");
+function ReceivableExistsRequest() {
+    return zod_1.z.object({
+        action: zod_1.z.literal("receivable_exists"),
+        hash: (0, hash_1.HashString)(),
+        include_active: (0, boolean_1.BooleanString)().or(zod_1.z.boolean()).optional(),
+        include_only_confirmed: (0, boolean_1.BooleanString)().or(zod_1.z.boolean()).optional(),
+    });
+}

package/dist/nano/rpc/requests/receivable.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+export declare function ReceivableRequest(): z.ZodObject<{
+    action: z.ZodLiteral<"receivable">;
+    account: z.ZodString;
+    count: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodInt]>>;
+    offset: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodInt]>>;
+    threshold: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodLiteral<"0">, z.ZodString]>>;
+    source: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>, z.ZodBoolean]>>;
+    include_active: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>, z.ZodBoolean]>>;
+    include_only_confirmed: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>, z.ZodBoolean]>>;
+    min_version: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>, z.ZodBoolean]>>;
+    sorting: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>, z.ZodBoolean]>>;
+}, z.core.$strip>;
+export type ReceivableRequest = z.infer<ReturnType<typeof ReceivableRequest>>;

package/dist/nano/rpc/requests/receivable.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReceivableRequest = ReceivableRequest;
+const zod_1 = require("zod");
+const account_1 = require("../../types/account");
+const amount_1 = require("../../types/amount");
+const boolean_1 = require("../../types/boolean");
+const uint_1 = require("../../types/uint");
+function ReceivableRequest() {
+    return zod_1.z.object({
+        action: zod_1.z.literal("receivable"),
+        account: (0, account_1.AccountString)(),
+        count: (0, uint_1.UIntString)().or((0, uint_1.UInt)()).optional(),
+        offset: (0, uint_1.UIntString)().or((0, uint_1.UInt)()).optional(),
+        threshold: zod_1.z.union([zod_1.z.literal(""), zod_1.z.literal("0"), (0, amount_1.RawAmountString)()]).optional(),
+        source: (0, boolean_1.BooleanString)().or(zod_1.z.boolean()).optional(),
+        include_active: (0, boolean_1.BooleanString)().or(zod_1.z.boolean()).optional(),
+        include_only_confirmed: (0, boolean_1.BooleanString)().or(zod_1.z.boolean()).optional(),
+        min_version: (0, boolean_1.BooleanString)().or(zod_1.z.boolean()).optional(),
+        sorting: (0, boolean_1.BooleanString)().or(zod_1.z.boolean()).optional(),
+    });
+}

package/dist/nano/rpc/requests/representatives-online.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare function RepresentativesOnlineRequest(): z.ZodObject<{
+    action: z.ZodLiteral<"representatives_online">;
+    accounts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    weight: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>, z.ZodBoolean]>>;
+}, z.core.$strip>;
+export type RepresentativesOnlineRequest = z.infer<ReturnType<typeof RepresentativesOnlineRequest>>;

package/dist/nano/rpc/requests/representatives-online.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepresentativesOnlineRequest = RepresentativesOnlineRequest;
+const zod_1 = require("zod");
+const account_1 = require("../../types/account");
+const boolean_1 = require("../../types/boolean");
+function RepresentativesOnlineRequest() {
+    return zod_1.z.object({
+        action: zod_1.z.literal("representatives_online"),
+        accounts: (0, account_1.AccountString)().array().optional(),
+        weight: (0, boolean_1.BooleanString)().or(zod_1.z.boolean()).optional(),
+    });
+}

package/dist/nano/rpc/requests/representatives.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare function RepresentativesRequest(): z.ZodObject<{
+    action: z.ZodLiteral<"representatives">;
+    count: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodInt]>>;
+    sorting: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>, z.ZodBoolean]>>;
+}, z.core.$strip>;
+export type RepresentativesRequest = z.infer<ReturnType<typeof RepresentativesRequest>>;

package/dist/nano/rpc/requests/representatives.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepresentativesRequest = RepresentativesRequest;
+const zod_1 = require("zod");
+const boolean_1 = require("../../types/boolean");
+const uint_1 = require("../../types/uint");
+function RepresentativesRequest() {
+    return zod_1.z.object({
+        action: zod_1.z.literal("representatives"),
+        count: (0, uint_1.UIntString)().or((0, uint_1.UInt)()).optional(),
+        sorting: (0, boolean_1.BooleanString)().or(zod_1.z.boolean()).optional(),
+    });
+}

package/dist/nano/rpc/requests/republish.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare function RepublishRequest(): z.ZodObject<{
+    action: z.ZodLiteral<"republish">;
+    hash: z.ZodString;
+    count: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodInt]>>;
+    sources: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodInt]>>;
+    destinations: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodInt]>>;
+}, z.core.$strip>;
+export type RepublishRequest = z.infer<ReturnType<typeof RepublishRequest>>;

package/dist/nano/rpc/requests/republish.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepublishRequest = RepublishRequest;
+const zod_1 = require("zod");
+const hash_1 = require("../../types/hash");
+const uint_1 = require("../../types/uint");
+function RepublishRequest() {
+    return zod_1.z.object({
+        action: zod_1.z.literal("republish"),
+        hash: (0, hash_1.HashString)(),
+        count: (0, uint_1.UIntString)().or((0, uint_1.UInt)()).optional(),
+        sources: (0, uint_1.UIntString)().or((0, uint_1.UInt)()).optional(),
+        destinations: (0, uint_1.UIntString)().or((0, uint_1.UInt)()).optional(),
+    });
+}

package/dist/nano/rpc/requests/sign.d.ts

@@ -0,0 +1,55 @@
+import { z } from "zod";
+export declare function SignRequest(): z.ZodUnion<readonly [z.ZodObject<{
+    action: z.ZodLiteral<"sign">;
+    json_block: z.ZodLiteral<true>;
+    key: z.ZodOptional<z.ZodString>;
+    block: z.ZodObject<{
+        type: z.ZodLiteral<"state">;
+        account: z.ZodString;
+        previous: z.ZodString;
+        representative: z.ZodString;
+        balance: z.ZodString;
+        link: z.ZodUnion<[z.ZodString, z.ZodString]>;
+        link_as_account: z.ZodString;
+        signature: z.ZodString;
+        work: z.ZodString;
+    }, z.core.$strip>;
+    hash: z.ZodOptional<z.ZodString>;
+    wallet: z.ZodOptional<z.ZodString>;
+    account: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"sign">;
+    json_block: z.ZodLiteral<true>;
+    key: z.ZodOptional<z.ZodString>;
+    block: z.ZodOptional<z.ZodObject<{
+        type: z.ZodLiteral<"state">;
+        account: z.ZodString;
+        previous: z.ZodString;
+        representative: z.ZodString;
+        balance: z.ZodString;
+        link: z.ZodUnion<[z.ZodString, z.ZodString]>;
+        link_as_account: z.ZodString;
+        signature: z.ZodString;
+        work: z.ZodString;
+    }, z.core.$strip>>;
+    hash: z.ZodString;
+    wallet: z.ZodOptional<z.ZodString>;
+    account: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"sign">;
+    json_block: z.ZodLiteral<false>;
+    key: z.ZodOptional<z.ZodString>;
+    block: z.ZodString;
+    hash: z.ZodOptional<z.ZodString>;
+    wallet: z.ZodOptional<z.ZodString>;
+    account: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"sign">;
+    json_block: z.ZodLiteral<false>;
+    key: z.ZodOptional<z.ZodString>;
+    block: z.ZodOptional<z.ZodString>;
+    hash: z.ZodString;
+    wallet: z.ZodOptional<z.ZodString>;
+    account: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+export type SignRequest = z.infer<ReturnType<typeof SignRequest>>;

package/dist/nano/rpc/requests/sign.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignRequest = SignRequest;
+const zod_1 = require("zod");
+const state_block_1 = require("../../blocks/state-block");
+const account_1 = require("../../types/account");
+const hash_1 = require("../../types/hash");
+const private_key_1 = require("../../types/private-key");
+const public_key_1 = require("../../types/public-key");
+function SignRequest() {
+    return zod_1.z.union([
+        zod_1.z.object({
+            action: zod_1.z.literal("sign"),
+            json_block: zod_1.z.literal(true),
+            key: (0, private_key_1.PrivateKeyString)().optional(),
+            block: (0, state_block_1.StateBlock)(),
+            hash: (0, hash_1.HashString)().optional(),
+            wallet: (0, public_key_1.PublicKeyString)().optional(),
+            account: (0, account_1.AccountString)().optional(),
+        }),
+        zod_1.z.object({
+            action: zod_1.z.literal("sign"),
+            json_block: zod_1.z.literal(true),
+            key: (0, private_key_1.PrivateKeyString)().optional(),
+            block: (0, state_block_1.StateBlock)().optional(),
+            hash: (0, hash_1.HashString)(),
+            wallet: (0, public_key_1.PublicKeyString)().optional(),
+            account: (0, account_1.AccountString)().optional(),
+        }),
+        zod_1.z.object({
+            action: zod_1.z.literal("sign"),
+            json_block: zod_1.z.literal(false),
+            key: (0, private_key_1.PrivateKeyString)().optional(),
+            block: zod_1.z.string(),
+            hash: (0, hash_1.HashString)().optional(),
+            wallet: (0, public_key_1.PublicKeyString)().optional(),
+            account: (0, account_1.AccountString)().optional(),
+        }),
+        zod_1.z.object({
+            action: zod_1.z.literal("sign"),
+            json_block: zod_1.z.literal(false),
+            key: (0, private_key_1.PrivateKeyString)().optional(),
+            block: zod_1.z.string().optional(),
+            hash: (0, hash_1.HashString)(),
+            wallet: (0, public_key_1.PublicKeyString)().optional(),
+            account: (0, account_1.AccountString)().optional(),
+        }),
+    ]);
+}

package/dist/nano/rpc/requests/stats-clear.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare function StatsClearRequest(): z.ZodObject<{
+    action: z.ZodLiteral<"stats_clear">;
+}, z.core.$strip>;
+export type StatsClearRequest = z.infer<ReturnType<typeof StatsClearRequest>>;

package/dist/nano/rpc/requests/stats-clear.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatsClearRequest = StatsClearRequest;
+const zod_1 = require("zod");
+function StatsClearRequest() {
+    return zod_1.z.object({
+        action: zod_1.z.literal("stats_clear"),
+    });
+}

package/dist/nano/rpc/requests/stats.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export declare function StatsRequest(): z.ZodObject<{
+    action: z.ZodLiteral<"stats">;
+    type: z.ZodUnion<readonly [z.ZodLiteral<"counters">, z.ZodLiteral<"samples">, z.ZodLiteral<"objects">, z.ZodLiteral<"database">]>;
+}, z.core.$strip>;
+export type StatsRequest = z.infer<ReturnType<typeof StatsRequest>>;

package/dist/nano/rpc/requests/stats.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatsRequest = StatsRequest;
+const zod_1 = require("zod");
+function StatsRequest() {
+    return zod_1.z.object({
+        action: zod_1.z.literal("stats"),
+        type: zod_1.z.union([zod_1.z.literal("counters"), zod_1.z.literal("samples"), zod_1.z.literal("objects"), zod_1.z.literal("database")]),
+    });
+}

package/dist/nano/rpc/requests/stop.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare function StopRequest(): z.ZodObject<{
+    action: z.ZodLiteral<"stop">;
+}, z.core.$strip>;
+export type StopRequest = z.infer<ReturnType<typeof StopRequest>>;

package/dist/nano/rpc/requests/stop.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StopRequest = StopRequest;
+const zod_1 = require("zod");
+function StopRequest() {
+    return zod_1.z.object({
+        action: zod_1.z.literal("stop"),
+    });
+}

package/dist/nano/rpc/requests/successors.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare function SuccessorsRequest(): z.ZodObject<{
+    action: z.ZodLiteral<"successors">;
+    block: z.ZodString;
+    count: z.ZodUnion<[z.ZodString, z.ZodInt]>;
+    offset: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodInt]>>;
+    reverse: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>, z.ZodBoolean]>>;
+}, z.core.$strip>;
+export type SuccessorsRequest = z.infer<ReturnType<typeof SuccessorsRequest>>;

package/dist/nano/rpc/requests/successors.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuccessorsRequest = SuccessorsRequest;
+const zod_1 = require("zod");
+const boolean_1 = require("../../types/boolean");
+const hash_1 = require("../../types/hash");
+const uint_1 = require("../../types/uint");
+function SuccessorsRequest() {
+    return zod_1.z.object({
+        action: zod_1.z.literal("successors"),
+        block: (0, hash_1.HashString)(),
+        count: (0, uint_1.UIntString)().or((0, uint_1.UInt)()),
+        offset: (0, uint_1.UIntString)().or((0, uint_1.UInt)()).optional(),
+        reverse: (0, boolean_1.BooleanString)().or(zod_1.z.boolean()).optional(),
+    });
+}

package/dist/nano/rpc/requests/telemetry.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare function TelemetryRequest(): z.ZodObject<{
+    action: z.ZodLiteral<"telemetry">;
+    address: z.ZodOptional<z.ZodString>;
+    port: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodInt]>>;
+    raw: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>, z.ZodBoolean]>>;
+}, z.core.$strip>;
+export type TelemetryRequest = z.infer<ReturnType<typeof TelemetryRequest>>;

package/dist/nano/rpc/requests/telemetry.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelemetryRequest = TelemetryRequest;
+const zod_1 = require("zod");
+const boolean_1 = require("../../types/boolean");
+const endpoint_1 = require("../../types/endpoint");
+const port_1 = require("../../types/port");
+function TelemetryRequest() {
+    return zod_1.z.object({
+        action: zod_1.z.literal("telemetry"),
+        address: (0, endpoint_1.EndpointString)().optional(),
+        port: (0, port_1.PortString)().or((0, port_1.Port)()).optional(),
+        raw: (0, boolean_1.BooleanString)().or(zod_1.z.boolean()).optional(),
+    });
+}

package/dist/nano/rpc/requests/unchecked-clear.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare function UncheckedClearRequest(): z.ZodObject<{
+    action: z.ZodLiteral<"unchecked_clear">;
+}, z.core.$strip>;
+export type UncheckedClearRequest = z.infer<ReturnType<typeof UncheckedClearRequest>>;

package/dist/nano/rpc/requests/unchecked-clear.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UncheckedClearRequest = UncheckedClearRequest;
+const zod_1 = require("zod");
+function UncheckedClearRequest() {
+    return zod_1.z.object({
+        action: zod_1.z.literal("unchecked_clear"),
+    });
+}

package/dist/nano/rpc/requests/unchecked-get.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare function UncheckedGetRequest(): z.ZodObject<{
+    action: z.ZodLiteral<"unchecked_get">;
+    hash: z.ZodString;
+    json_block: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>, z.ZodBoolean]>>;
+}, z.core.$strip>;
+export type UncheckedGetRequest = z.infer<ReturnType<typeof UncheckedGetRequest>>;

package/dist/nano/rpc/requests/unchecked-get.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UncheckedGetRequest = UncheckedGetRequest;
+const zod_1 = require("zod");
+const boolean_1 = require("../../types/boolean");
+const hash_1 = require("../../types/hash");
+function UncheckedGetRequest() {
+    return zod_1.z.object({
+        action: zod_1.z.literal("unchecked_get"),
+        hash: (0, hash_1.HashString)(),
+        json_block: (0, boolean_1.BooleanString)().or(zod_1.z.boolean()).optional(),
+    });
+}

package/dist/nano/rpc/requests/unchecked-keys.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare function UncheckedKeysRequest(): z.ZodObject<{
+    action: z.ZodLiteral<"unchecked_keys">;
+    key: z.ZodOptional<z.ZodString>;
+    count: z.ZodUnion<[z.ZodString, z.ZodInt]>;
+    json_block: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>, z.ZodBoolean]>>;
+}, z.core.$strip>;
+export type UncheckedKeysRequest = z.infer<ReturnType<typeof UncheckedKeysRequest>>;

package/dist/nano/rpc/requests/unchecked-keys.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UncheckedKeysRequest = UncheckedKeysRequest;
+const zod_1 = require("zod");
+const boolean_1 = require("../../types/boolean");
+const hash_1 = require("../../types/hash");
+const uint_1 = require("../../types/uint");
+function UncheckedKeysRequest() {
+    return zod_1.z.object({
+        action: zod_1.z.literal("unchecked_keys"),
+        key: (0, hash_1.HashString)().optional(),
+        count: (0, uint_1.UIntString)().or((0, uint_1.UInt)()),
+        json_block: (0, boolean_1.BooleanString)().or(zod_1.z.boolean()).optional(),
+    });
+}

package/dist/nano/rpc/requests/unchecked.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare function UncheckedRequest(): z.ZodObject<{
+    action: z.ZodLiteral<"unchecked">;
+    count: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodInt]>>;
+    json_block: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>, z.ZodBoolean]>>;
+}, z.core.$strip>;
+export type UncheckedRequest = z.infer<ReturnType<typeof UncheckedRequest>>;

package/dist/nano/rpc/requests/unchecked.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UncheckedRequest = UncheckedRequest;
+const zod_1 = require("zod");
+const boolean_1 = require("../../types/boolean");
+const uint_1 = require("../../types/uint");
+function UncheckedRequest() {
+    return zod_1.z.object({
+        action: zod_1.z.literal("unchecked"),
+        count: (0, uint_1.UIntString)().or((0, uint_1.UInt)()).optional(),
+        json_block: (0, boolean_1.BooleanString)().or(zod_1.z.boolean()).optional(),
+    });
+}

package/dist/nano/rpc/requests/unopened.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare function UnopenedRequest(): z.ZodObject<{
+    action: z.ZodLiteral<"unopened">;
+    account: z.ZodOptional<z.ZodString>;
+    count: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodInt]>>;
+    threshold: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type UnopenedRequest = z.infer<ReturnType<typeof UnopenedRequest>>;

package/dist/nano/rpc/requests/unopened.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnopenedRequest = UnopenedRequest;
+const zod_1 = require("zod");
+const account_1 = require("../../types/account");
+const amount_1 = require("../../types/amount");
+const uint_1 = require("../../types/uint");
+function UnopenedRequest() {
+    return zod_1.z.object({
+        action: zod_1.z.literal("unopened"),
+        account: (0, account_1.AccountString)().optional(),
+        count: (0, uint_1.UIntString)().or((0, uint_1.UInt)()).optional(),
+        threshold: (0, amount_1.RawAmountString)().optional(),
+    });
+}

package/dist/nano/rpc/requests/uptime.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare function UptimeRequest(): z.ZodObject<{
+    action: z.ZodLiteral<"uptime">;
+}, z.core.$strip>;
+export type UptimeRequest = z.infer<ReturnType<typeof UptimeRequest>>;

package/dist/nano/rpc/requests/uptime.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UptimeRequest = UptimeRequest;
+const zod_1 = require("zod");
+function UptimeRequest() {
+    return zod_1.z.object({
+        action: zod_1.z.literal("uptime"),
+    });
+}

package/dist/nano/rpc/requests/validate-account-number.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export declare function ValidateAccountNumberRequest(): z.ZodObject<{
+    action: z.ZodLiteral<"validate_account_number">;
+    account: z.ZodString;
+}, z.core.$strip>;
+export type ValidateAccountNumberRequest = z.infer<ReturnType<typeof ValidateAccountNumberRequest>>;

package/dist/nano/rpc/requests/validate-account-number.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidateAccountNumberRequest = ValidateAccountNumberRequest;
+const zod_1 = require("zod");
+function ValidateAccountNumberRequest() {
+    return zod_1.z.object({
+        action: zod_1.z.literal("validate_account_number"),
+        account: zod_1.z.string(), // No AccountString; use Nano node validation instead
+    });
+}

package/dist/nano/rpc/requests/version.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare function VersionRequest(): z.ZodObject<{
+    action: z.ZodLiteral<"version">;
+}, z.core.$strip>;
+export type VersionRequest = z.infer<ReturnType<typeof VersionRequest>>;

package/dist/nano/rpc/requests/version.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionRequest = VersionRequest;
+const zod_1 = require("zod");
+function VersionRequest() {
+    return zod_1.z.object({
+        action: zod_1.z.literal("version"),
+    });
+}

package/dist/nano/rpc/requests/work-cancel.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export declare function WorkCancelRequest(): z.ZodObject<{
+    action: z.ZodLiteral<"work_cancel">;
+    hash: z.ZodString;
+}, z.core.$strip>;
+export type WorkCancelRequest = z.infer<ReturnType<typeof WorkCancelRequest>>;

package/dist/nano/rpc/requests/work-cancel.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkCancelRequest = WorkCancelRequest;
+const zod_1 = require("zod");
+const hash_1 = require("../../types/hash");
+function WorkCancelRequest() {
+    return zod_1.z.object({
+        action: zod_1.z.literal("work_cancel"),
+        hash: (0, hash_1.HashString)(),
+    });
+}