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

// 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.

// Executed proposals have been approved and executed onchain in a DAO-based space's main voting plugin. The DAO itself also emits the executed event, but the ABI/interface is different. We really only care about the one from our plugins.

// 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.

// 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.

// * Votes represent a vote on a proposal in a DAO-based space. Currently we use a simple majority voting model, where a proposal requires 51% of the available votes in order to pass. Only editors are allowed to vote on proposals, but editors _and_ members can create them.

// Describes an enum type.

// 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

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

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

// Describes a field within a message.

// 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'

// * The new DAO-based space contracts are based on Aragon's OSX architecture which uses plugins to define functionality assigned to a DAO (See the top level comment for more information on Aragon's DAO architecture). This event maps creation of any governance plugins and associates the governance plugins contract addresses with the address of the DAO contract. As of January 23, 2024 there are two governance plugins: 1. Voting plugin – This defines the voting and proposal rules and behaviors for a DAO 2. Member access plugin – This defines the membership rules and behaviors for a DAO

// Describes a oneof.

// Describes a service.

// 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.

// * The new DAO-based space contracts are based on Aragon's OSX architecture which uses plugins to define functionality assigned to a DAO (See the top level comment for more information on Aragon's DAO architecture). This event maps creation of the Space plugin and associates the Space plugin contract address with the address of the DAO contract.

// Describes a complete .proto file.

// 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".

// * Processed Proposals represent content that has been approved by a DAO and executed onchain. We use the content URI to represent the content that was approved. We only consume the `proposalId` in the content URI to map the processed data to an existing proposal onchain and in the sink.

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

// * The new DAO-based contracts allow forking of spaces into successor spaces. This is so users can create new spaces whose data is derived from another space. This is immediately useful when migrating from legacy spaces to the new DAO-based spaces, but it's generally applicable across any space.

// 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.

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

// * Profiles represent the users of Geo. Profiles are registered in the GeoProfileRegistry contract and are associated with a user's EVM-based address and the space where metadata representing their profile resides in.

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

// 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 value within an enum.

// Describes a method of a service.

// * Proposals represent a proposal to change the state of a DAO-based space. Proposals can represent changes to content, membership (editor or member), governance changes, subspace membership, or anything else that can be executed by a DAO. Currently we use a simple majority voting model, where a proposal requires 51% of the available votes in order to pass. Only editors are allowed to vote on proposals, but editors _and_ members can create them. Proposals require encoding a "callback" that represents the action to be taken if the proposal succeeds. For example, if a proposal is to add a new editor to the space, the callback would be the encoded function call to add the editor to the space. ```ts { to: `0x123...`, // The address of the membership contract data: `0x123...`, // The encoded function call parameters } ```

// `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 message type.

// * This event represents adding editors to a DAO-based space The data model for DAO-based spaces works slightly differently than in legacy spaces. This means there will be a period where we need to support both data models depending on which space/contract we are working with. Eventually these data models will be merged and usage of the legacy space contracts will be migrated to the DAO-based contracts, but for now we are appending "V2" to permissions data models to denote it's used for the DAO-based spaces. An editor has editing and voting permissions in a DAO-based space. Editors join a space one of two ways: 1. They submit a request to join the space as an editor which goes to a vote. The editors in the space vote on whether to accept the new editor. 2. They are added as a set of initial editors when first creating the space. This allows space deployers to bootstrap a set of editors on space creation.

// * Added or Removed Subspaces represent adding a space contracto to the hierarchy of the DAO-based space. This is useful to "link" Spaces together in a tree of spaces, allowing us to curate the graph of their knowledge and permissions.