@polygonlabs/staker-pool-allocations-schemas 0.1.0

package/dist/registry-public.d.ts

@@ -0,0 +1,1323 @@
+import { TypedRegistry } from '@polygonlabs/openapi-registry';
+export declare const buildPublicRegistry: () => TypedRegistry<{}, {}> & TypedRegistry<{
+    getHealthCheck: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getHealthCheck";
+        readonly method: "get";
+        readonly path: "/health-check";
+        readonly summary: "Liveness check (K8s probe)";
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Service is alive.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            status: import("zod").ZodLiteral<"ok">;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    getReadiness: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getReadiness";
+        readonly method: "get";
+        readonly path: "/readiness";
+        readonly summary: "Readiness check";
+        readonly description: string;
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Service is ready.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            status: import("zod").ZodLiteral<"ok">;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+}, {}> & TypedRegistry<{
+    getHealthCheck: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getHealthCheck";
+        readonly method: "get";
+        readonly path: "/health-check";
+        readonly summary: "Liveness check (K8s probe)";
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Service is alive.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            status: import("zod").ZodLiteral<"ok">;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    getReadiness: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getReadiness";
+        readonly method: "get";
+        readonly path: "/readiness";
+        readonly summary: "Readiness check";
+        readonly description: string;
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Service is ready.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            status: import("zod").ZodLiteral<"ok">;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    listDistributions: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "listDistributions";
+        readonly method: "get";
+        readonly path: "/v1/{network}/distributions";
+        readonly summary: "List completed distributions";
+        readonly description: string;
+        readonly request: {
+            readonly params: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+            }, import("zod/v4/core").$strip>;
+            readonly query: import("zod").ZodObject<{
+                cursor: import("zod").ZodOptional<import("zod").ZodString>;
+                limit: import("zod").ZodDefault<import("zod").ZodCoercedNumber<unknown>>;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Page of distribution summaries.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            items: import("zod").ZodArray<import("zod").ZodObject<{
+                                distributionId: import("zod").ZodString;
+                                status: import("zod").ZodEnum<{
+                                    pending: "pending";
+                                    running: "running";
+                                    completed: "completed";
+                                    failed: "failed";
+                                }>;
+                                startPoSBlock: import("zod").ZodString;
+                                endPoSBlock: import("zod").ZodString;
+                                merkleRoot: import("zod").ZodNullable<import("zod").ZodString>;
+                                totalAllocated: import("zod").ZodNullable<import("zod").ZodString>;
+                                completedAt: import("zod").ZodNullable<import("zod").ZodISODateTime>;
+                            }, import("zod/v4/core").$strip>>;
+                            nextCursor: import("zod").ZodNullable<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 400: {
+                readonly description: string;
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    getDistribution: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getDistribution";
+        readonly method: "get";
+        readonly path: "/v1/{network}/distributions/{distributionId}";
+        readonly summary: "Get a single completed distribution";
+        readonly request: {
+            readonly params: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+                distributionId: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Distribution detail.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            distributionId: import("zod").ZodString;
+                            status: import("zod").ZodEnum<{
+                                pending: "pending";
+                                running: "running";
+                                completed: "completed";
+                                failed: "failed";
+                            }>;
+                            startPoSBlock: import("zod").ZodString;
+                            endPoSBlock: import("zod").ZodString;
+                            merkleRoot: import("zod").ZodNullable<import("zod").ZodString>;
+                            totalAllocated: import("zod").ZodNullable<import("zod").ZodString>;
+                            completedAt: import("zod").ZodNullable<import("zod").ZodISODateTime>;
+                            checkpointCount: import("zod").ZodNumber;
+                            polUsdPrice: import("zod").ZodNullable<import("zod").ZodString>;
+                            maxClaimableUsdThreshold: import("zod").ZodNullable<import("zod").ZodString>;
+                            inputsHash: import("zod").ZodNullable<import("zod").ZodString>;
+                            posStakingSubgraphBlock: import("zod").ZodNullable<import("zod").ZodString>;
+                            posStakingSubgraphHash: import("zod").ZodNullable<import("zod").ZodString>;
+                            posCheckpointsSubgraphBlock: import("zod").ZodNullable<import("zod").ZodString>;
+                            posCheckpointsSubgraphHash: import("zod").ZodNullable<import("zod").ZodString>;
+                            posPriorityFeesSubgraphBlock: import("zod").ZodNullable<import("zod").ZodString>;
+                            posPriorityFeesSubgraphHash: import("zod").ZodNullable<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 404: {
+                readonly description: "Distribution not found or not yet completed.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+}, {}> & TypedRegistry<{
+    getHealthCheck: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getHealthCheck";
+        readonly method: "get";
+        readonly path: "/health-check";
+        readonly summary: "Liveness check (K8s probe)";
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Service is alive.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            status: import("zod").ZodLiteral<"ok">;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    getReadiness: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getReadiness";
+        readonly method: "get";
+        readonly path: "/readiness";
+        readonly summary: "Readiness check";
+        readonly description: string;
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Service is ready.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            status: import("zod").ZodLiteral<"ok">;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    listDistributions: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "listDistributions";
+        readonly method: "get";
+        readonly path: "/v1/{network}/distributions";
+        readonly summary: "List completed distributions";
+        readonly description: string;
+        readonly request: {
+            readonly params: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+            }, import("zod/v4/core").$strip>;
+            readonly query: import("zod").ZodObject<{
+                cursor: import("zod").ZodOptional<import("zod").ZodString>;
+                limit: import("zod").ZodDefault<import("zod").ZodCoercedNumber<unknown>>;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Page of distribution summaries.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            items: import("zod").ZodArray<import("zod").ZodObject<{
+                                distributionId: import("zod").ZodString;
+                                status: import("zod").ZodEnum<{
+                                    pending: "pending";
+                                    running: "running";
+                                    completed: "completed";
+                                    failed: "failed";
+                                }>;
+                                startPoSBlock: import("zod").ZodString;
+                                endPoSBlock: import("zod").ZodString;
+                                merkleRoot: import("zod").ZodNullable<import("zod").ZodString>;
+                                totalAllocated: import("zod").ZodNullable<import("zod").ZodString>;
+                                completedAt: import("zod").ZodNullable<import("zod").ZodISODateTime>;
+                            }, import("zod/v4/core").$strip>>;
+                            nextCursor: import("zod").ZodNullable<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 400: {
+                readonly description: string;
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    getDistribution: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getDistribution";
+        readonly method: "get";
+        readonly path: "/v1/{network}/distributions/{distributionId}";
+        readonly summary: "Get a single completed distribution";
+        readonly request: {
+            readonly params: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+                distributionId: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Distribution detail.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            distributionId: import("zod").ZodString;
+                            status: import("zod").ZodEnum<{
+                                pending: "pending";
+                                running: "running";
+                                completed: "completed";
+                                failed: "failed";
+                            }>;
+                            startPoSBlock: import("zod").ZodString;
+                            endPoSBlock: import("zod").ZodString;
+                            merkleRoot: import("zod").ZodNullable<import("zod").ZodString>;
+                            totalAllocated: import("zod").ZodNullable<import("zod").ZodString>;
+                            completedAt: import("zod").ZodNullable<import("zod").ZodISODateTime>;
+                            checkpointCount: import("zod").ZodNumber;
+                            polUsdPrice: import("zod").ZodNullable<import("zod").ZodString>;
+                            maxClaimableUsdThreshold: import("zod").ZodNullable<import("zod").ZodString>;
+                            inputsHash: import("zod").ZodNullable<import("zod").ZodString>;
+                            posStakingSubgraphBlock: import("zod").ZodNullable<import("zod").ZodString>;
+                            posStakingSubgraphHash: import("zod").ZodNullable<import("zod").ZodString>;
+                            posCheckpointsSubgraphBlock: import("zod").ZodNullable<import("zod").ZodString>;
+                            posCheckpointsSubgraphHash: import("zod").ZodNullable<import("zod").ZodString>;
+                            posPriorityFeesSubgraphBlock: import("zod").ZodNullable<import("zod").ZodString>;
+                            posPriorityFeesSubgraphHash: import("zod").ZodNullable<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 404: {
+                readonly description: "Distribution not found or not yet completed.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    listAllocations: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "listAllocations";
+        readonly method: "get";
+        readonly path: "/v1/{network}/distributions/{distributionId}/allocations";
+        readonly summary: "List allocations for a completed distribution";
+        readonly description: "Paginated by `leafIndex` ascending.";
+        readonly request: {
+            readonly params: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+                distributionId: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+            readonly query: import("zod").ZodObject<{
+                cursor: import("zod").ZodOptional<import("zod").ZodString>;
+                limit: import("zod").ZodDefault<import("zod").ZodCoercedNumber<unknown>>;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Page of allocation rows.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            items: import("zod").ZodArray<import("zod").ZodObject<{
+                                address: import("zod").ZodString;
+                                amount: import("zod").ZodString;
+                                leafIndex: import("zod").ZodNullable<import("zod").ZodNumber>;
+                            }, import("zod/v4/core").$strip>>;
+                            nextCursor: import("zod").ZodNullable<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 400: {
+                readonly description: string;
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 404: {
+                readonly description: "Distribution not found or not yet completed.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    listExcludedAllocations: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "listExcludedAllocations";
+        readonly method: "get";
+        readonly path: "/v1/{network}/distributions/{distributionId}/excluded-allocations";
+        readonly summary: "List off-chain (merkle-excluded) allocations for a distribution";
+        readonly description: string;
+        readonly request: {
+            readonly params: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+                distributionId: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "The off-chain allocation set.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            items: import("zod").ZodArray<import("zod").ZodObject<{
+                                address: import("zod").ZodString;
+                                amount: import("zod").ZodString;
+                            }, import("zod/v4/core").$strip>>;
+                            total: import("zod").ZodNumber;
+                            totalAmount: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 404: {
+                readonly description: "Distribution not found or not yet completed.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    getAllocation: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getAllocation";
+        readonly method: "get";
+        readonly path: "/v1/{network}/distributions/{distributionId}/allocations/{address}";
+        readonly summary: "Get a single address allocation in a distribution";
+        readonly request: {
+            readonly params: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+                distributionId: import("zod").ZodString;
+                address: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Allocation row.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            address: import("zod").ZodString;
+                            amount: import("zod").ZodString;
+                            leafIndex: import("zod").ZodNullable<import("zod").ZodNumber>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 404: {
+                readonly description: "Distribution or allocation not found.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+}, {}> & TypedRegistry<{
+    getHealthCheck: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getHealthCheck";
+        readonly method: "get";
+        readonly path: "/health-check";
+        readonly summary: "Liveness check (K8s probe)";
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Service is alive.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            status: import("zod").ZodLiteral<"ok">;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    getReadiness: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getReadiness";
+        readonly method: "get";
+        readonly path: "/readiness";
+        readonly summary: "Readiness check";
+        readonly description: string;
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Service is ready.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            status: import("zod").ZodLiteral<"ok">;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    listDistributions: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "listDistributions";
+        readonly method: "get";
+        readonly path: "/v1/{network}/distributions";
+        readonly summary: "List completed distributions";
+        readonly description: string;
+        readonly request: {
+            readonly params: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+            }, import("zod/v4/core").$strip>;
+            readonly query: import("zod").ZodObject<{
+                cursor: import("zod").ZodOptional<import("zod").ZodString>;
+                limit: import("zod").ZodDefault<import("zod").ZodCoercedNumber<unknown>>;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Page of distribution summaries.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            items: import("zod").ZodArray<import("zod").ZodObject<{
+                                distributionId: import("zod").ZodString;
+                                status: import("zod").ZodEnum<{
+                                    pending: "pending";
+                                    running: "running";
+                                    completed: "completed";
+                                    failed: "failed";
+                                }>;
+                                startPoSBlock: import("zod").ZodString;
+                                endPoSBlock: import("zod").ZodString;
+                                merkleRoot: import("zod").ZodNullable<import("zod").ZodString>;
+                                totalAllocated: import("zod").ZodNullable<import("zod").ZodString>;
+                                completedAt: import("zod").ZodNullable<import("zod").ZodISODateTime>;
+                            }, import("zod/v4/core").$strip>>;
+                            nextCursor: import("zod").ZodNullable<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 400: {
+                readonly description: string;
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    getDistribution: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getDistribution";
+        readonly method: "get";
+        readonly path: "/v1/{network}/distributions/{distributionId}";
+        readonly summary: "Get a single completed distribution";
+        readonly request: {
+            readonly params: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+                distributionId: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Distribution detail.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            distributionId: import("zod").ZodString;
+                            status: import("zod").ZodEnum<{
+                                pending: "pending";
+                                running: "running";
+                                completed: "completed";
+                                failed: "failed";
+                            }>;
+                            startPoSBlock: import("zod").ZodString;
+                            endPoSBlock: import("zod").ZodString;
+                            merkleRoot: import("zod").ZodNullable<import("zod").ZodString>;
+                            totalAllocated: import("zod").ZodNullable<import("zod").ZodString>;
+                            completedAt: import("zod").ZodNullable<import("zod").ZodISODateTime>;
+                            checkpointCount: import("zod").ZodNumber;
+                            polUsdPrice: import("zod").ZodNullable<import("zod").ZodString>;
+                            maxClaimableUsdThreshold: import("zod").ZodNullable<import("zod").ZodString>;
+                            inputsHash: import("zod").ZodNullable<import("zod").ZodString>;
+                            posStakingSubgraphBlock: import("zod").ZodNullable<import("zod").ZodString>;
+                            posStakingSubgraphHash: import("zod").ZodNullable<import("zod").ZodString>;
+                            posCheckpointsSubgraphBlock: import("zod").ZodNullable<import("zod").ZodString>;
+                            posCheckpointsSubgraphHash: import("zod").ZodNullable<import("zod").ZodString>;
+                            posPriorityFeesSubgraphBlock: import("zod").ZodNullable<import("zod").ZodString>;
+                            posPriorityFeesSubgraphHash: import("zod").ZodNullable<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 404: {
+                readonly description: "Distribution not found or not yet completed.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    listAllocations: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "listAllocations";
+        readonly method: "get";
+        readonly path: "/v1/{network}/distributions/{distributionId}/allocations";
+        readonly summary: "List allocations for a completed distribution";
+        readonly description: "Paginated by `leafIndex` ascending.";
+        readonly request: {
+            readonly params: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+                distributionId: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+            readonly query: import("zod").ZodObject<{
+                cursor: import("zod").ZodOptional<import("zod").ZodString>;
+                limit: import("zod").ZodDefault<import("zod").ZodCoercedNumber<unknown>>;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Page of allocation rows.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            items: import("zod").ZodArray<import("zod").ZodObject<{
+                                address: import("zod").ZodString;
+                                amount: import("zod").ZodString;
+                                leafIndex: import("zod").ZodNullable<import("zod").ZodNumber>;
+                            }, import("zod/v4/core").$strip>>;
+                            nextCursor: import("zod").ZodNullable<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 400: {
+                readonly description: string;
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 404: {
+                readonly description: "Distribution not found or not yet completed.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    listExcludedAllocations: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "listExcludedAllocations";
+        readonly method: "get";
+        readonly path: "/v1/{network}/distributions/{distributionId}/excluded-allocations";
+        readonly summary: "List off-chain (merkle-excluded) allocations for a distribution";
+        readonly description: string;
+        readonly request: {
+            readonly params: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+                distributionId: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "The off-chain allocation set.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            items: import("zod").ZodArray<import("zod").ZodObject<{
+                                address: import("zod").ZodString;
+                                amount: import("zod").ZodString;
+                            }, import("zod/v4/core").$strip>>;
+                            total: import("zod").ZodNumber;
+                            totalAmount: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 404: {
+                readonly description: "Distribution not found or not yet completed.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    getAllocation: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getAllocation";
+        readonly method: "get";
+        readonly path: "/v1/{network}/distributions/{distributionId}/allocations/{address}";
+        readonly summary: "Get a single address allocation in a distribution";
+        readonly request: {
+            readonly params: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+                distributionId: import("zod").ZodString;
+                address: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Allocation row.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            address: import("zod").ZodString;
+                            amount: import("zod").ZodString;
+                            leafIndex: import("zod").ZodNullable<import("zod").ZodNumber>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 404: {
+                readonly description: "Distribution or allocation not found.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    getAddressAllocationHistory: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getAddressAllocationHistory";
+        readonly method: "get";
+        readonly path: "/v1/{network}/addresses/{address}/allocations";
+        readonly summary: "Per-address cross-distribution allocation history with live claim status";
+        readonly description: string;
+        readonly request: {
+            readonly params: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+                address: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "History rows ordered most-recently-completed first.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            items: import("zod").ZodArray<import("zod").ZodObject<{
+                                address: import("zod").ZodString;
+                                distributionId: import("zod").ZodString;
+                                amount: import("zod").ZodString;
+                                leafIndex: import("zod").ZodNullable<import("zod").ZodNumber>;
+                                merkleRoot: import("zod").ZodString;
+                                completedAt: import("zod").ZodISODateTime;
+                                status: import("zod").ZodEnum<{
+                                    claimed: "claimed";
+                                    unclaimed: "unclaimed";
+                                }>;
+                            }, import("zod/v4/core").$strip>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    getUnclaimedProofs: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getUnclaimedProofs";
+        readonly method: "get";
+        readonly path: "/v1/{network}/addresses/{address}/unclaimed-proofs";
+        readonly summary: "Per-address unclaimed-proofs array — the primary claim-flow UI endpoint";
+        readonly description: string;
+        readonly request: {
+            readonly params: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+                address: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Batch of unclaimed-proof entries ordered oldest-distribution first.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            items: import("zod").ZodArray<import("zod").ZodObject<{
+                                distributionId: import("zod").ZodString;
+                                merkleRoot: import("zod").ZodString;
+                                amount: import("zod").ZodString;
+                                leafIndex: import("zod").ZodNumber;
+                                proof: import("zod").ZodArray<import("zod").ZodString>;
+                            }, import("zod/v4/core").$strip>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+}, {}> & TypedRegistry<{
+    getHealthCheck: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getHealthCheck";
+        readonly method: "get";
+        readonly path: "/health-check";
+        readonly summary: "Liveness check (K8s probe)";
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Service is alive.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            status: import("zod").ZodLiteral<"ok">;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    getReadiness: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getReadiness";
+        readonly method: "get";
+        readonly path: "/readiness";
+        readonly summary: "Readiness check";
+        readonly description: string;
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Service is ready.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            status: import("zod").ZodLiteral<"ok">;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    listDistributions: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "listDistributions";
+        readonly method: "get";
+        readonly path: "/v1/{network}/distributions";
+        readonly summary: "List completed distributions";
+        readonly description: string;
+        readonly request: {
+            readonly params: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+            }, import("zod/v4/core").$strip>;
+            readonly query: import("zod").ZodObject<{
+                cursor: import("zod").ZodOptional<import("zod").ZodString>;
+                limit: import("zod").ZodDefault<import("zod").ZodCoercedNumber<unknown>>;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Page of distribution summaries.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            items: import("zod").ZodArray<import("zod").ZodObject<{
+                                distributionId: import("zod").ZodString;
+                                status: import("zod").ZodEnum<{
+                                    pending: "pending";
+                                    running: "running";
+                                    completed: "completed";
+                                    failed: "failed";
+                                }>;
+                                startPoSBlock: import("zod").ZodString;
+                                endPoSBlock: import("zod").ZodString;
+                                merkleRoot: import("zod").ZodNullable<import("zod").ZodString>;
+                                totalAllocated: import("zod").ZodNullable<import("zod").ZodString>;
+                                completedAt: import("zod").ZodNullable<import("zod").ZodISODateTime>;
+                            }, import("zod/v4/core").$strip>>;
+                            nextCursor: import("zod").ZodNullable<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 400: {
+                readonly description: string;
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    getDistribution: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getDistribution";
+        readonly method: "get";
+        readonly path: "/v1/{network}/distributions/{distributionId}";
+        readonly summary: "Get a single completed distribution";
+        readonly request: {
+            readonly params: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+                distributionId: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Distribution detail.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            distributionId: import("zod").ZodString;
+                            status: import("zod").ZodEnum<{
+                                pending: "pending";
+                                running: "running";
+                                completed: "completed";
+                                failed: "failed";
+                            }>;
+                            startPoSBlock: import("zod").ZodString;
+                            endPoSBlock: import("zod").ZodString;
+                            merkleRoot: import("zod").ZodNullable<import("zod").ZodString>;
+                            totalAllocated: import("zod").ZodNullable<import("zod").ZodString>;
+                            completedAt: import("zod").ZodNullable<import("zod").ZodISODateTime>;
+                            checkpointCount: import("zod").ZodNumber;
+                            polUsdPrice: import("zod").ZodNullable<import("zod").ZodString>;
+                            maxClaimableUsdThreshold: import("zod").ZodNullable<import("zod").ZodString>;
+                            inputsHash: import("zod").ZodNullable<import("zod").ZodString>;
+                            posStakingSubgraphBlock: import("zod").ZodNullable<import("zod").ZodString>;
+                            posStakingSubgraphHash: import("zod").ZodNullable<import("zod").ZodString>;
+                            posCheckpointsSubgraphBlock: import("zod").ZodNullable<import("zod").ZodString>;
+                            posCheckpointsSubgraphHash: import("zod").ZodNullable<import("zod").ZodString>;
+                            posPriorityFeesSubgraphBlock: import("zod").ZodNullable<import("zod").ZodString>;
+                            posPriorityFeesSubgraphHash: import("zod").ZodNullable<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 404: {
+                readonly description: "Distribution not found or not yet completed.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    listAllocations: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "listAllocations";
+        readonly method: "get";
+        readonly path: "/v1/{network}/distributions/{distributionId}/allocations";
+        readonly summary: "List allocations for a completed distribution";
+        readonly description: "Paginated by `leafIndex` ascending.";
+        readonly request: {
+            readonly params: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+                distributionId: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+            readonly query: import("zod").ZodObject<{
+                cursor: import("zod").ZodOptional<import("zod").ZodString>;
+                limit: import("zod").ZodDefault<import("zod").ZodCoercedNumber<unknown>>;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Page of allocation rows.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            items: import("zod").ZodArray<import("zod").ZodObject<{
+                                address: import("zod").ZodString;
+                                amount: import("zod").ZodString;
+                                leafIndex: import("zod").ZodNullable<import("zod").ZodNumber>;
+                            }, import("zod/v4/core").$strip>>;
+                            nextCursor: import("zod").ZodNullable<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 400: {
+                readonly description: string;
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 404: {
+                readonly description: "Distribution not found or not yet completed.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    listExcludedAllocations: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "listExcludedAllocations";
+        readonly method: "get";
+        readonly path: "/v1/{network}/distributions/{distributionId}/excluded-allocations";
+        readonly summary: "List off-chain (merkle-excluded) allocations for a distribution";
+        readonly description: string;
+        readonly request: {
+            readonly params: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+                distributionId: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "The off-chain allocation set.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            items: import("zod").ZodArray<import("zod").ZodObject<{
+                                address: import("zod").ZodString;
+                                amount: import("zod").ZodString;
+                            }, import("zod/v4/core").$strip>>;
+                            total: import("zod").ZodNumber;
+                            totalAmount: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 404: {
+                readonly description: "Distribution not found or not yet completed.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    getAllocation: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getAllocation";
+        readonly method: "get";
+        readonly path: "/v1/{network}/distributions/{distributionId}/allocations/{address}";
+        readonly summary: "Get a single address allocation in a distribution";
+        readonly request: {
+            readonly params: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+                distributionId: import("zod").ZodString;
+                address: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Allocation row.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            address: import("zod").ZodString;
+                            amount: import("zod").ZodString;
+                            leafIndex: import("zod").ZodNullable<import("zod").ZodNumber>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 404: {
+                readonly description: "Distribution or allocation not found.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    getAddressAllocationHistory: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getAddressAllocationHistory";
+        readonly method: "get";
+        readonly path: "/v1/{network}/addresses/{address}/allocations";
+        readonly summary: "Per-address cross-distribution allocation history with live claim status";
+        readonly description: string;
+        readonly request: {
+            readonly params: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+                address: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "History rows ordered most-recently-completed first.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            items: import("zod").ZodArray<import("zod").ZodObject<{
+                                address: import("zod").ZodString;
+                                distributionId: import("zod").ZodString;
+                                amount: import("zod").ZodString;
+                                leafIndex: import("zod").ZodNullable<import("zod").ZodNumber>;
+                                merkleRoot: import("zod").ZodString;
+                                completedAt: import("zod").ZodISODateTime;
+                                status: import("zod").ZodEnum<{
+                                    claimed: "claimed";
+                                    unclaimed: "unclaimed";
+                                }>;
+                            }, import("zod/v4/core").$strip>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    getUnclaimedProofs: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getUnclaimedProofs";
+        readonly method: "get";
+        readonly path: "/v1/{network}/addresses/{address}/unclaimed-proofs";
+        readonly summary: "Per-address unclaimed-proofs array — the primary claim-flow UI endpoint";
+        readonly description: string;
+        readonly request: {
+            readonly params: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+                address: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Batch of unclaimed-proof entries ordered oldest-distribution first.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            items: import("zod").ZodArray<import("zod").ZodObject<{
+                                distributionId: import("zod").ZodString;
+                                merkleRoot: import("zod").ZodString;
+                                amount: import("zod").ZodString;
+                                leafIndex: import("zod").ZodNumber;
+                                proof: import("zod").ZodArray<import("zod").ZodString>;
+                            }, import("zod/v4/core").$strip>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+} & {
+    getProof: import("@polygonlabs/openapi-registry").MergedRoute<{
+        readonly operationId: "getProof";
+        readonly method: "get";
+        readonly path: "/v1/{network}/distributions/{distributionId}/allocations/{address}/proof";
+        readonly summary: "Get the merkle proof for a single allocation";
+        readonly description: string;
+        readonly request: {
+            readonly params: import("zod").ZodObject<{
+                network: import("zod").ZodEnum<{
+                    mainnet: "mainnet";
+                    amoy: "amoy";
+                }>;
+                distributionId: import("zod").ZodString;
+                address: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>;
+            }, import("zod/v4/core").$strip>;
+        };
+        readonly responses: {
+            readonly 200: {
+                readonly description: "Proof bundle ready to submit to the claimer contract.";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            address: import("zod").ZodString;
+                            merkleRoot: import("zod").ZodString;
+                            amount: import("zod").ZodString;
+                            leafIndex: import("zod").ZodNumber;
+                            proof: import("zod").ZodArray<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+            readonly 404: {
+                readonly description: string;
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: import("zod").ZodObject<{
+                            error: import("zod").ZodLiteral<true>;
+                            message: import("zod").ZodString;
+                            info: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+            };
+        };
+    }>;
+}, {}>;
+//# sourceMappingURL=registry-public.d.ts.map