npm - @fairmint/canton-node-sdk - Versions diffs - 0.0.89 → 0.0.91 - Mend

@fairmint/canton-node-sdk 0.0.89 → 0.0.91

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (106) hide show

package/build/src/clients/ledger-json-api/operations/v2/updates/subscribe-to-flats.d.ts ADDED Viewed

@@ -0,0 +1,237 @@
+import { z } from 'zod';
+import { JsCantonErrorSchema, WsCantonErrorSchema } from '../../../schemas/api/errors';
+import { JsUpdateSchema, WsUpdateSchema } from '../../../schemas/api/updates';
+declare const UpdatesFlatsParamsSchema: z.ZodObject<{
+    beginExclusive: z.ZodNumber;
+    endInclusive: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    streamIdleTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    updateFormat: z.ZodObject<{
+        includeTransactions: z.ZodOptional<z.ZodObject<{
+            eventFormat: z.ZodObject<{
+                filtersByParty: z.ZodRecord<z.ZodString, z.ZodObject<{
+                    cumulative: z.ZodArray<z.ZodObject<{
+                        identifierFilter: z.ZodUnion<readonly [z.ZodObject<{
+                            Empty: z.ZodObject<{}, z.core.$strip>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            InterfaceFilter: z.ZodObject<{
+                                interfaceId: z.ZodString;
+                                includeInterfaceView: z.ZodOptional<z.ZodBoolean>;
+                                includeCreatedEventBlob: z.ZodOptional<z.ZodBoolean>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            TemplateFilter: z.ZodObject<{
+                                templateId: z.ZodString;
+                                includeCreatedEventBlob: z.ZodOptional<z.ZodBoolean>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            WildcardFilter: z.ZodObject<{
+                                includeCreatedEventBlob: z.ZodOptional<z.ZodBoolean>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>]>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                filtersForAnyParty: z.ZodOptional<z.ZodObject<{
+                    cumulative: z.ZodArray<z.ZodObject<{
+                        identifierFilter: z.ZodUnion<readonly [z.ZodObject<{
+                            Empty: z.ZodObject<{}, z.core.$strip>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            InterfaceFilter: z.ZodObject<{
+                                interfaceId: z.ZodString;
+                                includeInterfaceView: z.ZodOptional<z.ZodBoolean>;
+                                includeCreatedEventBlob: z.ZodOptional<z.ZodBoolean>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            TemplateFilter: z.ZodObject<{
+                                templateId: z.ZodString;
+                                includeCreatedEventBlob: z.ZodOptional<z.ZodBoolean>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            WildcardFilter: z.ZodObject<{
+                                includeCreatedEventBlob: z.ZodOptional<z.ZodBoolean>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>]>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                verbose: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>;
+            transactionShape: z.ZodUnion<readonly [z.ZodLiteral<"TRANSACTION_SHAPE_ACS_DELTA">, z.ZodLiteral<"TRANSACTION_SHAPE_LEDGER_EFFECTS">]>;
+        }, z.core.$strip>>;
+        includeReassignments: z.ZodOptional<z.ZodObject<{
+            filtersByParty: z.ZodRecord<z.ZodString, z.ZodObject<{
+                cumulative: z.ZodArray<z.ZodObject<{
+                    identifierFilter: z.ZodUnion<readonly [z.ZodObject<{
+                        Empty: z.ZodObject<{}, z.core.$strip>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        InterfaceFilter: z.ZodObject<{
+                            interfaceId: z.ZodString;
+                            includeInterfaceView: z.ZodOptional<z.ZodBoolean>;
+                            includeCreatedEventBlob: z.ZodOptional<z.ZodBoolean>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        TemplateFilter: z.ZodObject<{
+                            templateId: z.ZodString;
+                            includeCreatedEventBlob: z.ZodOptional<z.ZodBoolean>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        WildcardFilter: z.ZodObject<{
+                            includeCreatedEventBlob: z.ZodOptional<z.ZodBoolean>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>]>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            filtersForAnyParty: z.ZodOptional<z.ZodObject<{
+                cumulative: z.ZodArray<z.ZodObject<{
+                    identifierFilter: z.ZodUnion<readonly [z.ZodObject<{
+                        Empty: z.ZodObject<{}, z.core.$strip>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        InterfaceFilter: z.ZodObject<{
+                            interfaceId: z.ZodString;
+                            includeInterfaceView: z.ZodOptional<z.ZodBoolean>;
+                            includeCreatedEventBlob: z.ZodOptional<z.ZodBoolean>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        TemplateFilter: z.ZodObject<{
+                            templateId: z.ZodString;
+                            includeCreatedEventBlob: z.ZodOptional<z.ZodBoolean>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        WildcardFilter: z.ZodObject<{
+                            includeCreatedEventBlob: z.ZodOptional<z.ZodBoolean>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>]>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            verbose: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        includeTopologyEvents: z.ZodOptional<z.ZodObject<{
+            includeParticipantAuthorizationEvents: z.ZodOptional<z.ZodObject<{
+                parties: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type UpdatesFlatsWsParams = z.infer<typeof UpdatesFlatsParamsSchema>;
+export type UpdatesFlatsWsMessage = {
+    update: z.infer<typeof JsUpdateSchema>;
+} | {
+    update: z.infer<typeof WsUpdateSchema>;
+} | z.infer<typeof JsCantonErrorSchema> | z.infer<typeof WsCantonErrorSchema>;
+export declare const SubscribeToFlats: {
+    new (client: import("../../../../..").BaseClient): {
+        client: import("../../../../..").BaseClient;
+        validateParams<T>(params: T, schema: z.ZodType<T, unknown, z.core.$ZodTypeInternals<T, unknown>>): T;
+        subscribe(params: {
+            beginExclusive: number;
+            updateFormat: {
+                includeTransactions?: {
+                    eventFormat: {
+                        filtersByParty: Record<string, {
+                            cumulative: {
+                                identifierFilter: {
+                                    Empty: Record<string, never>;
+                                } | {
+                                    InterfaceFilter: {
+                                        interfaceId: string;
+                                        includeInterfaceView?: boolean | undefined;
+                                        includeCreatedEventBlob?: boolean | undefined;
+                                    };
+                                } | {
+                                    TemplateFilter: {
+                                        templateId: string;
+                                        includeCreatedEventBlob?: boolean | undefined;
+                                    };
+                                } | {
+                                    WildcardFilter: {
+                                        includeCreatedEventBlob?: boolean | undefined;
+                                    };
+                                };
+                            }[];
+                        }>;
+                        filtersForAnyParty?: {
+                            cumulative: {
+                                identifierFilter: {
+                                    Empty: Record<string, never>;
+                                } | {
+                                    InterfaceFilter: {
+                                        interfaceId: string;
+                                        includeInterfaceView?: boolean | undefined;
+                                        includeCreatedEventBlob?: boolean | undefined;
+                                    };
+                                } | {
+                                    TemplateFilter: {
+                                        templateId: string;
+                                        includeCreatedEventBlob?: boolean | undefined;
+                                    };
+                                } | {
+                                    WildcardFilter: {
+                                        includeCreatedEventBlob?: boolean | undefined;
+                                    };
+                                };
+                            }[];
+                        } | undefined;
+                        verbose?: boolean | undefined;
+                    };
+                    transactionShape: "TRANSACTION_SHAPE_ACS_DELTA" | "TRANSACTION_SHAPE_LEDGER_EFFECTS";
+                } | undefined;
+                includeReassignments?: {
+                    filtersByParty: Record<string, {
+                        cumulative: {
+                            identifierFilter: {
+                                Empty: Record<string, never>;
+                            } | {
+                                InterfaceFilter: {
+                                    interfaceId: string;
+                                    includeInterfaceView?: boolean | undefined;
+                                    includeCreatedEventBlob?: boolean | undefined;
+                                };
+                            } | {
+                                TemplateFilter: {
+                                    templateId: string;
+                                    includeCreatedEventBlob?: boolean | undefined;
+                                };
+                            } | {
+                                WildcardFilter: {
+                                    includeCreatedEventBlob?: boolean | undefined;
+                                };
+                            };
+                        }[];
+                    }>;
+                    filtersForAnyParty?: {
+                        cumulative: {
+                            identifierFilter: {
+                                Empty: Record<string, never>;
+                            } | {
+                                InterfaceFilter: {
+                                    interfaceId: string;
+                                    includeInterfaceView?: boolean | undefined;
+                                    includeCreatedEventBlob?: boolean | undefined;
+                                };
+                            } | {
+                                TemplateFilter: {
+                                    templateId: string;
+                                    includeCreatedEventBlob?: boolean | undefined;
+                                };
+                            } | {
+                                WildcardFilter: {
+                                    includeCreatedEventBlob?: boolean | undefined;
+                                };
+                            };
+                        }[];
+                    } | undefined;
+                    verbose?: boolean | undefined;
+                } | undefined;
+                includeTopologyEvents?: {
+                    includeParticipantAuthorizationEvents?: {
+                        parties?: string[] | undefined;
+                    } | undefined;
+                } | undefined;
+            };
+            endInclusive?: number | undefined;
+            limit?: number | undefined;
+            streamIdleTimeoutMs?: number | undefined;
+        }, handlers: import("../../../../..").WebSocketHandlers<UpdatesFlatsWsMessage, unknown>): Promise<import("../../../../..").WebSocketSubscription>;
+    };
+};
+export {};
+//# sourceMappingURL=subscribe-to-flats.d.ts.map

package/build/src/clients/ledger-json-api/operations/v2/updates/subscribe-to-flats.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"subscribe-to-flats.d.ts","sourceRoot":"","sources":["../../../../../../../src/clients/ledger-json-api/operations/v2/updates/subscribe-to-flats.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AACvF,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAM9E,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAyB,CAAC;AAExD,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC5E,MAAM,MAAM,qBAAqB,GAAG;IAAE,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;CAAE,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAExM,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0B3B,CAAC"}

package/build/src/clients/ledger-json-api/operations/v2/updates/subscribe-to-flats.js ADDED Viewed

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscribeToFlats = void 0;
+const zod_1 = require("zod");
+const WebSocketOperationFactory_1 = require("../../../../../core/operations/WebSocketOperationFactory");
+const updates_1 = require("../../../schemas/operations/updates");
+const errors_1 = require("../../../schemas/api/errors");
+const updates_2 = require("../../../schemas/api/updates");
+const format_normalizers_1 = require("./utils/format-normalizers");
+const WebSocketErrorUtils_1 = require("../../../../../core/ws/WebSocketErrorUtils");
+const path = '/v2/updates/flats';
+const UpdatesFlatsParamsSchema = updates_1.GetUpdatesParamsSchema;
+exports.SubscribeToFlats = (0, WebSocketOperationFactory_1.createWebSocketOperation)({
+    paramsSchema: UpdatesFlatsParamsSchema,
+    buildPath: (_params, _apiUrl) => `${path}`,
+    buildRequestMessage: (params) => {
+        const hasUpdateFormat = !!params.updateFormat;
+        const { filter, verbose } = (0, format_normalizers_1.buildWsRequestFilterAndVerbose)(params.updateFormat);
+        return {
+            beginExclusive: params.beginExclusive,
+            endInclusive: params.endInclusive,
+            // Server requires verbose; include it always. Only include filter when updateFormat is absent.
+            verbose,
+            ...(hasUpdateFormat ? { updateFormat: (0, format_normalizers_1.normalizeUpdateFormat)(params.updateFormat) } : { filter }),
+        };
+    },
+    transformInbound: (msg) => {
+        return WebSocketErrorUtils_1.WebSocketErrorUtils.parseUnion(msg, zod_1.z.union([
+            zod_1.z.object({ update: updates_2.JsUpdateSchema }),
+            zod_1.z.object({ update: updates_2.WsUpdateSchema }),
+            errors_1.JsCantonErrorSchema,
+            errors_1.WsCantonErrorSchema,
+        ]), 'SubscribeToFlats');
+    },
+});
+//# sourceMappingURL=subscribe-to-flats.js.map

package/build/src/clients/ledger-json-api/operations/v2/updates/subscribe-to-flats.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"subscribe-to-flats.js","sourceRoot":"","sources":["../../../../../../../src/clients/ledger-json-api/operations/v2/updates/subscribe-to-flats.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AACxB,wGAAoG;AACpG,iEAA6E;AAC7E,wDAAuF;AACvF,0DAA8E;AAC9E,mEAAmG;AACnG,oFAAiF;AAEjF,MAAM,IAAI,GAAG,mBAA4B,CAAC;AAE1C,MAAM,wBAAwB,GAAG,gCAAsB,CAAC;AAK3C,QAAA,gBAAgB,GAAG,IAAA,oDAAwB,EAAuD;IAC9G,YAAY,EAAE,wBAAwB;IACtC,SAAS,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE;IAC1C,mBAAmB,EAAE,CAAC,MAAM,EAAE,EAAE;QAC/B,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC;QAC9C,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,IAAA,mDAA8B,EAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QAChF,OAAO;YACN,cAAc,EAAE,MAAM,CAAC,cAAc;YACrC,YAAY,EAAE,MAAM,CAAC,YAAY;YACjC,+FAA+F;YAC/F,OAAO;YACP,GAAG,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,IAAA,0CAAqB,EAAC,MAAM,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC;SAChG,CAAC;IACH,CAAC;IACD,gBAAgB,EAAE,CAAC,GAAG,EAAE,EAAE;QACzB,OAAO,yCAAmB,CAAC,UAAU,CACpC,GAAG,EACH,OAAC,CAAC,KAAK,CAAC;YACP,OAAC,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,wBAAc,EAAE,CAAC;YACpC,OAAC,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,wBAAc,EAAE,CAAC;YACpC,4BAAmB;YACnB,4BAAmB;SACnB,CAAC,EACF,kBAAkB,CAClB,CAAC;IACH,CAAC;CACD,CAAC,CAAC"}

package/build/src/clients/ledger-json-api/operations/v2/updates/subscribe-to-trees.d.ts ADDED Viewed

@@ -0,0 +1,239 @@
+import { z } from 'zod';
+import { JsCantonErrorSchema, WsCantonErrorSchema } from '../../../schemas/api/errors';
+import { JsTransactionTreeSchema, WsUpdateTreesSchema } from '../../../schemas/api/updates';
+declare const UpdatesTreesParamsSchema: z.ZodObject<{
+    beginExclusive: z.ZodNumber;
+    endInclusive: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    streamIdleTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    updateFormat: z.ZodObject<{
+        includeTransactions: z.ZodOptional<z.ZodObject<{
+            eventFormat: z.ZodObject<{
+                filtersByParty: z.ZodRecord<z.ZodString, z.ZodObject<{
+                    cumulative: z.ZodArray<z.ZodObject<{
+                        identifierFilter: z.ZodUnion<readonly [z.ZodObject<{
+                            Empty: z.ZodObject<{}, z.core.$strip>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            InterfaceFilter: z.ZodObject<{
+                                interfaceId: z.ZodString;
+                                includeInterfaceView: z.ZodOptional<z.ZodBoolean>;
+                                includeCreatedEventBlob: z.ZodOptional<z.ZodBoolean>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            TemplateFilter: z.ZodObject<{
+                                templateId: z.ZodString;
+                                includeCreatedEventBlob: z.ZodOptional<z.ZodBoolean>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            WildcardFilter: z.ZodObject<{
+                                includeCreatedEventBlob: z.ZodOptional<z.ZodBoolean>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>]>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                filtersForAnyParty: z.ZodOptional<z.ZodObject<{
+                    cumulative: z.ZodArray<z.ZodObject<{
+                        identifierFilter: z.ZodUnion<readonly [z.ZodObject<{
+                            Empty: z.ZodObject<{}, z.core.$strip>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            InterfaceFilter: z.ZodObject<{
+                                interfaceId: z.ZodString;
+                                includeInterfaceView: z.ZodOptional<z.ZodBoolean>;
+                                includeCreatedEventBlob: z.ZodOptional<z.ZodBoolean>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            TemplateFilter: z.ZodObject<{
+                                templateId: z.ZodString;
+                                includeCreatedEventBlob: z.ZodOptional<z.ZodBoolean>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            WildcardFilter: z.ZodObject<{
+                                includeCreatedEventBlob: z.ZodOptional<z.ZodBoolean>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>]>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                verbose: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>;
+            transactionShape: z.ZodUnion<readonly [z.ZodLiteral<"TRANSACTION_SHAPE_ACS_DELTA">, z.ZodLiteral<"TRANSACTION_SHAPE_LEDGER_EFFECTS">]>;
+        }, z.core.$strip>>;
+        includeReassignments: z.ZodOptional<z.ZodObject<{
+            filtersByParty: z.ZodRecord<z.ZodString, z.ZodObject<{
+                cumulative: z.ZodArray<z.ZodObject<{
+                    identifierFilter: z.ZodUnion<readonly [z.ZodObject<{
+                        Empty: z.ZodObject<{}, z.core.$strip>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        InterfaceFilter: z.ZodObject<{
+                            interfaceId: z.ZodString;
+                            includeInterfaceView: z.ZodOptional<z.ZodBoolean>;
+                            includeCreatedEventBlob: z.ZodOptional<z.ZodBoolean>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        TemplateFilter: z.ZodObject<{
+                            templateId: z.ZodString;
+                            includeCreatedEventBlob: z.ZodOptional<z.ZodBoolean>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        WildcardFilter: z.ZodObject<{
+                            includeCreatedEventBlob: z.ZodOptional<z.ZodBoolean>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>]>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            filtersForAnyParty: z.ZodOptional<z.ZodObject<{
+                cumulative: z.ZodArray<z.ZodObject<{
+                    identifierFilter: z.ZodUnion<readonly [z.ZodObject<{
+                        Empty: z.ZodObject<{}, z.core.$strip>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        InterfaceFilter: z.ZodObject<{
+                            interfaceId: z.ZodString;
+                            includeInterfaceView: z.ZodOptional<z.ZodBoolean>;
+                            includeCreatedEventBlob: z.ZodOptional<z.ZodBoolean>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        TemplateFilter: z.ZodObject<{
+                            templateId: z.ZodString;
+                            includeCreatedEventBlob: z.ZodOptional<z.ZodBoolean>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        WildcardFilter: z.ZodObject<{
+                            includeCreatedEventBlob: z.ZodOptional<z.ZodBoolean>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>]>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            verbose: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        includeTopologyEvents: z.ZodOptional<z.ZodObject<{
+            includeParticipantAuthorizationEvents: z.ZodOptional<z.ZodObject<{
+                parties: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type UpdatesTreesWsParams = z.infer<typeof UpdatesTreesParamsSchema>;
+export type UpdatesTreesWsMessage = {
+    update: {
+        JsTransactionTree: z.infer<typeof JsTransactionTreeSchema>;
+    };
+} | {
+    update: z.infer<typeof WsUpdateTreesSchema>;
+} | z.infer<typeof JsCantonErrorSchema> | z.infer<typeof WsCantonErrorSchema>;
+export declare const SubscribeToTrees: {
+    new (client: import("../../../../..").BaseClient): {
+        client: import("../../../../..").BaseClient;
+        validateParams<T>(params: T, schema: z.ZodType<T, unknown, z.core.$ZodTypeInternals<T, unknown>>): T;
+        subscribe(params: {
+            beginExclusive: number;
+            updateFormat: {
+                includeTransactions?: {
+                    eventFormat: {
+                        filtersByParty: Record<string, {
+                            cumulative: {
+                                identifierFilter: {
+                                    Empty: Record<string, never>;
+                                } | {
+                                    InterfaceFilter: {
+                                        interfaceId: string;
+                                        includeInterfaceView?: boolean | undefined;
+                                        includeCreatedEventBlob?: boolean | undefined;
+                                    };
+                                } | {
+                                    TemplateFilter: {
+                                        templateId: string;
+                                        includeCreatedEventBlob?: boolean | undefined;
+                                    };
+                                } | {
+                                    WildcardFilter: {
+                                        includeCreatedEventBlob?: boolean | undefined;
+                                    };
+                                };
+                            }[];
+                        }>;
+                        filtersForAnyParty?: {
+                            cumulative: {
+                                identifierFilter: {
+                                    Empty: Record<string, never>;
+                                } | {
+                                    InterfaceFilter: {
+                                        interfaceId: string;
+                                        includeInterfaceView?: boolean | undefined;
+                                        includeCreatedEventBlob?: boolean | undefined;
+                                    };
+                                } | {
+                                    TemplateFilter: {
+                                        templateId: string;
+                                        includeCreatedEventBlob?: boolean | undefined;
+                                    };
+                                } | {
+                                    WildcardFilter: {
+                                        includeCreatedEventBlob?: boolean | undefined;
+                                    };
+                                };
+                            }[];
+                        } | undefined;
+                        verbose?: boolean | undefined;
+                    };
+                    transactionShape: "TRANSACTION_SHAPE_ACS_DELTA" | "TRANSACTION_SHAPE_LEDGER_EFFECTS";
+                } | undefined;
+                includeReassignments?: {
+                    filtersByParty: Record<string, {
+                        cumulative: {
+                            identifierFilter: {
+                                Empty: Record<string, never>;
+                            } | {
+                                InterfaceFilter: {
+                                    interfaceId: string;
+                                    includeInterfaceView?: boolean | undefined;
+                                    includeCreatedEventBlob?: boolean | undefined;
+                                };
+                            } | {
+                                TemplateFilter: {
+                                    templateId: string;
+                                    includeCreatedEventBlob?: boolean | undefined;
+                                };
+                            } | {
+                                WildcardFilter: {
+                                    includeCreatedEventBlob?: boolean | undefined;
+                                };
+                            };
+                        }[];
+                    }>;
+                    filtersForAnyParty?: {
+                        cumulative: {
+                            identifierFilter: {
+                                Empty: Record<string, never>;
+                            } | {
+                                InterfaceFilter: {
+                                    interfaceId: string;
+                                    includeInterfaceView?: boolean | undefined;
+                                    includeCreatedEventBlob?: boolean | undefined;
+                                };
+                            } | {
+                                TemplateFilter: {
+                                    templateId: string;
+                                    includeCreatedEventBlob?: boolean | undefined;
+                                };
+                            } | {
+                                WildcardFilter: {
+                                    includeCreatedEventBlob?: boolean | undefined;
+                                };
+                            };
+                        }[];
+                    } | undefined;
+                    verbose?: boolean | undefined;
+                } | undefined;
+                includeTopologyEvents?: {
+                    includeParticipantAuthorizationEvents?: {
+                        parties?: string[] | undefined;
+                    } | undefined;
+                } | undefined;
+            };
+            endInclusive?: number | undefined;
+            limit?: number | undefined;
+            streamIdleTimeoutMs?: number | undefined;
+        }, handlers: import("../../../../..").WebSocketHandlers<UpdatesTreesWsMessage, unknown>): Promise<import("../../../../..").WebSocketSubscription>;
+    };
+};
+export {};
+//# sourceMappingURL=subscribe-to-trees.d.ts.map

package/build/src/clients/ledger-json-api/operations/v2/updates/subscribe-to-trees.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"subscribe-to-trees.d.ts","sourceRoot":"","sources":["../../../../../../../src/clients/ledger-json-api/operations/v2/updates/subscribe-to-trees.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AACvF,OAAO,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAM5F,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAyB,CAAC;AAExD,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC5E,MAAM,MAAM,qBAAqB,GAAG;IAAE,MAAM,EAAE;QAAE,iBAAiB,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;KAAE,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;CAAE,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAE7O,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwB3B,CAAC"}

package/build/src/clients/ledger-json-api/operations/v2/updates/subscribe-to-trees.js ADDED Viewed

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscribeToTrees = void 0;
+const zod_1 = require("zod");
+const WebSocketOperationFactory_1 = require("../../../../../core/operations/WebSocketOperationFactory");
+const updates_1 = require("../../../schemas/operations/updates");
+const errors_1 = require("../../../schemas/api/errors");
+const updates_2 = require("../../../schemas/api/updates");
+const format_normalizers_1 = require("./utils/format-normalizers");
+const WebSocketErrorUtils_1 = require("../../../../../core/ws/WebSocketErrorUtils");
+const path = '/v2/updates/trees';
+const UpdatesTreesParamsSchema = updates_1.GetUpdatesParamsSchema;
+exports.SubscribeToTrees = (0, WebSocketOperationFactory_1.createWebSocketOperation)({
+    paramsSchema: UpdatesTreesParamsSchema,
+    buildPath: (_params, _apiUrl) => `${path}`,
+    buildRequestMessage: (params) => {
+        const { filter, verbose } = (0, format_normalizers_1.buildWsRequestFilterAndVerbose)(params.updateFormat);
+        return {
+            beginExclusive: params.beginExclusive,
+            endInclusive: params.endInclusive,
+            verbose,
+            filter,
+        };
+    },
+    transformInbound: (msg) => {
+        return WebSocketErrorUtils_1.WebSocketErrorUtils.parseUnion(msg, zod_1.z.union([
+            zod_1.z.object({ update: zod_1.z.object({ JsTransactionTree: updates_2.JsTransactionTreeSchema }) }),
+            zod_1.z.object({ update: updates_2.WsUpdateTreesSchema }),
+            errors_1.JsCantonErrorSchema,
+            errors_1.WsCantonErrorSchema,
+        ]), 'SubscribeToTrees');
+    },
+});
+//# sourceMappingURL=subscribe-to-trees.js.map

package/build/src/clients/ledger-json-api/operations/v2/updates/subscribe-to-trees.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"subscribe-to-trees.js","sourceRoot":"","sources":["../../../../../../../src/clients/ledger-json-api/operations/v2/updates/subscribe-to-trees.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AACxB,wGAAoG;AACpG,iEAA6E;AAC7E,wDAAuF;AACvF,0DAA4F;AAC5F,mEAA4E;AAC5E,oFAAiF;AAEjF,MAAM,IAAI,GAAG,mBAA4B,CAAC;AAE1C,MAAM,wBAAwB,GAAG,gCAAsB,CAAC;AAK3C,QAAA,gBAAgB,GAAG,IAAA,oDAAwB,EAAuD;IAC9G,YAAY,EAAE,wBAAwB;IACtC,SAAS,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE;IAC1C,mBAAmB,EAAE,CAAC,MAAM,EAAE,EAAE;QAC/B,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,IAAA,mDAA8B,EAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QAChF,OAAO;YACN,cAAc,EAAE,MAAM,CAAC,cAAc;YACrC,YAAY,EAAE,MAAM,CAAC,YAAY;YACjC,OAAO;YACP,MAAM;SACN,CAAC;IACH,CAAC;IACD,gBAAgB,EAAE,CAAC,GAAG,EAAE,EAAE;QACzB,OAAO,yCAAmB,CAAC,UAAU,CACpC,GAAG,EACH,OAAC,CAAC,KAAK,CAAC;YACP,OAAC,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,OAAC,CAAC,MAAM,CAAC,EAAE,iBAAiB,EAAE,iCAAuB,EAAE,CAAC,EAAE,CAAC;YAC9E,OAAC,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,6BAAmB,EAAE,CAAC;YACzC,4BAAmB;YACnB,4BAAmB;SACnB,CAAC,EACF,kBAAkB,CAClB,CAAC;IACH,CAAC;CACD,CAAC,CAAC"}

package/build/src/clients/ledger-json-api/operations/v2/updates/utils/format-normalizers.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+import type { GetUpdatesParams, IdentifierFilter } from '../../../../schemas/operations/updates';
+export declare function normalizeIdentifierFilter(filter: IdentifierFilter): unknown;
+export declare function normalizeUpdateFormat(p: GetUpdatesParams['updateFormat']): unknown;
+export declare function buildWsRequestFilterAndVerbose(p: GetUpdatesParams['updateFormat']): {
+    filter?: unknown;
+    verbose: boolean;
+};
+//# sourceMappingURL=format-normalizers.d.ts.map

package/build/src/clients/ledger-json-api/operations/v2/updates/utils/format-normalizers.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"format-normalizers.d.ts","sourceRoot":"","sources":["../../../../../../../../src/clients/ledger-json-api/operations/v2/updates/utils/format-normalizers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,wCAAwC,CAAC;AAEjG,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAiB3E;AAED,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,gBAAgB,CAAC,cAAc,CAAC,GAAG,OAAO,CA8ClF;AAGD,wBAAgB,8BAA8B,CAAC,CAAC,EAAE,gBAAgB,CAAC,cAAc,CAAC,GAAG;IAAE,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CA8B1H"}