@compass-labs/api-sdk 2.1.1-rc.1 → 2.1.2-rc.1

package/src/models/components/vaultwithdrawrequest.ts

@@ -4,10 +4,7 @@
 
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
-import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
-import { Result as SafeParseResult } from "../../types/fp.js";
-import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export const VaultWithdrawRequestChain = {
   Arbitrum: "arbitrum",
@@ -43,35 +40,11 @@ export type VaultWithdrawRequest = {
   estimateGas?: boolean | undefined;
 };
 
-/** @internal */
-export const VaultWithdrawRequestChain$inboundSchema: z.ZodNativeEnum<
-  typeof VaultWithdrawRequestChain
-> = z.nativeEnum(VaultWithdrawRequestChain);
 /** @internal */
 export const VaultWithdrawRequestChain$outboundSchema: z.ZodNativeEnum<
   typeof VaultWithdrawRequestChain
-> = VaultWithdrawRequestChain$inboundSchema;
+> = z.nativeEnum(VaultWithdrawRequestChain);
 
-/** @internal */
-export const VaultWithdrawRequest$inboundSchema: z.ZodType<
-  VaultWithdrawRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  action_type: z.literal("VAULT_WITHDRAW").default("VAULT_WITHDRAW").optional(),
-  vault_address: z.string(),
-  amount: z.any().optional(),
-  receiver: z.nullable(z.string()).optional(),
-  chain: VaultWithdrawRequestChain$inboundSchema,
-  sender: z.string(),
-  estimate_gas: z.boolean().optional(),
-}).transform((v) => {
-  return remap$(v, {
-    "action_type": "actionType",
-    "vault_address": "vaultAddress",
-    "estimate_gas": "estimateGas",
-  });
-});
 /** @internal */
 export type VaultWithdrawRequest$Outbound = {
   action_type: "VAULT_WITHDRAW";
@@ -111,12 +84,3 @@ export function vaultWithdrawRequestToJSON(
     VaultWithdrawRequest$outboundSchema.parse(vaultWithdrawRequest),
   );
 }
