// Binary represents some code compiled to its binary form.

// The protocol compiler can output a FileDescriptorSet containing the .proto files it parses.

// Describes a oneof.

// Describes an enum type.

// / @notice Emitted when the paused state is changed / @param paused The new paused state

// Describes a value within an enum.

// ModulesProgress is a message that is sent every 500ms

// / @notice Role accounts for pool management

// / @notice Emitted when a pool's recovery mode state is changed / @param pool The address of the pool / @param enabled The new recovery mode state

// Range of reserved numeric values. Reserved values may not be used by entries in the same enum. Reserved ranges may not overlap. Note that this is distinct from DescriptorProto.ReservedRange in that it is inclusive such that it can appropriately represent the entire int32 domain.

// / @notice Emitted when the recovery mode state is changed / @param enabled The new recovery mode state

// / @notice Emitted when an amplification parameter update is started / @param startValue The starting amplification value / @param endValue The ending amplification value / @param startTime The timestamp when the update starts / @param endTime The timestamp when the update ends

// Describes the relationship between generated code and its original source file. A GeneratedCodeInfo message is associated with only one generated source file, but may contain references to different source .proto files.

// Encapsulates information about the original source file from which a FileDescriptorProto was generated.

// / @notice Emitted when liquidity is removed from a pool / @param pool The address of the pool / @param liquidityProvider The address of the liquidity provider / @param kind The type of liquidity removal (enum as uint8) / @param totalSupply The total supply after removal / @param amountsRemovedRaw The amounts of tokens removed (as strings) / @param swapFeeAmountsRaw The swap fee amounts (as strings)

// Describes a message type.

// Balancer V2 WeightedPool, V3 StablePool and V3 Vault events https://github.com/balancer/balancer-v2-monorepo/blob/master/pkg/pool-weighted/contracts/WeightedPool.sol https://github.com/balancer/balancer-v3-monorepo

// StorePool - minimal pool storage type Primary key: pool address

// Range of reserved tag numbers. Reserved tag numbers may not be used by fields or extension ranges in the same message. Reserved ranges may not overlap.

// / @notice Emitted when a pool is initialized / @param pool The address of the pool

// Describes a service.

// / @notice Emitted when a swap is executed through the Vault / @param pool The address of the pool / @param tokenIn The address of the token being swapped in / @param tokenOut The address of the token being swapped out / @param amountIn The amount of token in / @param amountOut The amount of token out / @param swapFeePercentage The swap fee percentage / @param swapFeeAmount The swap fee amount

// / @notice Liquidity management configuration

// StoreModuleOutput are produced for store modules in development mode. It is not possible to retrieve store models in production, with parallelization enabled. If you need the deltas directly, write a pass through mapper module that will get them down to you.

// Describes a field within a message.

// Describes a method of a service.

// / @notice Emitted when the swap fee percentage is changed / @param swapFeePercentage The new swap fee percentage

// / @notice Emitted when a pool is registered / @param pool The address of the pool (indexed) / @param factory The address of the factory that created the pool (indexed) / @param tokenConfig Array of token configurations (token address, token type, rate provider, yield fee exempt) / @param swapFeePercentage The swap fee percentage for the pool / @param pauseWindowEndTime The timestamp when the pause window ends / @param roleAccounts Tuple of role account addresses (pause manager, swap fee manager, pool creator) / @param hooksConfig Hooks configuration flags and address / @param liquidityManagement Liquidity management configuration flags

// / @notice Emitted when the aggregate swap fee percentage is changed / @param pool The address of the pool / @param aggregateSwapFeePercentage The new aggregate swap fee percentage

// The name of the uninterpreted option. Each string represents a segment in a dot-separated name. is_extension is true iff a segment represents an extension (denoted with parentheses in options specs in .proto files). E.g.,{ ["foo", false], ["bar.baz", true], ["moo", false] } represents "foo.(bar.baz).moo".

// A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. # Examples Example 1: Compute Timestamp from POSIX `time()`. Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); Example 2: Compute Timestamp from POSIX `gettimeofday()`. struct timeval tv; gettimeofday(&tv, NULL); Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. Timestamp timestamp; timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); timestamp.set_nanos((INT32) ((ticks % 10000000) * 100)); Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. long millis = System.currentTimeMillis(); Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); Example 5: Compute Timestamp from Java `Instant.now()`. Instant now = Instant.now(); Timestamp timestamp = Timestamp.newBuilder().setSeconds(now.getEpochSecond()) .setNanos(now.getNano()).build(); Example 6: Compute Timestamp from current time in Python. timestamp = Timestamp() timestamp.GetCurrentTime() # JSON Mapping In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format.

// / @notice Token configuration for a pool

// / @notice Hooks configuration

// BlockUndoSignal informs you that every bit of data with a block number above 'last_valid_block' has been reverted on-chain. Delete that data and restart from 'last_valid_cursor'

// / @notice Emitted when a pool's paused state is changed / @param pool The address of the pool / @param paused The new paused state

// / @notice Emitted when an amplification parameter update is stopped / @param currentValue The current amplification value

// / @notice Emitted when liquidity is added to a pool / @param pool The address of the pool / @param liquidityProvider The address of the liquidity provider / @param kind The type of liquidity addition (enum as uint8) / @param totalSupply The total supply after addition / @param amountsAddedRaw The amounts of tokens added (as strings) / @param swapFeeAmountsRaw The swap fee amounts (as strings)

// BlockRef is a pointer to a block to which we don't know the timestamp

// A message representing a option the parser does not recognize. This only appears in options protos created by the compiler::Parser class. DescriptorPool resolves these when building Descriptor objects. Therefore, options protos in descriptor objects (e.g. returned by Descriptor::options(), or produced by Descriptor::CopyTo()) will never have UninterpretedOptions in them.

// `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". JSON The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": <string>, "lastName": <string> } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }

// Describes a complete .proto file.

// Clock is a pointer to a block with added timestamp

// ModuleStats gathers metrics and statistics from each module, running on tier1 or tier2 All the 'count' and 'time_ms' values may include duplicate for each stage going over that module

// / @notice Emitted when the protocol fee percentage cache is updated / @param feeType The fee type being updated / @param protocolFeePercentage The new protocol fee percentage