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

package/src/models/components/morphosupplycollateralrequest.ts

@@ -5,10 +5,7 @@
 import * as z from "zod/v3";
 import * as b64$ from "../../lib/base64.js";
 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";
 
 /**
  * Amount of the token to supply to the market as collateral.
@@ -53,12 +50,6 @@ export type MorphoSupplyCollateralRequest = {
   estimateGas?: boolean | undefined;
 };
 
-/** @internal */
-export const MorphoSupplyCollateralRequestAmount$inboundSchema: z.ZodType<
-  MorphoSupplyCollateralRequestAmount,
-  z.ZodTypeDef,
-  unknown
-> = z.union([z.number(), z.string()]);
 /** @internal */
 export type MorphoSupplyCollateralRequestAmount$Outbound = number | string;
 
@@ -78,51 +69,12 @@ export function morphoSupplyCollateralRequestAmountToJSON(
     ),
   );
 }
-export function morphoSupplyCollateralRequestAmountFromJSON(
-  jsonString: string,
-): SafeParseResult<MorphoSupplyCollateralRequestAmount, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      MorphoSupplyCollateralRequestAmount$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'MorphoSupplyCollateralRequestAmount' from JSON`,
-  );
-}
 
-/** @internal */
-export const MorphoSupplyCollateralRequestChain$inboundSchema: z.ZodNativeEnum<
-  typeof MorphoSupplyCollateralRequestChain
-> = z.nativeEnum(MorphoSupplyCollateralRequestChain);
 /** @internal */
 export const MorphoSupplyCollateralRequestChain$outboundSchema: z.ZodNativeEnum<
   typeof MorphoSupplyCollateralRequestChain
-> = MorphoSupplyCollateralRequestChain$inboundSchema;
+> = z.nativeEnum(MorphoSupplyCollateralRequestChain);
 
-/** @internal */
-export const MorphoSupplyCollateralRequest$inboundSchema: z.ZodType<
-  MorphoSupplyCollateralRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  action_type: z.literal("MORPHO_SUPPLY_COLLATERAL").default(
-    "MORPHO_SUPPLY_COLLATERAL",
-  ).optional(),
-  amount: z.union([z.number(), z.string()]),
-  unique_market_key: z.string(),
-  on_behalf_of: z.nullable(z.string()).optional(),
-  callback_data: z.nullable(b64$.zodInbound).optional(),
-  chain: MorphoSupplyCollateralRequestChain$inboundSchema,
-  sender: z.string(),
-  estimate_gas: z.boolean().optional(),
-}).transform((v) => {
-  return remap$(v, {
-    "action_type": "actionType",
-    "unique_market_key": "uniqueMarketKey",
-    "on_behalf_of": "onBehalfOf",
-    "callback_data": "callbackData",
-    "estimate_gas": "estimateGas",
-  });
-});
 /** @internal */
 export type MorphoSupplyCollateralRequest$Outbound = {
   action_type: "MORPHO_SUPPLY_COLLATERAL";
@@ -168,12 +120,3 @@ export function morphoSupplyCollateralRequestToJSON(
     ),
   );
 }
-export function morphoSupplyCollateralRequestFromJSON(
-  jsonString: string,
-): SafeParseResult<MorphoSupplyCollateralRequest, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => MorphoSupplyCollateralRequest$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'MorphoSupplyCollateralRequest' from JSON`,
-  );
-}

package/src/models/components/morphovault.ts