-export function vaultWithdrawRequestFromJSON(
-  jsonString: string,
-): SafeParseResult<VaultWithdrawRequest, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => VaultWithdrawRequest$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'VaultWithdrawRequest' from JSON`,
-  );
-}

package/src/models/components/weeklyapys.ts

@@ -25,29 +25,7 @@ export const WeeklyApys$inboundSchema: z.ZodType<
   borrowApy: z.number(),
   netBorrowApy: z.number(),
 });
-/** @internal */
-export type WeeklyApys$Outbound = {
-  supplyApy: number;
-  netSupplyApy: number;
-  borrowApy: number;
-  netBorrowApy: number;
-};
-
-/** @internal */
-export const WeeklyApys$outboundSchema: z.ZodType<
-  WeeklyApys$Outbound,
-  z.ZodTypeDef,
-  WeeklyApys
-> = z.object({
-  supplyApy: z.number(),
-  netSupplyApy: z.number(),
-  borrowApy: z.number(),
-  netBorrowApy: z.number(),
-});
 
-export function weeklyApysToJSON(weeklyApys: WeeklyApys): string {
-  return JSON.stringify(WeeklyApys$outboundSchema.parse(weeklyApys));
-}
 export function weeklyApysFromJSON(
   jsonString: string,
 ): SafeParseResult<WeeklyApys, SDKValidationError> {

package/src/models/components/wildcatgetmarketresponse.ts

@@ -10,14 +10,10 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   CompassApiBackendV1ModelsWildcatReadResponseMarketUserPosition,
   CompassApiBackendV1ModelsWildcatReadResponseMarketUserPosition$inboundSchema,
-  CompassApiBackendV1ModelsWildcatReadResponseMarketUserPosition$Outbound,
-  CompassApiBackendV1ModelsWildcatReadResponseMarketUserPosition$outboundSchema,
 } from "./compassapibackendv1modelswildcatreadresponsemarketuserposition.js";
 import {
   UnderlyingToken,
   UnderlyingToken$inboundSchema,
-  UnderlyingToken$Outbound,
-  UnderlyingToken$outboundSchema,
 } from "./underlyingtoken.js";
 
 export type WildcatGetMarketResponse = {
@@ -145,86 +141,7 @@ export const WildcatGetMarketResponse$inboundSchema: z.ZodType<
     "user_position": "userPosition",
   });
 });
-/** @internal */
-export type WildcatGetMarketResponse$Outbound = {
-  market_address: string;
-  name: string;
-  symbol: string;
-  decimals: number;
-  available_to_lend: string;
-  loaned: string;
-  max_borrowing_capacity: string;
-  gross_interest_accrued: string;
-  minimum_deposit: string;
-  minimum_reserve_ratio: string;
-  base_lender_apr: string;
-  protocol_fee_apr: string;
-  effective_lender_apr: string;
-  penalty_apr: string;
-  maximum_grace_period: number;
-  available_grace_period: number;
-  withdrawal_cycle_duration: number;
-  underlying_token: UnderlyingToken$Outbound;
-  user_position?:
-    | CompassApiBackendV1ModelsWildcatReadResponseMarketUserPosition$Outbound
-    | null
-    | undefined;
-};
 
-/** @internal */
-export const WildcatGetMarketResponse$outboundSchema: z.ZodType<
-  WildcatGetMarketResponse$Outbound,
-  z.ZodTypeDef,
-  WildcatGetMarketResponse
-> = z.object({
-  marketAddress: z.string(),
-  name: z.string(),
-  symbol: z.string(),
-  decimals: z.number().int(),
-  availableToLend: z.string(),
-  loaned: z.string(),
-  maxBorrowingCapacity: z.string(),
-  grossInterestAccrued: z.string(),
-  minimumDeposit: z.string(),
-  minimumReserveRatio: z.string(),
-  baseLenderApr: z.string(),
-  protocolFeeApr: z.string(),
-  effectiveLenderApr: z.string(),
-  penaltyApr: z.string(),
-  maximumGracePeriod: z.number().int(),
-  availableGracePeriod: z.number().int(),
-  withdrawalCycleDuration: z.number().int(),
-  underlyingToken: UnderlyingToken$outboundSchema,
-  userPosition: z.nullable(
-    CompassApiBackendV1ModelsWildcatReadResponseMarketUserPosition$outboundSchema,
-  ).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    marketAddress: "market_address",
-    availableToLend: "available_to_lend",
-    maxBorrowingCapacity: "max_borrowing_capacity",
-    grossInterestAccrued: "gross_interest_accrued",
-    minimumDeposit: "minimum_deposit",
-    minimumReserveRatio: "minimum_reserve_ratio",
-    baseLenderApr: "base_lender_apr",
-    protocolFeeApr: "protocol_fee_apr",
-    effectiveLenderApr: "effective_lender_apr",
-    penaltyApr: "penalty_apr",
-    maximumGracePeriod: "maximum_grace_period",
-    availableGracePeriod: "available_grace_period",
-    withdrawalCycleDuration: "withdrawal_cycle_duration",
-    underlyingToken: "underlying_token",
-    userPosition: "user_position",
-  });
-});
-
-export function wildcatGetMarketResponseToJSON(
-  wildcatGetMarketResponse: WildcatGetMarketResponse,
-): string {
-  return JSON.stringify(
-    WildcatGetMarketResponse$outboundSchema.parse(wildcatGetMarketResponse),
-  );
-}
 export function wildcatGetMarketResponseFromJSON(
   jsonString: string,
 ): SafeParseResult<WildcatGetMarketResponse, SDKValidationError> {

package/src/models/components/withdraw.ts

@@ -6,12 +6,7 @@ import * as z from "zod/v3";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
-import {
-  Reserve,
-  Reserve$inboundSchema,
-  Reserve$Outbound,
-  Reserve$outboundSchema,
-} from "./reserve.js";
+import { Reserve, Reserve$inboundSchema } from "./reserve.js";
 
 export type Withdraw = {
   /**
@@ -57,37 +52,7 @@ export const Withdraw$inboundSchema: z.ZodType<
   action: z.string(),
   block: z.number().int(),
 });
-/** @internal */
-export type Withdraw$Outbound = {
-  id: string;
-  timestamp: number;
-  txHash: string;
-  amount: number;
-  reserve: Reserve$Outbound;
-  assetPriceUSD: number;
-  action: string;
-  block: number;
-};
-
-/** @internal */
-export const Withdraw$outboundSchema: z.ZodType<
-  Withdraw$Outbound,
-  z.ZodTypeDef,
-  Withdraw
-> = z.object({
-  id: z.string(),
-  timestamp: z.number().int(),
-  txHash: z.string(),
-  amount: z.number(),
-  reserve: Reserve$outboundSchema,
-  assetPriceUSD: z.number(),
-  action: z.string(),
-  block: z.number().int(),
-});
 
-export function withdrawToJSON(withdraw: Withdraw): string {
-  return JSON.stringify(Withdraw$outboundSchema.parse(withdraw));
-}
 export function withdrawFromJSON(
   jsonString: string,
 ): SafeParseResult<Withdraw, SDKValidationError> {

package/src/models/components/wrapethparams.ts

@@ -4,9 +4,6 @@
 
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
-import { safeParse } from "../../lib/schemas.js";
-import { Result as SafeParseResult } from "../../types/fp.js";
-import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
  * The amount of ETH to wrap.
@@ -24,12 +21,6 @@ export type WrapEthParams = {
   amount: number | string;
 };
 
-/** @internal */
-export const WrapEthParamsAmount$inboundSchema: z.ZodType<
-  WrapEthParamsAmount,
-  z.ZodTypeDef,
-  unknown
-> = z.union([z.number(), z.string()]);
 /** @internal */
 export type WrapEthParamsAmount$Outbound = number | string;
 
@@ -47,29 +38,7 @@ export function wrapEthParamsAmountToJSON(
     WrapEthParamsAmount$outboundSchema.parse(wrapEthParamsAmount),
   );
 }
-export function wrapEthParamsAmountFromJSON(
-  jsonString: string,
-): SafeParseResult<WrapEthParamsAmount, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => WrapEthParamsAmount$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'WrapEthParamsAmount' from JSON`,
-  );
-}
 
