data

type AppendItem struct {

	// item_type is the type of item to be appended. All items must have a type.
	ItemType string `protobuf:"bytes,1,opt,name=item_type,json=itemType,proto3" json:"item_type,omitempty"`
	// id_assignment chooses how the item's ID will be assigned. Not all options
	// are applicable for all types of items or store configurations.
	IdAssignment AppendItem_IDAssignment `` /* 135-byte string literal not displayed */
	// json is a proto-encoded JSON object, to support storing JSON documents, or
	// to support storing the remainder of data that cannot be represented as
	// proto.
	// TODO: We may want to replace this with something a bit more powerful such
	// as BSON - still a map of string key to value, but with a larger vocabulary
	// of value types.
	Json *structpb.Struct `protobuf:"bytes,3,opt,name=json,proto3" json:"json,omitempty"`
	// proto is an arbitrary binary proto message, following the schema for this
	// item type (TBD). It is entirely possible for an item to store both proto
	// data AND json data - for example, if only a subset of its data has a
	// defined proto schema that informs its representation. We don't use the Any
	// type here because it is both inefficient (it encodes the entire type name
	// as a string), but also we should know via external schema what type of
	// proto this is.
	Proto []byte `protobuf:"bytes,4,opt,name=proto,proto3" json:"proto,omitempty"`
	// contains filtered or unexported fields
}

type AppendItemResult struct {

	// key_path is the full path to the newly appended item, if it was able to be
	// saved. See Item#key_path for more details.
	KeyPath string `protobuf:"bytes,1,opt,name=key_path,json=keyPath,proto3" json:"key_path,omitempty"`
	// error is the error that occurred while appending this item, if any.
	// error is not set if the item was successfully saved.
	Error *common.OperationError `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	// metadata is the version and timestamp metadata for the item that was appended.
	Metadata *ItemMetadata `protobuf:"bytes,3,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// contains filtered or unexported fields
}

type AppendItem_IDAssignment int32

type AppendRequest struct {

	// store_id is a globally unique Store ID, which can be looked up from the
	// console or CLI.
	StoreId uint64 `protobuf:"varint,1,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"`
	// parent_path is the full path, in the form
	// /item_type-item_id/[{sub_item_type}-{sub_item_id}...}], under which each
	// item will be appended. The item will be appended as a direct child of this
	// path. Note that the path *may* be "/" to create root-level items, though
	// some ID assignment options may not be available in that case.
	ParentPath string `protobuf:"bytes,2,opt,name=parent_path,json=parentPath,proto3" json:"parent_path,omitempty"`
	// appends is one or more items to be appended under the parent path.
	Appends []*AppendItem `protobuf:"bytes,3,rep,name=appends,proto3" json:"appends,omitempty"`
	// atomic indicates that all appends must succeed or none will (i.e. that they
	// are applied in a transaction), and that other operations will be serialized
	// ahead or behind this operation. Some store configurations may ignore this
	// option and will always apply the whole batch in a transaction (such as in
	// version-tracking stores). Note that this has no effect if there is only one
	// append. Enabling this option increases cost and latency, and may result in
	// the operation failing if it conflicts with another atomic operation. Also,
	// some ID assignment options may not be available depending on this option -
	// e.g. you cannot do SEQUENTIAL appends with atomic = false.
	Atomic bool `protobuf:"varint,4,opt,name=atomic,proto3" json:"atomic,omitempty"`
	// contains filtered or unexported fields
}

type AppendResponse struct {

	// results are in the same order as the appends in the request, one per append.
	Results []*AppendItemResult `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"`
	// contains filtered or unexported fields
}

type BeginListRequest struct {

	// store_id is a globally unique Store ID, which can be looked up from the
	// console or CLI.
	StoreId uint64 `protobuf:"varint,1,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"`
	// key_path_prefix is the a prefix that limits what items we will return. This
	// must contain at least a root segment. See Item#key_path for more details.
	KeyPathPrefix string `protobuf:"bytes,2,opt,name=key_path_prefix,json=keyPathPrefix,proto3" json:"key_path_prefix,omitempty"`
	// limit is the maximum number of items to return. If this is not specified or
	// set to 0, it will default to unlimited. Fewer items than the limit may be
	// returned even if there are more items to get - make sure to check
	// token.can_continue.
	Limit uint32 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"`
	// allow_stale indicates that you're okay with getting slightly stale items -
	// that is, if you had just changed an item and then call a List operation,
	// you might get the old version of the item. This can result in improved
	// performance, availability, and cost.
	AllowStale bool `protobuf:"varint,4,opt,name=allow_stale,json=allowStale,proto3" json:"allow_stale,omitempty"`
	// sort_property is the property of the item to sort the results by. If this
	// is not set, we will sort by key path.
	SortProperty SortableProperty `` /* 128-byte string literal not displayed */
	// sort_direction is the direction to sort the results in. If this is not set,
	// we will sort in ascending order.
	SortDirection SortDirection `` /* 128-byte string literal not displayed */
	// contains filtered or unexported fields
}