@@ -6,23 +6,14 @@ 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 {
-  ChainInfo,
-  ChainInfo$inboundSchema,
-  ChainInfo$Outbound,
-  ChainInfo$outboundSchema,
-} from "./chaininfo.js";
+import { ChainInfo, ChainInfo$inboundSchema } from "./chaininfo.js";
 import {
   CompassApiBackendV1ModelsMorphoReadResponseGetVaultsAsset,
   CompassApiBackendV1ModelsMorphoReadResponseGetVaultsAsset$inboundSchema,
-  CompassApiBackendV1ModelsMorphoReadResponseGetVaultsAsset$Outbound,
-  CompassApiBackendV1ModelsMorphoReadResponseGetVaultsAsset$outboundSchema,
 } from "./compassapibackendv1modelsmorphoreadresponsegetvaultsasset.js";
 import {
   CompassApiBackendV1ModelsMorphoReadResponseGetVaultsVaultState,
   CompassApiBackendV1ModelsMorphoReadResponseGetVaultsVaultState$inboundSchema,
-  CompassApiBackendV1ModelsMorphoReadResponseGetVaultsVaultState$Outbound,
-  CompassApiBackendV1ModelsMorphoReadResponseGetVaultsVaultState$outboundSchema,
 } from "./compassapibackendv1modelsmorphoreadresponsegetvaultsvaultstate.js";
 
 export type MorphoVault = {
@@ -57,44 +48,7 @@ export const MorphoVault$inboundSchema: z.ZodType<
   state:
     CompassApiBackendV1ModelsMorphoReadResponseGetVaultsVaultState$inboundSchema,
 });
-/** @internal */
-export type MorphoVault$Outbound = {
-  address: string;
-  symbol: string;
-  name: string;
-  creationBlockNumber: number;
-  creationTimestamp: number;
-  creatorAddress: string;
-  whitelisted: boolean;
-  asset: CompassApiBackendV1ModelsMorphoReadResponseGetVaultsAsset$Outbound;
-  chain: ChainInfo$Outbound;
-  state:
-    CompassApiBackendV1ModelsMorphoReadResponseGetVaultsVaultState$Outbound;
-};
-
-/** @internal */
-export const MorphoVault$outboundSchema: z.ZodType<
-  MorphoVault$Outbound,
-  z.ZodTypeDef,
-  MorphoVault
-> = z.object({
-  address: z.string(),
-  symbol: z.string(),
-  name: z.string(),
-  creationBlockNumber: z.number().int(),
-  creationTimestamp: z.number().int(),
-  creatorAddress: z.string(),
-  whitelisted: z.boolean(),
-  asset:
-    CompassApiBackendV1ModelsMorphoReadResponseGetVaultsAsset$outboundSchema,
-  chain: ChainInfo$outboundSchema,
-  state:
-    CompassApiBackendV1ModelsMorphoReadResponseGetVaultsVaultState$outboundSchema,
-});
 
-export function morphoVaultToJSON(morphoVault: MorphoVault): string {
-  return JSON.stringify(MorphoVault$outboundSchema.parse(morphoVault));
-}
 export function morphoVaultFromJSON(
   jsonString: string,
 ): SafeParseResult<MorphoVault, SDKValidationError> {

package/src/models/components/morphowithdrawcollateralparams.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";
 
 /**
  * Amount of the token to supply to the market as collateral.
@@ -33,12 +30,6 @@ export type MorphoWithdrawCollateralParams = {
   receiver?: string | null | undefined;
 };
 
-/** @internal */
-export const MorphoWithdrawCollateralParamsAmount$inboundSchema: z.ZodType<
-  MorphoWithdrawCollateralParamsAmount,
-  z.ZodTypeDef,
-  unknown
-> = z.union([z.number(), z.string()]);
 /** @internal */
 export type MorphoWithdrawCollateralParamsAmount$Outbound = number | string;
 
@@ -58,37 +49,7 @@ export function morphoWithdrawCollateralParamsAmountToJSON(
     ),
   );
 }
