@clossir-tech/ts-sdk 0.9.1 → 0.9.3

package/src/models/operations/get-orgs-by-org-id-assets-by-asset-id-vault-status.ts

@@ -3,12 +3,44 @@
  */
 
 import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { smartUnion } from "../../types/smart-union.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
 
 export type GetOrgsByOrgIdAssetsByAssetIdVaultStatusRequest = {
   orgId: string;
   assetId: string;
 };
 
+export type GetOrgsByOrgIdAssetsByAssetIdVaultStatusLatestNav = string | number;
+
+export type GetOrgsByOrgIdAssetsByAssetIdVaultStatusLatestNavRound =
+  | string
+  | number;
+
+/**
+ * Vault columns projected from the asset's `org_assets` row.
+ */
+export type GetOrgsByOrgIdAssetsByAssetIdVaultStatusVault = {
+  vaultAddress?: string | null | undefined;
+  vaultStatus?: string | null | undefined;
+  feesSplitterAddress?: string | null | undefined;
+  latestNav?: string | number | null | undefined;
+  latestNavRound?: string | number | null | undefined;
+  latestNavAt?: string | null | undefined;
+  [additionalProperties: string]: unknown;
+};
+
+/**
+ * Response
+ */
+export type GetOrgsByOrgIdAssetsByAssetIdVaultStatusResponse = {
+  vault: GetOrgsByOrgIdAssetsByAssetIdVaultStatusVault | null;
+};
+
 /** @internal */
 export type GetOrgsByOrgIdAssetsByAssetIdVaultStatusRequest$Outbound = {
   orgId: string;
@@ -35,3 +67,120 @@ export function getOrgsByOrgIdAssetsByAssetIdVaultStatusRequestToJSON(
     ),
   );
 }
+
+/** @internal */
+export const GetOrgsByOrgIdAssetsByAssetIdVaultStatusLatestNav$inboundSchema:
+  z.ZodMiniType<GetOrgsByOrgIdAssetsByAssetIdVaultStatusLatestNav, unknown> =
+    smartUnion([types.string(), types.number()]);
+
+export function getOrgsByOrgIdAssetsByAssetIdVaultStatusLatestNavFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetOrgsByOrgIdAssetsByAssetIdVaultStatusLatestNav,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetOrgsByOrgIdAssetsByAssetIdVaultStatusLatestNav$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetOrgsByOrgIdAssetsByAssetIdVaultStatusLatestNav' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetOrgsByOrgIdAssetsByAssetIdVaultStatusLatestNavRound$inboundSchema:
+  z.ZodMiniType<
+    GetOrgsByOrgIdAssetsByAssetIdVaultStatusLatestNavRound,
+    unknown
+  > = smartUnion([types.string(), types.number()]);
+
+export function getOrgsByOrgIdAssetsByAssetIdVaultStatusLatestNavRoundFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetOrgsByOrgIdAssetsByAssetIdVaultStatusLatestNavRound,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetOrgsByOrgIdAssetsByAssetIdVaultStatusLatestNavRound$inboundSchema
+        .parse(JSON.parse(x)),
+    `Failed to parse 'GetOrgsByOrgIdAssetsByAssetIdVaultStatusLatestNavRound' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetOrgsByOrgIdAssetsByAssetIdVaultStatusVault$inboundSchema:
+  z.ZodMiniType<GetOrgsByOrgIdAssetsByAssetIdVaultStatusVault, unknown> = z
+    .pipe(
+      z.catchall(
+        z.object({
+          vault_address: z.optional(z.nullable(types.string())),
+          vault_status: z.optional(z.nullable(types.string())),
+          fees_splitter_address: z.optional(z.nullable(types.string())),
+          latest_nav: z.optional(
+            z.nullable(smartUnion([types.string(), types.number()])),
+          ),
+          latest_nav_round: z.optional(
+            z.nullable(smartUnion([types.string(), types.number()])),
+          ),
+          latest_nav_at: z.optional(z.nullable(types.string())),
+        }),
+        z.any(),
+      ),
+      z.transform((v) => {
+        return remap$(v, {
+          "vault_address": "vaultAddress",
+          "vault_status": "vaultStatus",
+          "fees_splitter_address": "feesSplitterAddress",
+          "latest_nav": "latestNav",
+          "latest_nav_round": "latestNavRound",
+          "latest_nav_at": "latestNavAt",
+        });
+      }),
+    );
+
+export function getOrgsByOrgIdAssetsByAssetIdVaultStatusVaultFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetOrgsByOrgIdAssetsByAssetIdVaultStatusVault,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetOrgsByOrgIdAssetsByAssetIdVaultStatusVault$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetOrgsByOrgIdAssetsByAssetIdVaultStatusVault' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetOrgsByOrgIdAssetsByAssetIdVaultStatusResponse$inboundSchema:
+  z.ZodMiniType<GetOrgsByOrgIdAssetsByAssetIdVaultStatusResponse, unknown> = z
+    .object({
+      vault: types.nullable(
+        z.lazy(() =>
+          GetOrgsByOrgIdAssetsByAssetIdVaultStatusVault$inboundSchema
+        ),
+      ),
+    });
+
+export function getOrgsByOrgIdAssetsByAssetIdVaultStatusResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetOrgsByOrgIdAssetsByAssetIdVaultStatusResponse,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetOrgsByOrgIdAssetsByAssetIdVaultStatusResponse$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetOrgsByOrgIdAssetsByAssetIdVaultStatusResponse' from JSON`,
+  );
+}