-/** @internal */
-export const WrapEthParams$inboundSchema: z.ZodType<
-  WrapEthParams,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  action_type: z.literal("WRAP_ETH").default("WRAP_ETH").optional(),
-  amount: z.union([z.number(), z.string()]),
-}).transform((v) => {
-  return remap$(v, {
-    "action_type": "actionType",
-  });
-});
 /** @internal */
 export type WrapEthParams$Outbound = {
   action_type: "WRAP_ETH";
@@ -93,12 +62,3 @@ export const WrapEthParams$outboundSchema: z.ZodType<
 export function wrapEthParamsToJSON(wrapEthParams: WrapEthParams): string {
   return JSON.stringify(WrapEthParams$outboundSchema.parse(wrapEthParams));
 }
-export function wrapEthParamsFromJSON(
-  jsonString: string,
-): SafeParseResult<WrapEthParams, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => WrapEthParams$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'WrapEthParams' from JSON`,
-  );
-}

package/src/models/components/wrapethrequest.ts

@@ -4,10 +4,7 @@
 
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
-import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
-import { Result as SafeParseResult } from "../../types/fp.js";
-import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
  * The amount of ETH to wrap.
@@ -41,12 +38,6 @@ export type WrapEthRequest = {
   estimateGas?: boolean | undefined;
 };
 
-/** @internal */
-export const WrapEthRequestAmount$inboundSchema: z.ZodType<
-  WrapEthRequestAmount,
-  z.ZodTypeDef,
-  unknown
-> = z.union([z.number(), z.string()]);
 /** @internal */
 export type WrapEthRequestAmount$Outbound = number | string;
 
@@ -64,42 +55,12 @@ export function wrapEthRequestAmountToJSON(
     WrapEthRequestAmount$outboundSchema.parse(wrapEthRequestAmount),
   );
 }
-export function wrapEthRequestAmountFromJSON(
-  jsonString: string,
-): SafeParseResult<WrapEthRequestAmount, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => WrapEthRequestAmount$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'WrapEthRequestAmount' from JSON`,
-  );
-}
 