-export function morphoWithdrawCollateralParamsAmountFromJSON(
-  jsonString: string,
-): SafeParseResult<MorphoWithdrawCollateralParamsAmount, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      MorphoWithdrawCollateralParamsAmount$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'MorphoWithdrawCollateralParamsAmount' from JSON`,
-  );
-}
 
-/** @internal */
-export const MorphoWithdrawCollateralParams$inboundSchema: z.ZodType<
-  MorphoWithdrawCollateralParams,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  action_type: z.literal("MORPHO_WITHDRAW_COLLATERAL").default(
-    "MORPHO_WITHDRAW_COLLATERAL",
-  ).optional(),
-  amount: z.union([z.number(), z.string()]),
-  unique_market_key: z.string(),
-  on_behalf_of: z.nullable(z.string()).optional(),
-  receiver: z.nullable(z.string()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    "action_type": "actionType",
-    "unique_market_key": "uniqueMarketKey",
-    "on_behalf_of": "onBehalfOf",
-  });
-});
 /** @internal */
 export type MorphoWithdrawCollateralParams$Outbound = {
   action_type: "MORPHO_WITHDRAW_COLLATERAL";
@@ -126,12 +87,3 @@ export function morphoWithdrawCollateralParamsToJSON(
     ),
   );
 }
-export function morphoWithdrawCollateralParamsFromJSON(
-  jsonString: string,
-): SafeParseResult<MorphoWithdrawCollateralParams, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => MorphoWithdrawCollateralParams$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'MorphoWithdrawCollateralParams' from JSON`,
-  );
-}

package/src/models/components/morphowithdrawcollateralrequest.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";
 
 /**
  * Amount of the token to supply to the market as collateral.
@@ -52,12 +49,6 @@ export type MorphoWithdrawCollateralRequest = {
   estimateGas?: boolean | undefined;
 };
 
-/** @internal */
-export const MorphoWithdrawCollateralRequestAmount$inboundSchema: z.ZodType<
-  MorphoWithdrawCollateralRequestAmount,
-  z.ZodTypeDef,
-  unknown
-> = z.union([z.number(), z.string()]);
 /** @internal */
 export type MorphoWithdrawCollateralRequestAmount$Outbound = number | string;
 
@@ -77,51 +68,13 @@ export function morphoWithdrawCollateralRequestAmountToJSON(
     ),
   );
 }
-export function morphoWithdrawCollateralRequestAmountFromJSON(
-  jsonString: string,
-): SafeParseResult<MorphoWithdrawCollateralRequestAmount, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      MorphoWithdrawCollateralRequestAmount$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'MorphoWithdrawCollateralRequestAmount' from JSON`,
-  );
-}
 
 /** @internal */
-export const MorphoWithdrawCollateralRequestChain$inboundSchema:
+export const MorphoWithdrawCollateralRequestChain$outboundSchema:
   z.ZodNativeEnum<typeof MorphoWithdrawCollateralRequestChain> = z.nativeEnum(
     MorphoWithdrawCollateralRequestChain,
   );
-/** @internal */
-export const MorphoWithdrawCollateralRequestChain$outboundSchema:
-  z.ZodNativeEnum<typeof MorphoWithdrawCollateralRequestChain> =
-    MorphoWithdrawCollateralRequestChain$inboundSchema;
 
-/** @internal */
-export const MorphoWithdrawCollateralRequest$inboundSchema: z.ZodType<
-  MorphoWithdrawCollateralRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  action_type: z.literal("MORPHO_WITHDRAW_COLLATERAL").default(
-    "MORPHO_WITHDRAW_COLLATERAL",
-  ).optional(),
-  amount: z.union([z.number(), z.string()]),
-  unique_market_key: z.string(),
-  on_behalf_of: z.nullable(z.string()).optional(),
-  receiver: z.nullable(z.string()).optional(),
-  chain: MorphoWithdrawCollateralRequestChain$inboundSchema,
-  sender: z.string(),
-  estimate_gas: z.boolean().optional(),
-}).transform((v) => {
-  return remap$(v, {
-    "action_type": "actionType",
-    "unique_market_key": "uniqueMarketKey",
-    "on_behalf_of": "onBehalfOf",
-    "estimate_gas": "estimateGas",
-  });
-});
 /** @internal */
 export type MorphoWithdrawCollateralRequest$Outbound = {
   action_type: "MORPHO_WITHDRAW_COLLATERAL";
@@ -166,12 +119,3 @@ export function morphoWithdrawCollateralRequestToJSON(
     ),
   );
 }
-export function morphoWithdrawCollateralRequestFromJSON(
-  jsonString: string,
-): SafeParseResult<MorphoWithdrawCollateralRequest, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => MorphoWithdrawCollateralRequest$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'MorphoWithdrawCollateralRequest' from JSON`,
-  );
-}