package/src/models/operations/get-orgs-by-org-id-assets-by-asset-id-vault.ts

@@ -3,12 +3,42 @@
  */
 
 import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { smartUnion } from "../../types/smart-union.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
 
 export type GetOrgsByOrgIdAssetsByAssetIdVaultRequest = {
   orgId: string;
   assetId: string;
 };
 
+export type GetOrgsByOrgIdAssetsByAssetIdVaultLatestNav = string | number;
+
+export type GetOrgsByOrgIdAssetsByAssetIdVaultLatestNavRound = string | number;
+
+/**
+ * Vault columns projected from the asset's `org_assets` row.
+ */
+export type GetOrgsByOrgIdAssetsByAssetIdVaultVault = {
+  vaultAddress?: string | null | undefined;
+  vaultStatus?: string | null | undefined;
+  feesSplitterAddress?: string | null | undefined;
+  latestNav?: string | number | null | undefined;
+  latestNavRound?: string | number | null | undefined;
+  latestNavAt?: string | null | undefined;
+  [additionalProperties: string]: unknown;
+};
+
+/**
+ * Response
+ */
+export type GetOrgsByOrgIdAssetsByAssetIdVaultResponse = {
+  vault: GetOrgsByOrgIdAssetsByAssetIdVaultVault | null;
+};
+
 /** @internal */
 export type GetOrgsByOrgIdAssetsByAssetIdVaultRequest$Outbound = {
   orgId: string;
@@ -35,3 +65,117 @@ export function getOrgsByOrgIdAssetsByAssetIdVaultRequestToJSON(
     ),
   );
 }
+
+/** @internal */
+export const GetOrgsByOrgIdAssetsByAssetIdVaultLatestNav$inboundSchema:
+  z.ZodMiniType<GetOrgsByOrgIdAssetsByAssetIdVaultLatestNav, unknown> =
+    smartUnion([types.string(), types.number()]);
+
+export function getOrgsByOrgIdAssetsByAssetIdVaultLatestNavFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetOrgsByOrgIdAssetsByAssetIdVaultLatestNav,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetOrgsByOrgIdAssetsByAssetIdVaultLatestNav$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetOrgsByOrgIdAssetsByAssetIdVaultLatestNav' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetOrgsByOrgIdAssetsByAssetIdVaultLatestNavRound$inboundSchema:
+  z.ZodMiniType<GetOrgsByOrgIdAssetsByAssetIdVaultLatestNavRound, unknown> =
+    smartUnion([types.string(), types.number()]);
+
+export function getOrgsByOrgIdAssetsByAssetIdVaultLatestNavRoundFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetOrgsByOrgIdAssetsByAssetIdVaultLatestNavRound,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetOrgsByOrgIdAssetsByAssetIdVaultLatestNavRound$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetOrgsByOrgIdAssetsByAssetIdVaultLatestNavRound' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetOrgsByOrgIdAssetsByAssetIdVaultVault$inboundSchema:
+  z.ZodMiniType<GetOrgsByOrgIdAssetsByAssetIdVaultVault, unknown> = z.pipe(
+    z.catchall(
+      z.object({
+        vault_address: z.optional(z.nullable(types.string())),
+        vault_status: z.optional(z.nullable(types.string())),
+        fees_splitter_address: z.optional(z.nullable(types.string())),
+        latest_nav: z.optional(
+          z.nullable(smartUnion([types.string(), types.number()])),
+        ),
+        latest_nav_round: z.optional(
+          z.nullable(smartUnion([types.string(), types.number()])),
+        ),
+        latest_nav_at: z.optional(z.nullable(types.string())),
+      }),
+      z.any(),
+    ),
+    z.transform((v) => {
+      return remap$(v, {
+        "vault_address": "vaultAddress",
+        "vault_status": "vaultStatus",
+        "fees_splitter_address": "feesSplitterAddress",
+        "latest_nav": "latestNav",
+        "latest_nav_round": "latestNavRound",
+        "latest_nav_at": "latestNavAt",
+      });
+    }),
+  );
+
+export function getOrgsByOrgIdAssetsByAssetIdVaultVaultFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetOrgsByOrgIdAssetsByAssetIdVaultVault,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetOrgsByOrgIdAssetsByAssetIdVaultVault$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetOrgsByOrgIdAssetsByAssetIdVaultVault' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetOrgsByOrgIdAssetsByAssetIdVaultResponse$inboundSchema:
+  z.ZodMiniType<GetOrgsByOrgIdAssetsByAssetIdVaultResponse, unknown> = z.object(
+    {
+      vault: types.nullable(z.lazy(() =>
+        GetOrgsByOrgIdAssetsByAssetIdVaultVault$inboundSchema
+      )),
+    },
+  );
+
+export function getOrgsByOrgIdAssetsByAssetIdVaultResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetOrgsByOrgIdAssetsByAssetIdVaultResponse,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetOrgsByOrgIdAssetsByAssetIdVaultResponse$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetOrgsByOrgIdAssetsByAssetIdVaultResponse' from JSON`,
+  );
+}