-/** @internal */
-export const WrapEthRequestChain$inboundSchema: z.ZodNativeEnum<
-  typeof WrapEthRequestChain
-> = z.nativeEnum(WrapEthRequestChain);
 /** @internal */
 export const WrapEthRequestChain$outboundSchema: z.ZodNativeEnum<
   typeof WrapEthRequestChain
-> = WrapEthRequestChain$inboundSchema;
+> = z.nativeEnum(WrapEthRequestChain);
 
-/** @internal */
-export const WrapEthRequest$inboundSchema: z.ZodType<
-  WrapEthRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  action_type: z.literal("WRAP_ETH").default("WRAP_ETH").optional(),
-  amount: z.union([z.number(), z.string()]),
-  chain: WrapEthRequestChain$inboundSchema,
-  sender: z.string(),
-  estimate_gas: z.boolean().optional(),
-}).transform((v) => {
-  return remap$(v, {
-    "action_type": "actionType",
-    "estimate_gas": "estimateGas",
-  });
-});
 /** @internal */
 export type WrapEthRequest$Outbound = {
   action_type: "WRAP_ETH";
@@ -130,12 +91,3 @@ export const WrapEthRequest$outboundSchema: z.ZodType<
 export function wrapEthRequestToJSON(wrapEthRequest: WrapEthRequest): string {
   return JSON.stringify(WrapEthRequest$outboundSchema.parse(wrapEthRequest));
 }
-export function wrapEthRequestFromJSON(
-  jsonString: string,
-): SafeParseResult<WrapEthRequest, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => WrapEthRequest$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'WrapEthRequest' from JSON`,
-  );
-}

package/src/models/components/yieldrange.ts

@@ -21,25 +21,7 @@ export const YieldRange$inboundSchema: z.ZodType<
   min: z.number(),
   max: z.number(),
 });
-/** @internal */
-export type YieldRange$Outbound = {
-  min: number;
-  max: number;
-};
-
-/** @internal */
-export const YieldRange$outboundSchema: z.ZodType<
-  YieldRange$Outbound,
-  z.ZodTypeDef,
-  YieldRange
-> = z.object({
-  min: z.number(),
-  max: z.number(),
-});
 
-export function yieldRangeToJSON(yieldRange: YieldRange): string {
-  return JSON.stringify(YieldRange$outboundSchema.parse(yieldRange));
-}
 export function yieldRangeFromJSON(
   jsonString: string,
 ): SafeParseResult<YieldRange, SDKValidationError> {

package/src/models/errors/httpvalidationerror.ts

@@ -49,19 +49,3 @@ export const HTTPValidationError$inboundSchema: z.ZodType<
       body: v.body$,
     });
   });
-
-/** @internal */
-export type HTTPValidationError$Outbound = {
-  detail?: Array<components.ValidationError$Outbound> | undefined;
-};
-
-/** @internal */
-export const HTTPValidationError$outboundSchema: z.ZodType<
-  HTTPValidationError$Outbound,
-  z.ZodTypeDef,
-  HTTPValidationError
-> = z.instanceof(HTTPValidationError)
-  .transform(v => v.data$)
-  .pipe(z.object({
-    detail: z.array(components.ValidationError$outboundSchema).optional(),
-  }));

package/src/models/operations/v1aaveaavesupportedtokens.ts

@@ -3,10 +3,7 @@
  */
 
 import * as z from "zod/v3";
-import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
-import { Result as SafeParseResult } from "../../types/fp.js";
-import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export const V1AaveAaveSupportedTokensChain = {
   Arbitrum: "arbitrum",
@@ -25,24 +22,11 @@ export type V1AaveAaveSupportedTokensRequest = {
   block?: number | null | undefined;
 };
 
-/** @internal */
-export const V1AaveAaveSupportedTokensChain$inboundSchema: z.ZodNativeEnum<
-  typeof V1AaveAaveSupportedTokensChain
-> = z.nativeEnum(V1AaveAaveSupportedTokensChain);
 /** @internal */
 export const V1AaveAaveSupportedTokensChain$outboundSchema: z.ZodNativeEnum<
   typeof V1AaveAaveSupportedTokensChain
-> = V1AaveAaveSupportedTokensChain$inboundSchema;
+> = z.nativeEnum(V1AaveAaveSupportedTokensChain);
 
-/** @internal */
-export const V1AaveAaveSupportedTokensRequest$inboundSchema: z.ZodType<
-  V1AaveAaveSupportedTokensRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  chain: V1AaveAaveSupportedTokensChain$inboundSchema,
-  block: z.nullable(z.number().int()).optional(),
-});
 /** @internal */
 export type V1AaveAaveSupportedTokensRequest$Outbound = {
   chain: string;
@@ -68,12 +52,3 @@ export function v1AaveAaveSupportedTokensRequestToJSON(
     ),
   );
 }
-export function v1AaveAaveSupportedTokensRequestFromJSON(
-  jsonString: string,
-): SafeParseResult<V1AaveAaveSupportedTokensRequest, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => V1AaveAaveSupportedTokensRequest$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'V1AaveAaveSupportedTokensRequest' from JSON`,
-  );
-}