type ContinueListDirection int32

type ContinueListRequest struct {

	// token_data is an opaque list continuation token returned by a previous call to
	// BeginList, ContinueList, or SyncList.
	TokenData []byte `protobuf:"bytes,1,opt,name=token_data,json=tokenData,proto3" json:"token_data,omitempty"`
	// direction indicates whether we are expanding the result set (paginating)
	// forward (in the direction of the original List operation) or backward (in
	// the opposite direction). The default is to expand forward.
	Direction ContinueListDirection `protobuf:"varint,2,opt,name=direction,proto3,enum=stately.ContinueListDirection" json:"direction,omitempty"`
	// contains filtered or unexported fields
}

type DeleteItem struct {

	// key_path is the full path to the item. See Item#key_path for more details.
	KeyPath string `protobuf:"bytes,1,opt,name=key_path,json=keyPath,proto3" json:"key_path,omitempty"`
	// contains filtered or unexported fields
}

type DeleteRequest struct {

	// store_id is a globally unique Store ID, which can be looked up from the
	// console or CLI.
	StoreId uint64 `protobuf:"varint,1,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"`
	// deletes is one or more items to be deleted from the Group.
	Deletes []*DeleteItem `protobuf:"bytes,3,rep,name=deletes,proto3" json:"deletes,omitempty"`
	// atomic indicates that all deletes must succeed or none will (i.e. that they
	// are applied in a transaction), and that other operations will be serialized
	// ahead or behind this operation. Some store configurations may ignore this
	// option and will always apply the whole batch in a transaction (such as in
	// version-tracking stores). Note that this has no effect if there is only one
	// delete. Enabling this option increases cost and latency, and may result in
	// the operation failing if it conflicts with another atomic operation.
	Atomic bool `protobuf:"varint,4,opt,name=atomic,proto3" json:"atomic,omitempty"`
	// contains filtered or unexported fields
}

type DeleteResponse struct {

	// results is the result of each delete operation, whether it succeeded or failed.
	Results []*DeleteResult `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"`
	// contains filtered or unexported fields
}

type DeleteResult struct {

	// The key_path of the item that was deleted.
	KeyPath string `protobuf:"bytes,1,opt,name=key_path,json=keyPath,proto3" json:"key_path,omitempty"`
	// error is the error that occurred while deleting this item, if any. error is
	// not set if the item was successfully deleted (or didn't exist in the first
	// place).
	Error *common.OperationError `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	// contains filtered or unexported fields
}

type DeletedItem struct {

	// Since the item was deleted, only the key is provided.
	KeyPath string `protobuf:"bytes,1,opt,name=key_path,json=keyPath,proto3" json:"key_path,omitempty"`
	// contains filtered or unexported fields
}

type GetItem struct {

	// key_path is the full path to the item. See Item#key_path for more details.
	KeyPath string `protobuf:"bytes,1,opt,name=key_path,json=keyPath,proto3" json:"key_path,omitempty"`
	// contains filtered or unexported fields
}

type GetRequest struct {

	// store_id is a globally unique Store ID, which can be looked up from the
	// console or CLI.
	StoreId uint64 `protobuf:"varint,1,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"`
	// gets is one or more requests to get an item its key path.
	Gets []*GetItem `protobuf:"bytes,2,rep,name=gets,proto3" json:"gets,omitempty"`
	// allow_stale indicates that you're okay with getting a slightly stale item -
	// that is, if you had just changed an item and then call GetItem, you might
	// get the old version of the item. This can result in improved performance,
	// availability, and cost.
	AllowStale bool `protobuf:"varint,3,opt,name=allow_stale,json=allowStale,proto3" json:"allow_stale,omitempty"`
	// Atomic indicates that all gets in this request should be executed
	// atomically relative to other requests - that is, it will retrieve the items
	// as they were at the same point in time. If this is false (the default),
	// then each get will be executed independently, meaning each get may be
	// interleaved with modifications by other requests. See
	// https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transaction-apis.html#transaction-isolation
	// for an example of why you'd want to use this. Note that this has no effect
	// if there is only one get. Also, allow_stale may not be true if atomic is
	// true. Enabling this option increases cost and latency, and may result in
	// the operation failing if it conflicts with another atomic operation.
	Atomic bool `protobuf:"varint,4,opt,name=atomic,proto3" json:"atomic,omitempty"`
	// contains filtered or unexported fields
}

type GetResponse struct {

	// results is a list that contains one entry for each Item that was found.
	Items []*Item `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	// contains filtered or unexported fields
}