package/src/models/operations/get-orgs-by-org-id-fee-distributions.ts

@@ -3,11 +3,63 @@
  */
 
 import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { smartUnion } from "../../types/smart-union.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
 
 export type GetOrgsByOrgIdFeeDistributionsRequest = {
   orgId: string;
 };
 
+export type GetOrgsByOrgIdFeeDistributionsTotalAmount = string | number;
+
+export type PlatformAmount = string | number;
+
+export type ParentOrgAmount = string | number;
+
+export type SubOrgAmount = string | number;
+
+/**
+ * A row of the `fee_distributions` table.
+ */
+export type GetOrgsByOrgIdFeeDistributionsDistribution = {
+  id?: string | null | undefined;
+  splitterAddress?: string | null | undefined;
+  assetId?: string | null | undefined;
+  distributionId?: string | null | undefined;
+  tokenAddress?: string | null | undefined;
+  totalAmount?: string | number | null | undefined;
+  platformAmount?: string | number | null | undefined;
+  parentOrgAmount?: string | number | null | undefined;
+  subOrgAmount?: string | number | null | undefined;
+  txHash?: string | null | undefined;
+  chainEid?: number | null | undefined;
+  createdAt?: string | null | undefined;
+  [additionalProperties: string]: unknown;
+};
+
+/**
+ * Response
+ */
+export type GetOrgsByOrgIdFeeDistributionsResponse = {
+  distributions: Array<GetOrgsByOrgIdFeeDistributionsDistribution>;
+  /**
+   * Total matching rows, ignoring limit/offset
+   */
+  total: number;
+  /**
+   * Page size that was applied
+   */
+  limit: number;
+  /**
+   * Row offset that was applied
+   */
+  offset: number;
+};
+
 /** @internal */
 export type GetOrgsByOrgIdFeeDistributionsRequest$Outbound = {
   orgId: string;
@@ -31,3 +83,153 @@ export function getOrgsByOrgIdFeeDistributionsRequestToJSON(
     ),
   );
 }