package/src/models/operations/v1aaveavgrate.ts

@@ -3,10 +3,7 @@
  */
 
 import * as z from "zod/v3";
-import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
-import { Result as SafeParseResult } from "../../types/fp.js";
-import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export const V1AaveAvgRateChain = {
   Arbitrum: "arbitrum",
@@ -31,26 +28,11 @@ export type V1AaveAvgRateRequest = {
   days: number;
 };
 
-/** @internal */
-export const V1AaveAvgRateChain$inboundSchema: z.ZodNativeEnum<
-  typeof V1AaveAvgRateChain
-> = z.nativeEnum(V1AaveAvgRateChain);
 /** @internal */
 export const V1AaveAvgRateChain$outboundSchema: z.ZodNativeEnum<
   typeof V1AaveAvgRateChain
-> = V1AaveAvgRateChain$inboundSchema;
+> = z.nativeEnum(V1AaveAvgRateChain);
 
-/** @internal */
-export const V1AaveAvgRateRequest$inboundSchema: z.ZodType<
-  V1AaveAvgRateRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  chain: V1AaveAvgRateChain$inboundSchema,
-  block: z.nullable(z.number().int()).optional(),
-  token: z.string(),
-  days: z.number().int(),
-});
 /** @internal */
 export type V1AaveAvgRateRequest$Outbound = {
   chain: string;
@@ -78,12 +60,3 @@ export function v1AaveAvgRateRequestToJSON(
     V1AaveAvgRateRequest$outboundSchema.parse(v1AaveAvgRateRequest),
   );
 }