type IsTransactionCommand = isTransactionRequest_Command

type IsTransactionResponseResult = isTransactionResponse_Result

type Item struct {

	// key_path is the full path to this item, in the form
	// /item_type-item_id/[{sub_item_type}-{sub_item_id}...}]. It must contain at
	// least one segment with item type and ID, as the first segment identifies a
	// "root path" that forms the partition key for data.
	//
	// For example, to store information about Jedi, you might have /jedi-luke, or
	// to have a sub-item of that item, you could use the path
	// /jedi-luke/equipment-lightsaber. The "type" of this item is the last item
	// type in the path, and the last ID is optional if this is a singleton item.
	KeyPath string `protobuf:"bytes,1,opt,name=key_path,json=keyPath,proto3" json:"key_path,omitempty"`
	// json is a proto-encoded JSON object, to support storing JSON documents, or
	// to support storing the remainder of data that cannot be represented as
	// proto.
	// TODO: We may want to replace this with something a bit more powerful such
	// as BSON - still a map of string key to value, but with a larger vocabulary
	// of value types.
	Json *structpb.Struct `protobuf:"bytes,2,opt,name=json,proto3" json:"json,omitempty"`
	// proto is an arbitrary binary proto message, following the schema for this
	// item type (TBD). It is entirely possible for an item to store both proto
	// data AND json data - for example, if only a subset of its data has a
	// defined proto schema that informs its representation. We don't use the Any
	// type here because it is both inefficient (it encodes the entire type name
	// as a string), but also we should know via external schema what type of
	// proto this is.
	Proto []byte `protobuf:"bytes,3,opt,name=proto,proto3" json:"proto,omitempty"`
	// metadata is extra metadata about this item, such as its version numbers and
	// timestamps. This must not be present when the item is being used in
	// PutItem, but will be populated when items are returned from the service.
	Metadata *ItemMetadata `protobuf:"bytes,6,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// contains filtered or unexported fields
}

type ItemMetadata struct {

	// created_at_micros is the time at which this item was created, as a Unix
	// microsecond timestamp.
	CreatedAtMicros uint64 `protobuf:"varint,1,opt,name=created_at_micros,json=createdAtMicros,proto3" json:"created_at_micros,omitempty"`
	// last_modified_at_micros is the time at which this item was last modified,
	// as a Unix microsecond timestamp.
	LastModifiedAtMicros uint64 `` /* 126-byte string literal not displayed */
	// created_at_version is the group version of the item at the time it was
	// created. This is only populated in stores that are configured to track
	// versions.
	CreatedAtVersion uint64 `protobuf:"varint,3,opt,name=created_at_version,json=createdAtVersion,proto3" json:"created_at_version,omitempty"`
	// last_modified_at_version is the group version of the item when it was last
	// modified. This is only populated in stores that are configured to track
	// versions.
	LastModifiedAtVersion uint64 `` /* 129-byte string literal not displayed */
	// contains filtered or unexported fields
}

type ListFinished struct {

	// token is always set and represents an updated list continuation token that
	// can be used in subsequent calls to ContinueList or SyncList.
	Token *ListToken `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	// contains filtered or unexported fields
}