+
+/** @internal */
+export const GetOrgsByOrgIdFeeDistributionsTotalAmount$inboundSchema:
+  z.ZodMiniType<GetOrgsByOrgIdFeeDistributionsTotalAmount, unknown> =
+    smartUnion([types.string(), types.number()]);
+
+export function getOrgsByOrgIdFeeDistributionsTotalAmountFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetOrgsByOrgIdFeeDistributionsTotalAmount,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetOrgsByOrgIdFeeDistributionsTotalAmount$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetOrgsByOrgIdFeeDistributionsTotalAmount' from JSON`,
+  );
+}
+
+/** @internal */
+export const PlatformAmount$inboundSchema: z.ZodMiniType<
+  PlatformAmount,
+  unknown
+> = smartUnion([types.string(), types.number()]);
+
+export function platformAmountFromJSON(
+  jsonString: string,
+): SafeParseResult<PlatformAmount, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PlatformAmount$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PlatformAmount' from JSON`,
+  );
+}
+
+/** @internal */
+export const ParentOrgAmount$inboundSchema: z.ZodMiniType<
+  ParentOrgAmount,
+  unknown
+> = smartUnion([types.string(), types.number()]);
+
+export function parentOrgAmountFromJSON(
+  jsonString: string,
+): SafeParseResult<ParentOrgAmount, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ParentOrgAmount$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ParentOrgAmount' from JSON`,
+  );
+}
+
+/** @internal */
+export const SubOrgAmount$inboundSchema: z.ZodMiniType<SubOrgAmount, unknown> =
+  smartUnion([types.string(), types.number()]);
+
+export function subOrgAmountFromJSON(
+  jsonString: string,
+): SafeParseResult<SubOrgAmount, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SubOrgAmount$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SubOrgAmount' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetOrgsByOrgIdFeeDistributionsDistribution$inboundSchema:
+  z.ZodMiniType<GetOrgsByOrgIdFeeDistributionsDistribution, unknown> = z.pipe(
+    z.catchall(
+      z.object({
+        id: z.optional(z.nullable(types.string())),
+        splitter_address: z.optional(z.nullable(types.string())),
+        asset_id: z.optional(z.nullable(types.string())),
+        distribution_id: z.optional(z.nullable(types.string())),
+        token_address: z.optional(z.nullable(types.string())),
+        total_amount: z.optional(
+          z.nullable(smartUnion([types.string(), types.number()])),
+        ),
+        platform_amount: z.optional(
+          z.nullable(smartUnion([types.string(), types.number()])),
+        ),
+        parent_org_amount: z.optional(
+          z.nullable(smartUnion([types.string(), types.number()])),
+        ),
+        sub_org_amount: z.optional(
+          z.nullable(smartUnion([types.string(), types.number()])),
+        ),
+        tx_hash: z.optional(z.nullable(types.string())),
+        chain_eid: z.optional(z.nullable(types.number())),
+        created_at: z.optional(z.nullable(types.string())),
+      }),
+      z.any(),
+    ),
+    z.transform((v) => {
+      return remap$(v, {
+        "splitter_address": "splitterAddress",
+        "asset_id": "assetId",
+        "distribution_id": "distributionId",
+        "token_address": "tokenAddress",
+        "total_amount": "totalAmount",
+        "platform_amount": "platformAmount",
+        "parent_org_amount": "parentOrgAmount",
+        "sub_org_amount": "subOrgAmount",
+        "tx_hash": "txHash",
+        "chain_eid": "chainEid",
+        "created_at": "createdAt",
+      });
+    }),
+  );
+
+export function getOrgsByOrgIdFeeDistributionsDistributionFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetOrgsByOrgIdFeeDistributionsDistribution,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetOrgsByOrgIdFeeDistributionsDistribution$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetOrgsByOrgIdFeeDistributionsDistribution' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetOrgsByOrgIdFeeDistributionsResponse$inboundSchema:
+  z.ZodMiniType<GetOrgsByOrgIdFeeDistributionsResponse, unknown> = z.object({
+    distributions: z.array(
+      z.lazy(() => GetOrgsByOrgIdFeeDistributionsDistribution$inboundSchema),
+    ),
+    total: types.number(),
+    limit: types.number(),
+    offset: types.number(),
+  });
+
+export function getOrgsByOrgIdFeeDistributionsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetOrgsByOrgIdFeeDistributionsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetOrgsByOrgIdFeeDistributionsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetOrgsByOrgIdFeeDistributionsResponse' from JSON`,
+  );
+}

package/src/models/operations/get-orgs-by-org-id-fee-splits.ts

@@ -3,11 +3,41 @@
  */
 
 import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
 
 export type GetOrgsByOrgIdFeeSplitsRequest = {
   orgId: string;
 };
 
+/**
+ * A row of the `org_fee_splits` table.
+ */
+export type Split = {
+  id?: string | null | undefined;
+  parentOrgId?: string | null | undefined;
+  subOrgId?: string | null | undefined;
+  platformShareBps?: number | null | undefined;
+  parentShareBps?: number | null | undefined;
+  platformShareEnabled?: boolean | null | undefined;
+  parentShareEnabled?: boolean | null | undefined;
+  effectiveFrom?: string | null | undefined;
+  effectiveUntil?: string | null | undefined;
+  notes?: string | null | undefined;
+  createdAt?: string | null | undefined;
+  [additionalProperties: string]: unknown;
+};
+
+/**
+ * Response
+ */
+export type GetOrgsByOrgIdFeeSplitsResponse = {
+  splits: Array<Split>;
+};
+
 /** @internal */
 export type GetOrgsByOrgIdFeeSplitsRequest$Outbound = {
   orgId: string;
@@ -30,3 +60,64 @@ export function getOrgsByOrgIdFeeSplitsRequestToJSON(
     ),
   );
 }