-export function v1AaveAvgRateRequestFromJSON(
-  jsonString: string,
-): SafeParseResult<V1AaveAvgRateRequest, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => V1AaveAvgRateRequest$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'V1AaveAvgRateRequest' from JSON`,
-  );
-}

package/src/models/operations/v1aavehistoricaltransactions.ts

@@ -4,10 +4,7 @@
 
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
-import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
-import { Result as SafeParseResult } from "../../types/fp.js";
-import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export const V1AaveHistoricalTransactionsChain = {
   Arbitrum: "arbitrum",
@@ -34,30 +31,11 @@ export type V1AaveHistoricalTransactionsRequest = {
   userAddress: string;
 };
 
-/** @internal */
-export const V1AaveHistoricalTransactionsChain$inboundSchema: z.ZodNativeEnum<
-  typeof V1AaveHistoricalTransactionsChain
-> = z.nativeEnum(V1AaveHistoricalTransactionsChain);
 /** @internal */
 export const V1AaveHistoricalTransactionsChain$outboundSchema: z.ZodNativeEnum<
   typeof V1AaveHistoricalTransactionsChain
-> = V1AaveHistoricalTransactionsChain$inboundSchema;
+> = z.nativeEnum(V1AaveHistoricalTransactionsChain);
 
-/** @internal */
-export const V1AaveHistoricalTransactionsRequest$inboundSchema: z.ZodType<
-  V1AaveHistoricalTransactionsRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  offset: z.number().int().optional(),
-  limit: z.number().int().optional(),
-  chain: V1AaveHistoricalTransactionsChain$inboundSchema,
-  user_address: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    "user_address": "userAddress",
-  });
-});
 /** @internal */
 export type V1AaveHistoricalTransactionsRequest$Outbound = {
   offset?: number | undefined;
@@ -91,13 +69,3 @@ export function v1AaveHistoricalTransactionsRequestToJSON(
     ),
   );
 }
-export function v1AaveHistoricalTransactionsRequestFromJSON(
-  jsonString: string,
-): SafeParseResult<V1AaveHistoricalTransactionsRequest, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      V1AaveHistoricalTransactionsRequest$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'V1AaveHistoricalTransactionsRequest' from JSON`,
-  );
-}

package/src/models/operations/v1aaveliquiditychange.ts

@@ -4,10 +4,7 @@
 
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
-import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
-import { Result as SafeParseResult } from "../../types/fp.js";
-import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export const V1AaveLiquidityChangeChain = {
   Arbitrum: "arbitrum",
@@ -34,31 +31,11 @@ export type V1AaveLiquidityChangeRequest = {
   endBlock: number;
 };
 
-/** @internal */
-export const V1AaveLiquidityChangeChain$inboundSchema: z.ZodNativeEnum<
-  typeof V1AaveLiquidityChangeChain
-> = z.nativeEnum(V1AaveLiquidityChangeChain);
 /** @internal */
 export const V1AaveLiquidityChangeChain$outboundSchema: z.ZodNativeEnum<
   typeof V1AaveLiquidityChangeChain
-> = V1AaveLiquidityChangeChain$inboundSchema;
+> = z.nativeEnum(V1AaveLiquidityChangeChain);
 
-/** @internal */
-export const V1AaveLiquidityChangeRequest$inboundSchema: z.ZodType<
-  V1AaveLiquidityChangeRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  chain: V1AaveLiquidityChangeChain$inboundSchema,
-  token: z.string(),
-  start_block: z.number().int(),
-  end_block: z.number().int(),
-}).transform((v) => {
-  return remap$(v, {
-    "start_block": "startBlock",
-    "end_block": "endBlock",
-  });
-});
 /** @internal */
 export type V1AaveLiquidityChangeRequest$Outbound = {
   chain: string;
@@ -93,12 +70,3 @@ export function v1AaveLiquidityChangeRequestToJSON(
     ),
   );
 }
-export function v1AaveLiquidityChangeRequestFromJSON(
-  jsonString: string,
-): SafeParseResult<V1AaveLiquidityChangeRequest, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => V1AaveLiquidityChangeRequest$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'V1AaveLiquidityChangeRequest' from JSON`,
-  );
-}