type ListPartialResult struct {

	// results is a list that contains one entry for each Item that was found.
	Items []*Item `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	// contains filtered or unexported fields
}

type ListResponder interface {
	IsListResponder()
}

type ListResponse struct {

	// Types that are assignable to Response:
	//
	//	*ListResponse_Result
	//	*ListResponse_Finished
	Response isListResponse_Response `protobuf_oneof:"response"`
	// contains filtered or unexported fields
}

type ListResponse_Finished struct {
	// Finished is sent when there are no more results in this operation, and
	// there will only be one.
	Finished *ListFinished `protobuf:"bytes,2,opt,name=finished,proto3,oneof"`
}

type ListResponse_Result struct {
	// Result is a segment of the result set - multiple of these may be returned
	// in a stream before the final "finished" message.
	Result *ListPartialResult `protobuf:"bytes,1,opt,name=result,proto3,oneof"`
}

type ListToken struct {

	// token_data will always be returned, and can be used to expand the result
	// set via ContinueList (if can_continue is true), or to get changed items
	// within the result set via SyncList (if can_sync is true). The token_data
	// itself is opaque and cannot be parsed or modified by clients.
	TokenData []byte `protobuf:"bytes,1,opt,name=token_data,json=tokenData,proto3" json:"token_data,omitempty"`
	// can_continue indicates that there are more results available by expanding
	// the pagination window by calling ContinueList with this token.
	CanContinue bool `protobuf:"varint,2,opt,name=can_continue,json=canContinue,proto3" json:"can_continue,omitempty"`
	// can_sync indicates that you could call SyncList with this token later to
	// get updated items. This is determined by the type of store you're listing
	// from.
	CanSync bool `protobuf:"varint,3,opt,name=can_sync,json=canSync,proto3" json:"can_sync,omitempty"`
	// contains filtered or unexported fields
}

type PutItem struct {

	// Item is the full item to be put, including its key_path.
	Item *Item `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

type PutRequest struct {

	// store_id is a globally unique Store ID, which can be looked up from the
	// console or CLI.
	StoreId uint64 `protobuf:"varint,1,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"`
	// puts is one or more items to be put into the Store.
	Puts []*PutItem `protobuf:"bytes,2,rep,name=puts,proto3" json:"puts,omitempty"`
	// atomic indicates that all puts must succeed or none will (i.e. that they
	// are applied in a transaction), and that other operations will be serialized
	// ahead or behind this operation. Some store configurations may ignore this
	// option and will always apply the whole batch in a transaction (such as in
	// version-tracking stores). Note that this has no effect if there is only one
	// put. Enabling this option increases cost and latency, and may result in the
	// operation failing if it conflicts with another atomic operation.
	Atomic bool `protobuf:"varint,3,opt,name=atomic,proto3" json:"atomic,omitempty"`
	// contains filtered or unexported fields
}

type PutResponse struct {

	// results is the result of each put operation (whether it succeeded or failed).
	Results []*PutResult `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"`
	// contains filtered or unexported fields
}

type PutResult struct {

	// The key_path of the item that was put.
	KeyPath string `protobuf:"bytes,1,opt,name=key_path,json=keyPath,proto3" json:"key_path,omitempty"`
	// error is the error that occurred while putting this item, if any.
	// error is not set if the item was successfully put.
	Error *common.OperationError `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	// metadata is the version and timestamp metadata for the item that was put.
	Metadata *ItemMetadata `protobuf:"bytes,3,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// contains filtered or unexported fields
}

type ScanRootPathResult struct {

	// key_path is a single root key path. Users can Query by this root path to
	// get all of the items under it.
	KeyPath string `protobuf:"bytes,1,opt,name=key_path,json=keyPath,proto3" json:"key_path,omitempty"`
	// contains filtered or unexported fields
}

type ScanRootPathsRequest struct {

	// store_id is a globally unique Store ID, which can be looked up from the
	// console or CLI.
	StoreId uint64 `protobuf:"varint,1,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"`
	// Limit sets an upper bound on how many root paths to return.
	Limit uint32 `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"`
	// pagination_token is an optional token to continue retrieving the next page of results.
	// This value must be read from a ScanRootPathsResponse and passed with a clone of the
	// previous request to fetch the next page of data
	PaginationToken []byte `protobuf:"bytes,3,opt,name=pagination_token,json=paginationToken,proto3" json:"pagination_token,omitempty"`
	// contains filtered or unexported fields
}

type ScanRootPathsResponse struct {

	// results is a list that contains one entry for each root path that was found.
	Results []*ScanRootPathResult `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"`
	// This field is optional and will be set if there are more query results to fetch.
	// To fetch the next page of results you must make the exact same ScanRootPathsRequest as before
	// but set ScanRootPathsRequest.pagination_token to the value returned here.
	PaginationToken []byte `protobuf:"bytes,2,opt,name=pagination_token,json=paginationToken,proto3" json:"pagination_token,omitempty"`
	// contains filtered or unexported fields
}