@polygonlabs/staker-pool-allocations-client 0.1.0

package/src/generated/registry-validator.gen.ts

@@ -0,0 +1,607 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import { AllocationHistoryResponse, AllocationListResponse, AllocationRow, DistributionDetail, DistributionListResponse, ErrorResponse, ExcludedAllocationsResponse, OperationalStatus, ProofResponse, UnclaimedProofsResponse, ValidationErrorResponse } from '@polygonlabs/staker-pool-allocations-schemas/codegen';
+import { z, type ZodError } from 'zod';
+
+import { getAddressAllocationHistory as getAddressAllocationHistory2, getAllocation as getAllocation2, getDistribution as getDistribution2, getHealthCheck as getHealthCheck2, getProof as getProof2, getReadiness as getReadiness2, getUnclaimedProofs as getUnclaimedProofs2, listAllocations as listAllocations2, listDistributions as listDistributions2, listExcludedAllocations as listExcludedAllocations2, type Options } from './sdk.gen.js';
+import type { GetAddressAllocationHistoryData, GetAllocationData, GetDistributionData, GetHealthCheckData, GetProofData, GetReadinessData, GetUnclaimedProofsData, ListAllocationsData, ListDistributionsData, ListExcludedAllocationsData } from './types.gen.js';
+
+export type GetHealthCheckResponses = {
+    200: z.output<typeof OperationalStatus>;
+};
+
+export type GetHealthCheckResponse = GetHealthCheckResponses[keyof GetHealthCheckResponses];
+
+export type GetHealthCheckErrors = {
+    500: z.output<typeof ErrorResponse>;
+};
+
+export type GetHealthCheckError = GetHealthCheckErrors[keyof GetHealthCheckErrors];
+
+export const getHealthCheckTransformer = async (data: unknown): Promise<z.output<typeof OperationalStatus>> => await OperationalStatus.parseAsync(data);
+
+export const getHealthCheckErrorTransformer = async (data: unknown): Promise<z.output<typeof ErrorResponse>> => await ErrorResponse.parseAsync(data);
+
+/**
+ * @internal — emitted by `@polygonlabs/zod-to-openapi-heyapi`. Do not
+ * instantiate from consumer code; the wrapper constructs these in
+ * response to fetch transport rejections (DNS / abort / `ECONNRESET`).
+ * Narrow via the emitted `isTransportError` type-predicate guard.
+ */
+export class TransportError extends Error {
+    readonly cause: Error;
+    constructor(cause: Error) {
+        super('Request failed before producing an HTTP response');
+        (this as Record<symbol, unknown>)[Symbol.for("@polygonlabs/zod-to-openapi-heyapi/is-transport-error")] = true;
+        this.cause = cause;
+        this.name = 'TransportError';
+    }
+}
+
+/**
+ * @internal — emitted by `@polygonlabs/zod-to-openapi-heyapi`. Do not
+ * instantiate from consumer code; the wrapper constructs these when
+ * `parseAsync` rejects an HTTP error body that did not match any
+ * registered error schema. `cause` carries the `ZodError` issues;
+ * `body` is the original wire body for debugging schema drift.
+ * Narrow via the emitted `isResponseValidationError` type-predicate guard.
+ */
+export class ResponseValidationError extends Error {
+    readonly cause: ZodError;
+    readonly body: unknown;
+    constructor(cause: ZodError, body: unknown) {
+        super('API response did not match the registered schema');
+        (this as Record<symbol, unknown>)[Symbol.for("@polygonlabs/zod-to-openapi-heyapi/is-response-validation-error")] = true;
+        this.cause = cause;
+        this.name = 'ResponseValidationError';
+        this.body = body;
+    }
+}
+
+export const isTransportError = (value: unknown): value is TransportError => typeof value === "object" && value !== null && (value as Record<symbol, unknown>)[Symbol.for("@polygonlabs/zod-to-openapi-heyapi/is-transport-error")] === true;
+
+export const isResponseValidationError = (value: unknown): value is ResponseValidationError => typeof value === "object" && value !== null && (value as Record<symbol, unknown>)[Symbol.for("@polygonlabs/zod-to-openapi-heyapi/is-response-validation-error")] === true;
+
+export const isWrapperError = (value: unknown): value is TransportError | ResponseValidationError => typeof value === "object" && value !== null && ((value as Record<symbol, unknown>)[Symbol.for("@polygonlabs/zod-to-openapi-heyapi/is-transport-error")] === true || (value as Record<symbol, unknown>)[Symbol.for("@polygonlabs/zod-to-openapi-heyapi/is-response-validation-error")] === true);
+
+export type WrapErrors<TData, TError, ThrowOnError extends boolean, TResponseStyle extends "fields" | "data" = 'fields'> = Promise<ThrowOnError extends true ? TResponseStyle extends "data" ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    request: Request;
+    response: Response;
+} : TResponseStyle extends "data" ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined : ({
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    error: undefined;
+} | {
+    data: undefined;
+    error: (TError extends Record<string, unknown> ? TError[keyof TError] : TError) | TransportError | ResponseValidationError;
+}) & {
+    request: Request;
+    response: Response;
+}>;
+
+export const getHealthCheck = async <ThrowOnError extends boolean = false, TResponseStyle extends 'fields' | 'data' = 'fields'>(options?: Options<GetHealthCheckData, ThrowOnError>): WrapErrors<GetHealthCheckResponses, GetHealthCheckErrors, ThrowOnError, TResponseStyle> => {
+    let result;
+    try {
+        result = await getHealthCheck2(options);
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            throw new TransportError(err as Error);
+        }
+        let typedErr;
+        try {
+            typedErr = await getHealthCheckErrorTransformer(err);
+        }
+        catch (validationError) {
+            throw new ResponseValidationError(validationError as ZodError, err);
+        }
+        throw typedErr;
+    }
+    const errorBearing = result as {
+        error?: unknown;
+    };
+    if (typeof result === "object" && result !== null && "request" in result && "response" in result && (typeof errorBearing.error === "object" && errorBearing.error !== null)) {
+        if (errorBearing.error instanceof Error) {
+            errorBearing.error = new TransportError(errorBearing.error as Error);
+        }
+        else {
+            try {
+                errorBearing.error = await getHealthCheckErrorTransformer(errorBearing.error);
+            }
+            catch (validationError) {
+                errorBearing.error = new ResponseValidationError(validationError as ZodError, errorBearing.error);
+            }
+        }
+    }
+    return result as unknown as Awaited<WrapErrors<GetHealthCheckResponses, GetHealthCheckErrors, ThrowOnError, TResponseStyle>>;
+};
+
+export type GetReadinessResponses = {
+    200: z.output<typeof OperationalStatus>;
+};
+
+export type GetReadinessResponse = GetReadinessResponses[keyof GetReadinessResponses];
+
+export type GetReadinessErrors = {
+    500: z.output<typeof ErrorResponse>;
+};
+
+export type GetReadinessError = GetReadinessErrors[keyof GetReadinessErrors];
+
+export const getReadinessTransformer = async (data: unknown): Promise<z.output<typeof OperationalStatus>> => await OperationalStatus.parseAsync(data);
+
+export const getReadinessErrorTransformer = async (data: unknown): Promise<z.output<typeof ErrorResponse>> => await ErrorResponse.parseAsync(data);
+
+export const getReadiness = async <ThrowOnError extends boolean = false, TResponseStyle extends 'fields' | 'data' = 'fields'>(options?: Options<GetReadinessData, ThrowOnError>): WrapErrors<GetReadinessResponses, GetReadinessErrors, ThrowOnError, TResponseStyle> => {
+    let result;
+    try {
+        result = await getReadiness2(options);
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            throw new TransportError(err as Error);
+        }
+        let typedErr;
+        try {
+            typedErr = await getReadinessErrorTransformer(err);
+        }
+        catch (validationError) {
+            throw new ResponseValidationError(validationError as ZodError, err);
+        }
+        throw typedErr;
+    }
+    const errorBearing = result as {
+        error?: unknown;
+    };
+    if (typeof result === "object" && result !== null && "request" in result && "response" in result && (typeof errorBearing.error === "object" && errorBearing.error !== null)) {
+        if (errorBearing.error instanceof Error) {
+            errorBearing.error = new TransportError(errorBearing.error as Error);
+        }
+        else {
+            try {
+                errorBearing.error = await getReadinessErrorTransformer(errorBearing.error);
+            }
+            catch (validationError) {
+                errorBearing.error = new ResponseValidationError(validationError as ZodError, errorBearing.error);
+            }
+        }
+    }
+    return result as unknown as Awaited<WrapErrors<GetReadinessResponses, GetReadinessErrors, ThrowOnError, TResponseStyle>>;
+};
+
+export type ListDistributionsResponses = {
+    200: z.output<typeof DistributionListResponse>;
+};
+
+export type ListDistributionsResponse = ListDistributionsResponses[keyof ListDistributionsResponses];
+
+export type ListDistributionsErrors = {
+    400: z.output<typeof ErrorResponse>;
+    500: z.output<typeof ErrorResponse>;
+};
+
+export type ListDistributionsError = ListDistributionsErrors[keyof ListDistributionsErrors];
+
+export const listDistributionsTransformer = async (data: unknown): Promise<z.output<typeof DistributionListResponse>> => await DistributionListResponse.parseAsync(data);
+
+export const listDistributionsErrorTransformer = async (data: unknown): Promise<z.output<typeof ErrorResponse>> => await ErrorResponse.parseAsync(data);
+
+export const listDistributions = async <ThrowOnError extends boolean = false, TResponseStyle extends 'fields' | 'data' = 'fields'>(options: Options<ListDistributionsData, ThrowOnError>): WrapErrors<ListDistributionsResponses, ListDistributionsErrors, ThrowOnError, TResponseStyle> => {
+    let result;
+    try {
+        result = await listDistributions2(options);
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            throw new TransportError(err as Error);
+        }
+        let typedErr;
+        try {
+            typedErr = await listDistributionsErrorTransformer(err);
+        }
+        catch (validationError) {
+            throw new ResponseValidationError(validationError as ZodError, err);
+        }
+        throw typedErr;
+    }
+    const errorBearing = result as {
+        error?: unknown;
+    };
+    if (typeof result === "object" && result !== null && "request" in result && "response" in result && (typeof errorBearing.error === "object" && errorBearing.error !== null)) {
+        if (errorBearing.error instanceof Error) {
+            errorBearing.error = new TransportError(errorBearing.error as Error);
+        }
+        else {
+            try {
+                errorBearing.error = await listDistributionsErrorTransformer(errorBearing.error);
+            }
+            catch (validationError) {
+                errorBearing.error = new ResponseValidationError(validationError as ZodError, errorBearing.error);
+            }
+        }
+    }
+    return result as unknown as Awaited<WrapErrors<ListDistributionsResponses, ListDistributionsErrors, ThrowOnError, TResponseStyle>>;
+};
+
+export type GetDistributionResponses = {
+    200: z.output<typeof DistributionDetail>;
+};
+
+export type GetDistributionResponse = GetDistributionResponses[keyof GetDistributionResponses];
+
+export type GetDistributionErrors = {
+    400: z.output<typeof ValidationErrorResponse>;
+    404: z.output<typeof ErrorResponse>;
+    500: z.output<typeof ErrorResponse>;
+};
+
+export type GetDistributionError = GetDistributionErrors[keyof GetDistributionErrors];
+
+export const getDistributionTransformer = async (data: unknown): Promise<z.output<typeof DistributionDetail>> => await DistributionDetail.parseAsync(data);
+
+export const getDistributionErrorTransformer = async (data: unknown): Promise<z.output<typeof ValidationErrorResponse> | z.output<typeof ErrorResponse>> => await z.union([ValidationErrorResponse, ErrorResponse]).parseAsync(data);
+
+export const getDistribution = async <ThrowOnError extends boolean = false, TResponseStyle extends 'fields' | 'data' = 'fields'>(options: Options<GetDistributionData, ThrowOnError>): WrapErrors<GetDistributionResponses, GetDistributionErrors, ThrowOnError, TResponseStyle> => {
+    let result;
+    try {
+        result = await getDistribution2(options);
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            throw new TransportError(err as Error);
+        }
+        let typedErr;
+        try {
+            typedErr = await getDistributionErrorTransformer(err);
+        }
+        catch (validationError) {
+            throw new ResponseValidationError(validationError as ZodError, err);
+        }
+        throw typedErr;
+    }
+    const errorBearing = result as {
+        error?: unknown;
+    };
+    if (typeof result === "object" && result !== null && "request" in result && "response" in result && (typeof errorBearing.error === "object" && errorBearing.error !== null)) {
+        if (errorBearing.error instanceof Error) {
+            errorBearing.error = new TransportError(errorBearing.error as Error);
+        }
+        else {
+            try {
+                errorBearing.error = await getDistributionErrorTransformer(errorBearing.error);
+            }
+            catch (validationError) {
+                errorBearing.error = new ResponseValidationError(validationError as ZodError, errorBearing.error);
+            }
+        }
+    }
+    return result as unknown as Awaited<WrapErrors<GetDistributionResponses, GetDistributionErrors, ThrowOnError, TResponseStyle>>;
+};
+
+export type ListAllocationsResponses = {
+    200: z.output<typeof AllocationListResponse>;
+};
+
+export type ListAllocationsResponse = ListAllocationsResponses[keyof ListAllocationsResponses];
+
+export type ListAllocationsErrors = {
+    400: z.output<typeof ErrorResponse>;
+    404: z.output<typeof ErrorResponse>;
+    500: z.output<typeof ErrorResponse>;
+};
+
+export type ListAllocationsError = ListAllocationsErrors[keyof ListAllocationsErrors];
+
+export const listAllocationsTransformer = async (data: unknown): Promise<z.output<typeof AllocationListResponse>> => await AllocationListResponse.parseAsync(data);
+
+export const listAllocationsErrorTransformer = async (data: unknown): Promise<z.output<typeof ErrorResponse>> => await ErrorResponse.parseAsync(data);
+
+export const listAllocations = async <ThrowOnError extends boolean = false, TResponseStyle extends 'fields' | 'data' = 'fields'>(options: Options<ListAllocationsData, ThrowOnError>): WrapErrors<ListAllocationsResponses, ListAllocationsErrors, ThrowOnError, TResponseStyle> => {
+    let result;
+    try {
+        result = await listAllocations2(options);
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            throw new TransportError(err as Error);
+        }
+        let typedErr;
+        try {
+            typedErr = await listAllocationsErrorTransformer(err);
+        }
+        catch (validationError) {
+            throw new ResponseValidationError(validationError as ZodError, err);
+        }
+        throw typedErr;
+    }
+    const errorBearing = result as {
+        error?: unknown;
+    };
+    if (typeof result === "object" && result !== null && "request" in result && "response" in result && (typeof errorBearing.error === "object" && errorBearing.error !== null)) {
+        if (errorBearing.error instanceof Error) {
+            errorBearing.error = new TransportError(errorBearing.error as Error);
+        }
+        else {
+            try {
+                errorBearing.error = await listAllocationsErrorTransformer(errorBearing.error);
+            }
+            catch (validationError) {
+                errorBearing.error = new ResponseValidationError(validationError as ZodError, errorBearing.error);
+            }
+        }
+    }
+    return result as unknown as Awaited<WrapErrors<ListAllocationsResponses, ListAllocationsErrors, ThrowOnError, TResponseStyle>>;
+};
+
+export type ListExcludedAllocationsResponses = {
+    200: z.output<typeof ExcludedAllocationsResponse>;
+};
+
+export type ListExcludedAllocationsResponse = ListExcludedAllocationsResponses[keyof ListExcludedAllocationsResponses];
+
+export type ListExcludedAllocationsErrors = {
+    400: z.output<typeof ValidationErrorResponse>;
+    404: z.output<typeof ErrorResponse>;
+    500: z.output<typeof ErrorResponse>;
+};
+
+export type ListExcludedAllocationsError = ListExcludedAllocationsErrors[keyof ListExcludedAllocationsErrors];
+
+export const listExcludedAllocationsTransformer = async (data: unknown): Promise<z.output<typeof ExcludedAllocationsResponse>> => await ExcludedAllocationsResponse.parseAsync(data);
+
+export const listExcludedAllocationsErrorTransformer = async (data: unknown): Promise<z.output<typeof ValidationErrorResponse> | z.output<typeof ErrorResponse>> => await z.union([ValidationErrorResponse, ErrorResponse]).parseAsync(data);
+
+export const listExcludedAllocations = async <ThrowOnError extends boolean = false, TResponseStyle extends 'fields' | 'data' = 'fields'>(options: Options<ListExcludedAllocationsData, ThrowOnError>): WrapErrors<ListExcludedAllocationsResponses, ListExcludedAllocationsErrors, ThrowOnError, TResponseStyle> => {
+    let result;
+    try {
+        result = await listExcludedAllocations2(options);
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            throw new TransportError(err as Error);
+        }
+        let typedErr;
+        try {
+            typedErr = await listExcludedAllocationsErrorTransformer(err);
+        }
+        catch (validationError) {
+            throw new ResponseValidationError(validationError as ZodError, err);
+        }
+        throw typedErr;
+    }
+    const errorBearing = result as {
+        error?: unknown;
+    };
+    if (typeof result === "object" && result !== null && "request" in result && "response" in result && (typeof errorBearing.error === "object" && errorBearing.error !== null)) {
+        if (errorBearing.error instanceof Error) {
+            errorBearing.error = new TransportError(errorBearing.error as Error);
+        }
+        else {
+            try {
+                errorBearing.error = await listExcludedAllocationsErrorTransformer(errorBearing.error);
+            }
+            catch (validationError) {
+                errorBearing.error = new ResponseValidationError(validationError as ZodError, errorBearing.error);
+            }
+        }
+    }
+    return result as unknown as Awaited<WrapErrors<ListExcludedAllocationsResponses, ListExcludedAllocationsErrors, ThrowOnError, TResponseStyle>>;
+};
+
+export type GetAllocationResponses = {
+    200: z.output<typeof AllocationRow>;
+};
+
+export type GetAllocationResponse = GetAllocationResponses[keyof GetAllocationResponses];
+
+export type GetAllocationErrors = {
+    400: z.output<typeof ValidationErrorResponse>;
+    404: z.output<typeof ErrorResponse>;
+    500: z.output<typeof ErrorResponse>;
+};
+
+export type GetAllocationError = GetAllocationErrors[keyof GetAllocationErrors];
+
+export const getAllocationTransformer = async (data: unknown): Promise<z.output<typeof AllocationRow>> => await AllocationRow.parseAsync(data);
+
+export const getAllocationErrorTransformer = async (data: unknown): Promise<z.output<typeof ValidationErrorResponse> | z.output<typeof ErrorResponse>> => await z.union([ValidationErrorResponse, ErrorResponse]).parseAsync(data);
+
+export const getAllocation = async <ThrowOnError extends boolean = false, TResponseStyle extends 'fields' | 'data' = 'fields'>(options: Options<GetAllocationData, ThrowOnError>): WrapErrors<GetAllocationResponses, GetAllocationErrors, ThrowOnError, TResponseStyle> => {
+    let result;
+    try {
+        result = await getAllocation2(options);
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            throw new TransportError(err as Error);
+        }
+        let typedErr;
+        try {
+            typedErr = await getAllocationErrorTransformer(err);
+        }
+        catch (validationError) {
+            throw new ResponseValidationError(validationError as ZodError, err);
+        }
+        throw typedErr;
+    }
+    const errorBearing = result as {
+        error?: unknown;
+    };
+    if (typeof result === "object" && result !== null && "request" in result && "response" in result && (typeof errorBearing.error === "object" && errorBearing.error !== null)) {
+        if (errorBearing.error instanceof Error) {
+            errorBearing.error = new TransportError(errorBearing.error as Error);
+        }
+        else {
+            try {
+                errorBearing.error = await getAllocationErrorTransformer(errorBearing.error);
+            }
+            catch (validationError) {
+                errorBearing.error = new ResponseValidationError(validationError as ZodError, errorBearing.error);
+            }
+        }
+    }
+    return result as unknown as Awaited<WrapErrors<GetAllocationResponses, GetAllocationErrors, ThrowOnError, TResponseStyle>>;
+};
+
+export type GetAddressAllocationHistoryResponses = {
+    200: z.output<typeof AllocationHistoryResponse>;
+};
+
+export type GetAddressAllocationHistoryResponse = GetAddressAllocationHistoryResponses[keyof GetAddressAllocationHistoryResponses];
+
+export type GetAddressAllocationHistoryErrors = {
+    400: z.output<typeof ValidationErrorResponse>;
+    500: z.output<typeof ErrorResponse>;
+};
+
+export type GetAddressAllocationHistoryError = GetAddressAllocationHistoryErrors[keyof GetAddressAllocationHistoryErrors];
+
+export const getAddressAllocationHistoryTransformer = async (data: unknown): Promise<z.output<typeof AllocationHistoryResponse>> => await AllocationHistoryResponse.parseAsync(data);
+
+export const getAddressAllocationHistoryErrorTransformer = async (data: unknown): Promise<z.output<typeof ValidationErrorResponse> | z.output<typeof ErrorResponse>> => await z.union([ValidationErrorResponse, ErrorResponse]).parseAsync(data);
+
+export const getAddressAllocationHistory = async <ThrowOnError extends boolean = false, TResponseStyle extends 'fields' | 'data' = 'fields'>(options: Options<GetAddressAllocationHistoryData, ThrowOnError>): WrapErrors<GetAddressAllocationHistoryResponses, GetAddressAllocationHistoryErrors, ThrowOnError, TResponseStyle> => {
+    let result;
+    try {
+        result = await getAddressAllocationHistory2(options);
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            throw new TransportError(err as Error);
+        }
+        let typedErr;
+        try {
+            typedErr = await getAddressAllocationHistoryErrorTransformer(err);
+        }
+        catch (validationError) {
+            throw new ResponseValidationError(validationError as ZodError, err);
+        }
+        throw typedErr;
+    }
+    const errorBearing = result as {
+        error?: unknown;
+    };
+    if (typeof result === "object" && result !== null && "request" in result && "response" in result && (typeof errorBearing.error === "object" && errorBearing.error !== null)) {
+        if (errorBearing.error instanceof Error) {
+            errorBearing.error = new TransportError(errorBearing.error as Error);
+        }
+        else {
+            try {
+                errorBearing.error = await getAddressAllocationHistoryErrorTransformer(errorBearing.error);
+            }
+            catch (validationError) {
+                errorBearing.error = new ResponseValidationError(validationError as ZodError, errorBearing.error);
+            }
+        }
+    }
+    return result as unknown as Awaited<WrapErrors<GetAddressAllocationHistoryResponses, GetAddressAllocationHistoryErrors, ThrowOnError, TResponseStyle>>;
+};
+
+export type GetUnclaimedProofsResponses = {
+    200: z.output<typeof UnclaimedProofsResponse>;
+};
+
+export type GetUnclaimedProofsResponse = GetUnclaimedProofsResponses[keyof GetUnclaimedProofsResponses];
+
+export type GetUnclaimedProofsErrors = {
+    400: z.output<typeof ValidationErrorResponse>;
+    500: z.output<typeof ErrorResponse>;
+};
+
+export type GetUnclaimedProofsError = GetUnclaimedProofsErrors[keyof GetUnclaimedProofsErrors];
+
+export const getUnclaimedProofsTransformer = async (data: unknown): Promise<z.output<typeof UnclaimedProofsResponse>> => await UnclaimedProofsResponse.parseAsync(data);
+
+export const getUnclaimedProofsErrorTransformer = async (data: unknown): Promise<z.output<typeof ValidationErrorResponse> | z.output<typeof ErrorResponse>> => await z.union([ValidationErrorResponse, ErrorResponse]).parseAsync(data);
+
+export const getUnclaimedProofs = async <ThrowOnError extends boolean = false, TResponseStyle extends 'fields' | 'data' = 'fields'>(options: Options<GetUnclaimedProofsData, ThrowOnError>): WrapErrors<GetUnclaimedProofsResponses, GetUnclaimedProofsErrors, ThrowOnError, TResponseStyle> => {
+    let result;
+    try {
+        result = await getUnclaimedProofs2(options);
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            throw new TransportError(err as Error);
+        }
+        let typedErr;
+        try {
+            typedErr = await getUnclaimedProofsErrorTransformer(err);
+        }
+        catch (validationError) {
+            throw new ResponseValidationError(validationError as ZodError, err);
+        }
+        throw typedErr;
+    }
+    const errorBearing = result as {
+        error?: unknown;
+    };
+    if (typeof result === "object" && result !== null && "request" in result && "response" in result && (typeof errorBearing.error === "object" && errorBearing.error !== null)) {
+        if (errorBearing.error instanceof Error) {
+            errorBearing.error = new TransportError(errorBearing.error as Error);
+        }
+        else {
+            try {
+                errorBearing.error = await getUnclaimedProofsErrorTransformer(errorBearing.error);
+            }
+            catch (validationError) {
+                errorBearing.error = new ResponseValidationError(validationError as ZodError, errorBearing.error);
+            }
+        }
+    }
+    return result as unknown as Awaited<WrapErrors<GetUnclaimedProofsResponses, GetUnclaimedProofsErrors, ThrowOnError, TResponseStyle>>;
+};
+
+export type GetProofResponses = {
+    200: z.output<typeof ProofResponse>;
+};
+
+export type GetProofResponse = GetProofResponses[keyof GetProofResponses];
+
+export type GetProofErrors = {
+    400: z.output<typeof ValidationErrorResponse>;
+    404: z.output<typeof ErrorResponse>;
+    500: z.output<typeof ErrorResponse>;
+};
+
+export type GetProofError = GetProofErrors[keyof GetProofErrors];
+
+export const getProofTransformer = async (data: unknown): Promise<z.output<typeof ProofResponse>> => await ProofResponse.parseAsync(data);
+
+export const getProofErrorTransformer = async (data: unknown): Promise<z.output<typeof ValidationErrorResponse> | z.output<typeof ErrorResponse>> => await z.union([ValidationErrorResponse, ErrorResponse]).parseAsync(data);
+
+export const getProof = async <ThrowOnError extends boolean = false, TResponseStyle extends 'fields' | 'data' = 'fields'>(options: Options<GetProofData, ThrowOnError>): WrapErrors<GetProofResponses, GetProofErrors, ThrowOnError, TResponseStyle> => {
+    let result;
+    try {
+        result = await getProof2(options);
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            throw new TransportError(err as Error);
+        }
+        let typedErr;
+        try {
+            typedErr = await getProofErrorTransformer(err);
+        }
+        catch (validationError) {
+            throw new ResponseValidationError(validationError as ZodError, err);
+        }
+        throw typedErr;
+    }
+    const errorBearing = result as {
+        error?: unknown;
+    };
+    if (typeof result === "object" && result !== null && "request" in result && "response" in result && (typeof errorBearing.error === "object" && errorBearing.error !== null)) {
+        if (errorBearing.error instanceof Error) {
+            errorBearing.error = new TransportError(errorBearing.error as Error);
+        }
+        else {
+            try {
+                errorBearing.error = await getProofErrorTransformer(errorBearing.error);
+            }
+            catch (validationError) {
+                errorBearing.error = new ResponseValidationError(validationError as ZodError, errorBearing.error);
+            }
+        }
+    }
+    return result as unknown as Awaited<WrapErrors<GetProofResponses, GetProofErrors, ThrowOnError, TResponseStyle>>;
+};