@fairmint/canton-node-sdk 0.0.108 → 0.0.110

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

@@ -1,282 +0,0 @@
-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<{
-                                value: z.ZodObject<{
-                                    interfaceId: z.ZodString;
-                                    includeInterfaceView: z.ZodBoolean;
-                                    includeCreatedEventBlob: z.ZodBoolean;
-                                }, z.core.$strip>;
-                            }, z.core.$strip>;
-                        }, z.core.$strip>, z.ZodObject<{
-                            TemplateFilter: z.ZodObject<{
-                                value: z.ZodObject<{
-                                    templateId: z.ZodString;
-                                    includeCreatedEventBlob: z.ZodBoolean;
-                                }, z.core.$strip>;
-                            }, z.core.$strip>;
-                        }, z.core.$strip>, z.ZodObject<{
-                            WildcardFilter: z.ZodObject<{
-                                value: z.ZodObject<{
-                                    includeCreatedEventBlob: z.ZodBoolean;
-                                }, z.core.$strip>;
-                            }, 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<{
-                                value: z.ZodObject<{
-                                    interfaceId: z.ZodString;
-                                    includeInterfaceView: z.ZodBoolean;
-                                    includeCreatedEventBlob: z.ZodBoolean;
-                                }, z.core.$strip>;
-                            }, z.core.$strip>;
-                        }, z.core.$strip>, z.ZodObject<{
-                            TemplateFilter: z.ZodObject<{
-                                value: z.ZodObject<{
-                                    templateId: z.ZodString;
-                                    includeCreatedEventBlob: z.ZodBoolean;
-                                }, z.core.$strip>;
-                            }, z.core.$strip>;
-                        }, z.core.$strip>, z.ZodObject<{
-                            WildcardFilter: z.ZodObject<{
-                                value: z.ZodObject<{
-                                    includeCreatedEventBlob: z.ZodBoolean;
-                                }, z.core.$strip>;
-                            }, 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<{
-                            value: z.ZodObject<{
-                                interfaceId: z.ZodString;
-                                includeInterfaceView: z.ZodBoolean;
-                                includeCreatedEventBlob: z.ZodBoolean;
-                            }, z.core.$strip>;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>, z.ZodObject<{
-                        TemplateFilter: z.ZodObject<{
-                            value: z.ZodObject<{
-                                templateId: z.ZodString;
-                                includeCreatedEventBlob: z.ZodBoolean;
-                            }, z.core.$strip>;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>, z.ZodObject<{
-                        WildcardFilter: z.ZodObject<{
-                            value: z.ZodObject<{
-                                includeCreatedEventBlob: z.ZodBoolean;
-                            }, z.core.$strip>;
-                        }, 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<{
-                            value: z.ZodObject<{
-                                interfaceId: z.ZodString;
-                                includeInterfaceView: z.ZodBoolean;
-                                includeCreatedEventBlob: z.ZodBoolean;
-                            }, z.core.$strip>;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>, z.ZodObject<{
-                        TemplateFilter: z.ZodObject<{
-                            value: z.ZodObject<{
-                                templateId: z.ZodString;
-                                includeCreatedEventBlob: z.ZodBoolean;
-                            }, z.core.$strip>;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>, z.ZodObject<{
-                        WildcardFilter: z.ZodObject<{
-                            value: z.ZodObject<{
-                                includeCreatedEventBlob: z.ZodBoolean;
-                            }, z.core.$strip>;
-                        }, 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;
-    subscribe: (params: {
-        beginExclusive: number;
-        updateFormat: {
-            includeTransactions?: {
-                eventFormat: {
-                    filtersByParty: Record<string, {
-                        cumulative: {
-                            identifierFilter: {
-                                Empty: Record<string, never>;
-                            } | {
-                                InterfaceFilter: {
-                                    value: {
-                                        interfaceId: string;
-                                        includeInterfaceView: boolean;
-                                        includeCreatedEventBlob: boolean;
-                                    };
-                                };
-                            } | {
-                                TemplateFilter: {
-                                    value: {
-                                        templateId: string;
-                                        includeCreatedEventBlob: boolean;
-                                    };
-                                };
-                            } | {
-                                WildcardFilter: {
-                                    value: {
-                                        includeCreatedEventBlob: boolean;
-                                    };
-                                };
-                            };
-                        }[];
-                    }>;
-                    filtersForAnyParty?: {
-                        cumulative: {
-                            identifierFilter: {
-                                Empty: Record<string, never>;
-                            } | {
-                                InterfaceFilter: {
-                                    value: {
-                                        interfaceId: string;
-                                        includeInterfaceView: boolean;
-                                        includeCreatedEventBlob: boolean;
-                                    };
-                                };
-                            } | {
-                                TemplateFilter: {
-                                    value: {
-                                        templateId: string;
-                                        includeCreatedEventBlob: boolean;
-                                    };
-                                };
-                            } | {
-                                WildcardFilter: {
-                                    value: {
-                                        includeCreatedEventBlob: boolean;
-                                    };
-                                };
-                            };
-                        }[];
-                    } | 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: {
-                                value: {
-                                    interfaceId: string;
-                                    includeInterfaceView: boolean;
-                                    includeCreatedEventBlob: boolean;
-                                };
-                            };
-                        } | {
-                            TemplateFilter: {
-                                value: {
-                                    templateId: string;
-                                    includeCreatedEventBlob: boolean;
-                                };
-                            };
-                        } | {
-                            WildcardFilter: {
-                                value: {
-                                    includeCreatedEventBlob: boolean;
-                                };
-                            };
-                        };
-                    }[];
-                }>;
-                filtersForAnyParty?: {
-                    cumulative: {
-                        identifierFilter: {
-                            Empty: Record<string, never>;
-                        } | {
-                            InterfaceFilter: {
-                                value: {
-                                    interfaceId: string;
-                                    includeInterfaceView: boolean;
-                                    includeCreatedEventBlob: boolean;
-                                };
-                            };
-                        } | {
-                            TemplateFilter: {
-                                value: {
-                                    templateId: string;
-                                    includeCreatedEventBlob: boolean;
-                                };
-                            };
-                        } | {
-                            WildcardFilter: {
-                                value: {
-                                    includeCreatedEventBlob: boolean;
-                                };
-                            };
-                        };
-                    }[];
-                } | 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

@@ -1 +0,0 @@
-{"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,GAC7B;IAAE,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;CAAE,GAC1C;IAAE,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;CAAE,GAC1C,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,GACnC,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAExC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyB3B,CAAC"}

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

@@ -1,34 +0,0 @@
-"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 WebSocketErrorUtils_1 = require("../../../../../core/ws/WebSocketErrorUtils");
-const errors_1 = require("../../../schemas/api/errors");
-const updates_1 = require("../../../schemas/api/updates");
-const updates_2 = require("../../../schemas/operations/updates");
-const format_normalizers_1 = require("./utils/format-normalizers");
-const path = '/v2/updates/flats';
-const UpdatesFlatsParamsSchema = updates_2.GetUpdatesParamsSchema;
-exports.SubscribeToFlats = (0, WebSocketOperationFactory_1.createWebSocketOperation)({
-    paramsSchema: UpdatesFlatsParamsSchema,
-    buildPath: (_params, _apiUrl) => `${path}`,
-    buildRequestMessage: (params) => {
-        const hasUpdateFormat = Boolean(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) => WebSocketErrorUtils_1.WebSocketErrorUtils.parseUnion(msg, zod_1.z.union([
-        zod_1.z.object({ update: updates_1.JsUpdateSchema }),
-        zod_1.z.object({ update: updates_1.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

@@ -1 +0,0 @@
-{"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,oFAAiF;AACjF,wDAAuF;AACvF,0DAA8E;AAC9E,iEAA6E;AAC7E,mEAAmG;AAEnG,MAAM,IAAI,GAAG,mBAA4B,CAAC;AAE1C,MAAM,wBAAwB,GAAG,gCAAsB,CAAC;AAS3C,QAAA,gBAAgB,GAAG,IAAA,oDAAwB,EAAuD;IAC7G,YAAY,EAAE,wBAAwB;IACtC,SAAS,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE;IAC1C,mBAAmB,EAAE,CAAC,MAAM,EAAE,EAAE;QAC9B,MAAM,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QACrD,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,IAAA,mDAA8B,EAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QAChF,OAAO;YACL,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;SACjG,CAAC;IACJ,CAAC;IACD,gBAAgB,EAAE,CAAC,GAAG,EAAE,EAAE,CACxB,yCAAmB,CAAC,UAAU,CAC5B,GAAG,EACH,OAAC,CAAC,KAAK,CAAC;QACN,OAAC,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,wBAAc,EAAE,CAAC;QACpC,OAAC,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,wBAAc,EAAE,CAAC;QACpC,4BAAmB;QACnB,4BAAmB;KACpB,CAAC,EACF,kBAAkB,CACnB;CACJ,CAAC,CAAC"}

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

@@ -1,284 +0,0 @@
-import { type z } from 'zod';
-import { type JsCantonErrorSchema, type WsCantonErrorSchema } from '../../../schemas/api/errors';
-import { type JsTransactionTreeSchema, type 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<{
-                                value: z.ZodObject<{
-                                    interfaceId: z.ZodString;
-                                    includeInterfaceView: z.ZodBoolean;
-                                    includeCreatedEventBlob: z.ZodBoolean;
-                                }, z.core.$strip>;
-                            }, z.core.$strip>;
-                        }, z.core.$strip>, z.ZodObject<{
-                            TemplateFilter: z.ZodObject<{
-                                value: z.ZodObject<{
-                                    templateId: z.ZodString;
-                                    includeCreatedEventBlob: z.ZodBoolean;
-                                }, z.core.$strip>;
-                            }, z.core.$strip>;
-                        }, z.core.$strip>, z.ZodObject<{
-                            WildcardFilter: z.ZodObject<{
-                                value: z.ZodObject<{
-                                    includeCreatedEventBlob: z.ZodBoolean;
-                                }, z.core.$strip>;
-                            }, 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<{
-                                value: z.ZodObject<{
-                                    interfaceId: z.ZodString;
-                                    includeInterfaceView: z.ZodBoolean;
-                                    includeCreatedEventBlob: z.ZodBoolean;
-                                }, z.core.$strip>;
-                            }, z.core.$strip>;
-                        }, z.core.$strip>, z.ZodObject<{
-                            TemplateFilter: z.ZodObject<{
-                                value: z.ZodObject<{
-                                    templateId: z.ZodString;
-                                    includeCreatedEventBlob: z.ZodBoolean;
-                                }, z.core.$strip>;
-                            }, z.core.$strip>;
-                        }, z.core.$strip>, z.ZodObject<{
-                            WildcardFilter: z.ZodObject<{
-                                value: z.ZodObject<{
-                                    includeCreatedEventBlob: z.ZodBoolean;
-                                }, z.core.$strip>;
-                            }, 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<{
-                            value: z.ZodObject<{
-                                interfaceId: z.ZodString;
-                                includeInterfaceView: z.ZodBoolean;
-                                includeCreatedEventBlob: z.ZodBoolean;
-                            }, z.core.$strip>;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>, z.ZodObject<{
-                        TemplateFilter: z.ZodObject<{
-                            value: z.ZodObject<{
-                                templateId: z.ZodString;
-                                includeCreatedEventBlob: z.ZodBoolean;
-                            }, z.core.$strip>;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>, z.ZodObject<{
-                        WildcardFilter: z.ZodObject<{
-                            value: z.ZodObject<{
-                                includeCreatedEventBlob: z.ZodBoolean;
-                            }, z.core.$strip>;
-                        }, 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<{
-                            value: z.ZodObject<{
-                                interfaceId: z.ZodString;
-                                includeInterfaceView: z.ZodBoolean;
-                                includeCreatedEventBlob: z.ZodBoolean;
-                            }, z.core.$strip>;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>, z.ZodObject<{
-                        TemplateFilter: z.ZodObject<{
-                            value: z.ZodObject<{
-                                templateId: z.ZodString;
-                                includeCreatedEventBlob: z.ZodBoolean;
-                            }, z.core.$strip>;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>, z.ZodObject<{
-                        WildcardFilter: z.ZodObject<{
-                            value: z.ZodObject<{
-                                includeCreatedEventBlob: z.ZodBoolean;
-                            }, z.core.$strip>;
-                        }, 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;
-    subscribe: (params: {
-        beginExclusive: number;
-        updateFormat: {
-            includeTransactions?: {
-                eventFormat: {
-                    filtersByParty: Record<string, {
-                        cumulative: {
-                            identifierFilter: {
-                                Empty: Record<string, never>;
-                            } | {
-                                InterfaceFilter: {
-                                    value: {
-                                        interfaceId: string;
-                                        includeInterfaceView: boolean;
-                                        includeCreatedEventBlob: boolean;
-                                    };
-                                };
-                            } | {
-                                TemplateFilter: {
-                                    value: {
-                                        templateId: string;
-                                        includeCreatedEventBlob: boolean;
-                                    };
-                                };
-                            } | {
-                                WildcardFilter: {
-                                    value: {
-                                        includeCreatedEventBlob: boolean;
-                                    };
-                                };
-                            };
-                        }[];
-                    }>;
-                    filtersForAnyParty?: {
-                        cumulative: {
-                            identifierFilter: {
-                                Empty: Record<string, never>;
-                            } | {
-                                InterfaceFilter: {
-                                    value: {
-                                        interfaceId: string;
-                                        includeInterfaceView: boolean;
-                                        includeCreatedEventBlob: boolean;
-                                    };
-                                };
-                            } | {
-                                TemplateFilter: {
-                                    value: {
-                                        templateId: string;
-                                        includeCreatedEventBlob: boolean;
-                                    };
-                                };
-                            } | {
-                                WildcardFilter: {
-                                    value: {
-                                        includeCreatedEventBlob: boolean;
-                                    };
-                                };
-                            };
-                        }[];
-                    } | 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: {
-                                value: {
-                                    interfaceId: string;
-                                    includeInterfaceView: boolean;
-                                    includeCreatedEventBlob: boolean;
-                                };
-                            };
-                        } | {
-                            TemplateFilter: {
-                                value: {
-                                    templateId: string;
-                                    includeCreatedEventBlob: boolean;
-                                };
-                            };
-                        } | {
-                            WildcardFilter: {
-                                value: {
-                                    includeCreatedEventBlob: boolean;
-                                };
-                            };
-                        };
-                    }[];
-                }>;
-                filtersForAnyParty?: {
-                    cumulative: {
-                        identifierFilter: {
-                            Empty: Record<string, never>;
-                        } | {
-                            InterfaceFilter: {
-                                value: {
-                                    interfaceId: string;
-                                    includeInterfaceView: boolean;
-                                    includeCreatedEventBlob: boolean;
-                                };
-                            };
-                        } | {
-                            TemplateFilter: {
-                                value: {
-                                    templateId: string;
-                                    includeCreatedEventBlob: boolean;
-                                };
-                            };
-                        } | {
-                            WildcardFilter: {
-                                value: {
-                                    includeCreatedEventBlob: boolean;
-                                };
-                            };
-                        };
-                    }[];
-                } | 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

@@ -1 +0,0 @@
-{"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,KAAK,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,EAAE,KAAK,mBAAmB,EAAE,KAAK,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AACjG,OAAO,EAAE,KAAK,uBAAuB,EAAE,KAAK,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAMtG,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAyB,CAAC;AAExD,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC5E,MAAM,MAAM,qBAAqB,GAC7B;IAAE,MAAM,EAAE;QAAE,iBAAiB,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;KAAE,CAAA;CAAE,GAC1E;IAAE,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;CAAE,GAC/C,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,GACnC,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAExC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAY3B,CAAC"}

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

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SubscribeToTrees = void 0;
-const WebSocketOperationFactory_1 = require("../../../../../core/operations/WebSocketOperationFactory");
-const updates_1 = require("../../../schemas/operations/updates");
-const format_normalizers_1 = require("./utils/format-normalizers");
-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,
-        };
-    },
-});
-//# sourceMappingURL=subscribe-to-trees.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"subscribe-to-trees.js","sourceRoot":"","sources":["../../../../../../../src/clients/ledger-json-api/operations/v2/updates/subscribe-to-trees.ts"],"names":[],"mappings":";;;AACA,wGAAoG;AAGpG,iEAA6E;AAC7E,mEAA4E;AAE5E,MAAM,IAAI,GAAG,mBAA4B,CAAC;AAE1C,MAAM,wBAAwB,GAAG,gCAAsB,CAAC;AAS3C,QAAA,gBAAgB,GAAG,IAAA,oDAAwB,EAAuD;IAC7G,YAAY,EAAE,wBAAwB;IACtC,SAAS,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE;IAC1C,mBAAmB,EAAE,CAAC,MAAM,EAAE,EAAE;QAC9B,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,IAAA,mDAA8B,EAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QAChF,OAAO;YACL,cAAc,EAAE,MAAM,CAAC,cAAc;YACrC,YAAY,EAAE,MAAM,CAAC,YAAY;YACjC,OAAO;YACP,MAAM;SACP,CAAC;IACJ,CAAC;CACF,CAAC,CAAC"}

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

@@ -1,7 +0,0 @@
-import type { GetUpdatesParams } from '../../../../schemas/operations/updates';
-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

@@ -1 +0,0 @@
-{"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,EAAoB,MAAM,wCAAwC,CAAC;AAEjG,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,gBAAgB,CAAC,cAAc,CAAC,GAAG,OAAO,CA8DlF;AAGD,wBAAgB,8BAA8B,CAAC,CAAC,EAAE,gBAAgB,CAAC,cAAc,CAAC,GAAG;IACnF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;CAClB,CAmCA"}