package/src/models/components/morphowithdrawparams.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";
 
 export type MorphoWithdrawParams = {
   actionType?: "MORPHO_WITHDRAW" | undefined;
@@ -24,23 +21,6 @@ export type MorphoWithdrawParams = {
   receiver?: string | null | undefined;
 };
 
-/** @internal */
-export const MorphoWithdrawParams$inboundSchema: z.ZodType<
-  MorphoWithdrawParams,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  action_type: z.literal("MORPHO_WITHDRAW").default("MORPHO_WITHDRAW")
-    .optional(),
-  vault_address: z.string(),
-  amount: z.any().optional(),
-  receiver: z.nullable(z.string()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    "action_type": "actionType",
-    "vault_address": "vaultAddress",
-  });
-});
 /** @internal */
 export type MorphoWithdrawParams$Outbound = {
   action_type: "MORPHO_WITHDRAW";
@@ -73,12 +53,3 @@ export function morphoWithdrawParamsToJSON(
     MorphoWithdrawParams$outboundSchema.parse(morphoWithdrawParams),
   );
 }
-export function morphoWithdrawParamsFromJSON(
-  jsonString: string,
-): SafeParseResult<MorphoWithdrawParams, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => MorphoWithdrawParams$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'MorphoWithdrawParams' from JSON`,
-  );
-}

package/src/models/components/morphowithdrawrequest.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 MorphoWithdrawRequestChain = {
   Arbitrum: "arbitrum",
@@ -43,36 +40,11 @@ export type MorphoWithdrawRequest = {
   estimateGas?: boolean | undefined;
 };
 
-/** @internal */
-export const MorphoWithdrawRequestChain$inboundSchema: z.ZodNativeEnum<
-  typeof MorphoWithdrawRequestChain
-> = z.nativeEnum(MorphoWithdrawRequestChain);
 /** @internal */
 export const MorphoWithdrawRequestChain$outboundSchema: z.ZodNativeEnum<
   typeof MorphoWithdrawRequestChain
-> = MorphoWithdrawRequestChain$inboundSchema;
+> = z.nativeEnum(MorphoWithdrawRequestChain);
 
-/** @internal */
-export const MorphoWithdrawRequest$inboundSchema: z.ZodType<
-  MorphoWithdrawRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  action_type: z.literal("MORPHO_WITHDRAW").default("MORPHO_WITHDRAW")
-    .optional(),
-  vault_address: z.string(),
-  amount: z.any().optional(),
-  receiver: z.nullable(z.string()).optional(),
-  chain: MorphoWithdrawRequestChain$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 MorphoWithdrawRequest$Outbound = {
   action_type: "MORPHO_WITHDRAW";
@@ -112,12 +84,3 @@ export function morphoWithdrawRequestToJSON(
     MorphoWithdrawRequest$outboundSchema.parse(morphoWithdrawRequest),
   );
 }
-export function morphoWithdrawRequestFromJSON(
-  jsonString: string,
-): SafeParseResult<MorphoWithdrawRequest, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => MorphoWithdrawRequest$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'MorphoWithdrawRequest' from JSON`,
-  );
-}

package/src/models/components/movement10percent.ts

@@ -25,33 +25,7 @@ export const Movement10Percent$inboundSchema: z.ZodType<
   ytMovementUpUsd: z.nullable(z.number()).optional(),
   ytMovementDownUsd: z.nullable(z.number()).optional(),
 });
-/** @internal */
-export type Movement10Percent$Outbound = {
-  ptMovementUpUsd?: number | null | undefined;
-  ptMovementDownUsd?: number | null | undefined;
-  ytMovementUpUsd?: number | null | undefined;
-  ytMovementDownUsd?: number | null | undefined;
-};
 
