@settlemint/dalp-sdk 2.1.7-main.23442422201 → 2.1.7-main.23445298463

package/dist/index.js

@@ -9906,6 +9906,10 @@ var FeatureConfigsInputSchema = z190.object({
 // ../../packages/dalp/api-contract/src/routes/token/routes/mutations/create/helpers/create-handlers/dalp-asset.create.schema.ts
 var DALPAssetTokenSchema = TokenBaseSchema.extend({
   type: z191.literal(AssetFactoryTypeIdEnum.dalpAsset),
+  templateId: z191.string().min(1, "Template ID cannot be empty").meta({
+    description: "ID of the instrument template used to create this token",
+    examples: ["template-bond-standard"]
+  }),
   priceCurrency: fiatCurrency().optional().meta({
     description: "The fiat currency code for valuation (e.g., USD, EUR)",
     examples: ["USD", "EUR", "GBP"]
@@ -9914,9 +9918,41 @@ var DALPAssetTokenSchema = TokenBaseSchema.extend({
     description: "The fiat value per token in the price currency",
     examples: ["1.00", "100.00"]
   }),
-  templateId: z191.string().min(1, "Template ID cannot be empty").meta({
-    description: "ID of the instrument template used to create this token",
-    examples: ["template-bond-standard"]
+  cap: assetAmount.optional().meta({
+    description: "Maximum supply cap (bonds, stablecoins, deposits)",
+    examples: ["1000000000000000000000000"]
+  }),
+  faceValue: assetAmount.optional().meta({
+    description: "Face value per bond in denomination asset units",
+    examples: ["1000000000000000000"]
+  }),
+  maturityDate: blocktime({ future: true }).optional().meta({
+    description: "Bond maturity date as unix timestamp",
+    examples: [1735689600]
+  }),
+  denominationAsset: ethereumAddress.optional().meta({
+    description: "ERC-20 token used as denomination asset for bonds",
+    examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
+  }),
+  uniqueIdentifier: z191.string().optional().meta({
+    description: "ISIN or other security identifier",
+    examples: ["US0378331005"]
+  }),
+  managementFeeBps: basisPoints().optional().meta({
+    description: "Annual management fee in basis points",
+    examples: [100, 250]
+  }),
+  maximumFractions: assetAmount.optional().meta({
+    description: "Maximum number of fractions for real-estate tokens",
+    examples: ["1000000000000000000000"]
+  }),
+  premintRecipient: ethereumAddress.optional().meta({
+    description: "Recipient of preminted real-estate fractions",
+    examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
+  }),
+  collateralRatioBps: z191.number().int().min(0).max(20000).optional().meta({
+    description: "Collateral ratio in basis points (10000 = 100%)",
+    examples: [1e4]
   }),
   metadataValues: z191.record(z191.string(), z191.union([z191.string(), z191.number().finite()])).optional().meta({
     description: "Custom metadata values from the instrument template",
@@ -12719,10 +12755,52 @@ function buildSortSchema(sortFields) {
   }
   return z274.enum(values);
 }
+function buildFlatFormatPreprocess(filterFieldNames) {
+  return (input) => {
+    if (typeof input !== "object" || input === null || Array.isArray(input)) {
+      return input;
+    }
+    const raw = input;
+    if (raw.filter !== undefined || raw.page !== undefined || raw.sort !== undefined) {
+      return input;
+    }
+    const hasFilterField = Object.keys(raw).some((key) => filterFieldNames.has(key));
+    const hasPaginationField = raw.limit !== undefined || raw.offset !== undefined;
+    const hasSortField = raw.sortBy !== undefined;
+    if (!hasFilterField && !hasPaginationField && !hasSortField) {
+      return input;
+    }
+    const filter = {};
+    const page = {};
+    let sort;
+    for (const [key, value2] of Object.entries(raw)) {
+      if (filterFieldNames.has(key) && value2 !== undefined) {
+        filter[key] = typeof value2 === "boolean" ? String(value2) : value2;
+      } else if (key === "limit" || key === "offset") {
+        page[key] = value2;
+      } else if (key === "sortBy" && typeof value2 === "string") {
+        const dir = raw.sortDirection === "desc" ? "-" : "";
+        sort = `${dir}${value2}`;
+      }
+    }
+    const result = {};
+    if (Object.keys(filter).length > 0) {
+      result.filter = filter;
+    }
+    if (Object.keys(page).length > 0) {
+      result.page = page;
+    }
+    if (sort !== undefined) {
+      result.sort = sort;
+    }
+    return result;
+  };
+}
 function createCollectionInputSchema(fields, options) {
   const sortFields = sortableFieldNames(fields);
   const sortDescription = `JSON:API sort param. Prefix with - for descending. Sortable fields: ${sortFields.join(", ")}`;
   const filterShape = buildFilterShape(fields, options.globalSearch ?? false);
+  const filterFieldNames = new Set(Object.keys(filterShape));
   const sortSchema = buildSortSchema(sortFields);
   const rawSchema = z274.object({
     sort: sortSchema.optional().meta({ description: sortDescription }),
@@ -12734,7 +12812,8 @@ function createCollectionInputSchema(fields, options) {
       description: "JSON:API filter params. Use filter[field]=value (shorthand) or filter[field][operator]=value (explicit)."
     })
   });
-  return rawSchema.transform((raw) => {
+  const preprocess = buildFlatFormatPreprocess(filterFieldNames);
+  return z274.preprocess(preprocess, rawSchema).transform((raw) => {
     const rawSort = typeof raw.sort === "string" ? raw.sort : undefined;
     const sorting = parseJsonApiSort(rawSort, fields, options.defaultSort);
     const filterInput = raw.filter;
@@ -23424,7 +23503,7 @@ var dalpSerializers = [
 // package.json
 var package_default = {
   name: "@settlemint/dalp-sdk",
-  version: "2.1.7-main.23442422201",
+  version: "2.1.7-main.23445298463",
   private: false,
   description: "Fully typed SDK for the DALP tokenization platform API",
   homepage: "https://settlemint.com",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@settlemint/dalp-sdk",
-  "version": "2.1.7-main.23442422201",
+  "version": "2.1.7-main.23445298463",
   "private": false,
   "description": "Fully typed SDK for the DALP tokenization platform API",
   "homepage": "https://settlemint.com",