+
+/** @internal */
+export const Split$inboundSchema: z.ZodMiniType<Split, unknown> = z.pipe(
+  z.catchall(
+    z.object({
+      id: z.optional(z.nullable(types.string())),
+      parent_org_id: z.optional(z.nullable(types.string())),
+      sub_org_id: z.optional(z.nullable(types.string())),
+      platform_share_bps: z.optional(z.nullable(types.number())),
+      parent_share_bps: z.optional(z.nullable(types.number())),
+      platform_share_enabled: z.optional(z.nullable(types.boolean())),
+      parent_share_enabled: z.optional(z.nullable(types.boolean())),
+      effective_from: z.optional(z.nullable(types.string())),
+      effective_until: z.optional(z.nullable(types.string())),
+      notes: z.optional(z.nullable(types.string())),
+      created_at: z.optional(z.nullable(types.string())),
+    }),
+    z.any(),
+  ),
+  z.transform((v) => {
+    return remap$(v, {
+      "parent_org_id": "parentOrgId",
+      "sub_org_id": "subOrgId",
+      "platform_share_bps": "platformShareBps",
+      "parent_share_bps": "parentShareBps",
+      "platform_share_enabled": "platformShareEnabled",
+      "parent_share_enabled": "parentShareEnabled",
+      "effective_from": "effectiveFrom",
+      "effective_until": "effectiveUntil",
+      "created_at": "createdAt",
+    });
+  }),
+);
+
+export function splitFromJSON(
+  jsonString: string,
+): SafeParseResult<Split, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Split$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Split' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetOrgsByOrgIdFeeSplitsResponse$inboundSchema: z.ZodMiniType<
+  GetOrgsByOrgIdFeeSplitsResponse,
+  unknown
+> = z.object({
+  splits: z.array(z.lazy(() => Split$inboundSchema)),
+});
+
+export function getOrgsByOrgIdFeeSplitsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetOrgsByOrgIdFeeSplitsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetOrgsByOrgIdFeeSplitsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetOrgsByOrgIdFeeSplitsResponse' from JSON`,
+  );
+}

package/src/sdk/distributions.ts

@@ -15,7 +15,7 @@ export class Distributions extends ClientSDK {
     orgId: string,
     assetId: string,
     options?: RequestOptions,
-  ): Promise<void> {
+  ): Promise<operations.GetOrgsByOrgIdAssetsByAssetIdDistributionsResponse> {
     return unwrapAsync(distributionsGetOrgsByOrgIdAssetsByAssetIdDistributions(
       this,
       orgId,
@@ -44,7 +44,9 @@ export class Distributions extends ClientSDK {
     assetId: string,
     distId: string,
     options?: RequestOptions,
-  ): Promise<void> {
+  ): Promise<
+    operations.GetOrgsByOrgIdAssetsByAssetIdDistributionsByDistIdResponse
+  > {
     return unwrapAsync(
       distributionsGetOrgsByOrgIdAssetsByAssetIdDistributionsByDistId(
         this,

package/src/sdk/fees.ts

@@ -13,7 +13,7 @@ export class Fees extends ClientSDK {
   async getOrgsByOrgIdFeeSplits(
     orgId: string,
     options?: RequestOptions,
-  ): Promise<void> {
+  ): Promise<operations.GetOrgsByOrgIdFeeSplitsResponse> {
     return unwrapAsync(feesGetOrgsByOrgIdFeeSplits(
       this,
       orgId,
@@ -24,7 +24,7 @@ export class Fees extends ClientSDK {
   async getOrgsByOrgIdFeeDistributions(
     orgId: string,
     options?: RequestOptions,
-  ): Promise<void> {
+  ): Promise<operations.GetOrgsByOrgIdFeeDistributionsResponse> {
     return unwrapAsync(feesGetOrgsByOrgIdFeeDistributions(
       this,
       orgId,

package/src/sdk/nav.ts

@@ -15,7 +15,7 @@ export class Nav extends ClientSDK {
     orgId: string,
     assetId: string,
     options?: RequestOptions,
-  ): Promise<void> {
+  ): Promise<operations.GetOrgsByOrgIdAssetsByAssetIdNavLatestResponse> {
     return unwrapAsync(navGetOrgsByOrgIdAssetsByAssetIdNAVLatest(
       this,
       orgId,
@@ -28,7 +28,7 @@ export class Nav extends ClientSDK {
     orgId: string,
     assetId: string,
     options?: RequestOptions,
-  ): Promise<void> {
+  ): Promise<operations.GetOrgsByOrgIdAssetsByAssetIdNavHistoryResponse> {
     return unwrapAsync(navGetOrgsByOrgIdAssetsByAssetIdNAVHistory(
       this,
       orgId,