-/** @internal */
-export const Movement10Percent$outboundSchema: z.ZodType<
-  Movement10Percent$Outbound,
-  z.ZodTypeDef,
-  Movement10Percent
-> = z.object({
-  ptMovementUpUsd: z.nullable(z.number()).optional(),
-  ptMovementDownUsd: z.nullable(z.number()).optional(),
-  ytMovementUpUsd: z.nullable(z.number()).optional(),
-  ytMovementDownUsd: z.nullable(z.number()).optional(),
-});
-
-export function movement10PercentToJSON(
-  movement10Percent: Movement10Percent,
-): string {
-  return JSON.stringify(
-    Movement10Percent$outboundSchema.parse(movement10Percent),
-  );
-}
 export function movement10PercentFromJSON(
   jsonString: string,
 ): SafeParseResult<Movement10Percent, SDKValidationError> {

package/src/models/components/multicallauthorizationrequest.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 MulticallAuthorizationRequestChain = {
   Arbitrum: "arbitrum",
@@ -34,24 +31,11 @@ export type MulticallAuthorizationRequest = {
   sender: string;
 };
 
-/** @internal */
-export const MulticallAuthorizationRequestChain$inboundSchema: z.ZodNativeEnum<
-  typeof MulticallAuthorizationRequestChain
-> = z.nativeEnum(MulticallAuthorizationRequestChain);
 /** @internal */
 export const MulticallAuthorizationRequestChain$outboundSchema: z.ZodNativeEnum<
   typeof MulticallAuthorizationRequestChain
-> = MulticallAuthorizationRequestChain$inboundSchema;
+> = z.nativeEnum(MulticallAuthorizationRequestChain);
 
-/** @internal */
-export const MulticallAuthorizationRequest$inboundSchema: z.ZodType<
-  MulticallAuthorizationRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  chain: MulticallAuthorizationRequestChain$inboundSchema,
-  sender: z.string(),
-});
 /** @internal */
 export type MulticallAuthorizationRequest$Outbound = {
   chain: string;
@@ -77,12 +61,3 @@ export function multicallAuthorizationRequestToJSON(
     ),
   );
 }
-export function multicallAuthorizationRequestFromJSON(
-  jsonString: string,
-): SafeParseResult<MulticallAuthorizationRequest, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => MulticallAuthorizationRequest$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'MulticallAuthorizationRequest' from JSON`,
-  );
-}

package/src/models/components/multicallauthorizationresponse.ts

@@ -35,33 +35,7 @@ export const MulticallAuthorizationResponse$inboundSchema: z.ZodType<
   address: z.string(),
   chainId: z.number().int(),
 });
-/** @internal */
-export type MulticallAuthorizationResponse$Outbound = {
-  nonce: number;
-  address: string;
-  chainId: number;
-};
 
-/** @internal */
-export const MulticallAuthorizationResponse$outboundSchema: z.ZodType<
-  MulticallAuthorizationResponse$Outbound,
-  z.ZodTypeDef,
-  MulticallAuthorizationResponse
-> = z.object({
-  nonce: z.number().int(),
-  address: z.string(),
-  chainId: z.number().int(),
-});
-
-export function multicallAuthorizationResponseToJSON(
-  multicallAuthorizationResponse: MulticallAuthorizationResponse,
-): string {
-  return JSON.stringify(
-    MulticallAuthorizationResponse$outboundSchema.parse(
-      multicallAuthorizationResponse,
-    ),
-  );
-}
 export function multicallAuthorizationResponseFromJSON(
   jsonString: string,
 ): SafeParseResult<MulticallAuthorizationResponse, SDKValidationError> {

package/src/models/components/multicallexecuterequest.ts

@@ -4,19 +4,14 @@
 
 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";
 import {
   SignedAuthorization,
-  SignedAuthorization$inboundSchema,
   SignedAuthorization$Outbound,
   SignedAuthorization$outboundSchema,
 } from "./signedauthorization.js";
 import {
   UserOperation,
-  UserOperation$inboundSchema,
   UserOperation$Outbound,
   UserOperation$outboundSchema,
 } from "./useroperation.js";
@@ -53,33 +48,11 @@ export type MulticallExecuteRequest = {
   actions: Array<UserOperation>;
 };
 
-/** @internal */
-export const MulticallExecuteRequestChain$inboundSchema: z.ZodNativeEnum<
-  typeof MulticallExecuteRequestChain
-> = z.nativeEnum(MulticallExecuteRequestChain);
 /** @internal */
 export const MulticallExecuteRequestChain$outboundSchema: z.ZodNativeEnum<
   typeof MulticallExecuteRequestChain
-> = MulticallExecuteRequestChain$inboundSchema;
+> = z.nativeEnum(MulticallExecuteRequestChain);
 
-/** @internal */
-export const MulticallExecuteRequest$inboundSchema: z.ZodType<
-  MulticallExecuteRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  chain: MulticallExecuteRequestChain$inboundSchema,
-  sender: z.string(),
-  estimate_gas: z.boolean().optional(),
-  signed_authorization: z.nullable(SignedAuthorization$inboundSchema)
-    .optional(),
-  actions: z.array(UserOperation$inboundSchema),
-}).transform((v) => {
-  return remap$(v, {
-    "estimate_gas": "estimateGas",
-    "signed_authorization": "signedAuthorization",
-  });
-});
 /** @internal */
 export type MulticallExecuteRequest$Outbound = {
   chain: string;
@@ -115,12 +88,3 @@ export function multicallExecuteRequestToJSON(
     MulticallExecuteRequest$outboundSchema.parse(multicallExecuteRequest),
   );
 }
-export function multicallExecuteRequestFromJSON(
-  jsonString: string,
-): SafeParseResult<MulticallExecuteRequest, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => MulticallExecuteRequest$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'MulticallExecuteRequest' from JSON`,
-  );
-}

package/src/models/components/odosswapparams.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 token_in to be sold.
@@ -33,12 +30,6 @@ export type OdosSwapParams = {
   maxSlippagePercent: number;
 };
 
-/** @internal */
-export const OdosSwapParamsAmountIn$inboundSchema: z.ZodType<
-  OdosSwapParamsAmountIn,
-  z.ZodTypeDef,
-  unknown
-> = z.union([z.number(), z.string()]);
 /** @internal */
 export type OdosSwapParamsAmountIn$Outbound = number | string;
 
@@ -56,36 +47,7 @@ export function odosSwapParamsAmountInToJSON(
     OdosSwapParamsAmountIn$outboundSchema.parse(odosSwapParamsAmountIn),
   );
 }
-export function odosSwapParamsAmountInFromJSON(
-  jsonString: string,
-): SafeParseResult<OdosSwapParamsAmountIn, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => OdosSwapParamsAmountIn$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'OdosSwapParamsAmountIn' from JSON`,
-  );
-}
 
-/** @internal */
-export const OdosSwapParams$inboundSchema: z.ZodType<
-  OdosSwapParams,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  action_type: z.literal("ODOS_SWAP").default("ODOS_SWAP").optional(),
-  token_in: z.string(),
-  token_out: z.string(),
-  amount_in: z.union([z.number(), z.string()]),
-  max_slippage_percent: z.number(),
-}).transform((v) => {
-  return remap$(v, {
-    "action_type": "actionType",
-    "token_in": "tokenIn",
-    "token_out": "tokenOut",
-    "amount_in": "amountIn",
-    "max_slippage_percent": "maxSlippagePercent",
-  });
-});
 /** @internal */
 export type OdosSwapParams$Outbound = {
   action_type: "ODOS_SWAP";
@@ -119,12 +81,3 @@ export const OdosSwapParams$outboundSchema: z.ZodType<
 export function odosSwapParamsToJSON(odosSwapParams: OdosSwapParams): string {
   return JSON.stringify(OdosSwapParams$outboundSchema.parse(odosSwapParams));
 }
-export function odosSwapParamsFromJSON(
-  jsonString: string,
-): SafeParseResult<OdosSwapParams, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => OdosSwapParams$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'OdosSwapParams' from JSON`,
-  );
-}