capture

type Acknowledge struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type ApplyRequest struct {
	// Capture to be applied.
	Capture *flow.CaptureSpec `protobuf:"bytes,1,opt,name=capture,proto3" json:"capture,omitempty"`
	// Version of the CaptureSpec being applied.
	Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
	// Is this Apply a dry-run? If so, no action is undertaken and Apply will
	// report only what would have happened.
	DryRun               bool     `protobuf:"varint,3,opt,name=dry_run,json=dryRun,proto3" json:"dry_run,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type ApplyResponse struct {
	// Human-readable description of the action that the Driver took (or, if
	// dry_run, would have taken). If empty, this Apply is to be considered a
	// "no-op".
	ActionDescription    string   `protobuf:"bytes,1,opt,name=action_description,json=actionDescription,proto3" json:"action_description,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type DiscoverRequest struct {
	// Endpoint type addressed by this request.
	EndpointType flow.EndpointType `protobuf:"varint,1,opt,name=endpoint_type,json=endpointType,proto3,enum=flow.EndpointType" json:"endpoint_type,omitempty"`
	// Driver specification, as an encoded JSON object.
	EndpointSpecJson     encoding_json.RawMessage `` /* 141-byte string literal not displayed */
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

type DiscoverResponse struct {
	Bindings             []*DiscoverResponse_Binding `protobuf:"bytes,1,rep,name=bindings,proto3" json:"bindings,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

type DiscoverResponse_Binding struct {
	// A recommended display name for this discovered binding.
	RecommendedName string `protobuf:"bytes,1,opt,name=recommended_name,json=recommendedName,proto3" json:"recommended_name,omitempty"`
	// JSON-encoded object which specifies the endpoint resource to be captured.
	ResourceSpecJson encoding_json.RawMessage `` /* 141-byte string literal not displayed */
	// JSON schema of documents produced by this binding.
	DocumentSchemaJson encoding_json.RawMessage `` /* 147-byte string literal not displayed */
	// Composite key of documents (if known), as JSON-Pointers.
	KeyPtrs              []string `protobuf:"bytes,4,rep,name=key_ptrs,json=keyPtrs,proto3" json:"key_ptrs,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type Documents struct {
	// The capture binding for documents of this message.
	Binding uint32 `protobuf:"varint,1,opt,name=binding,proto3" json:"binding,omitempty"`
	// Byte arena of the response.
	Arena github_com_estuary_protocols_flow.Arena `protobuf:"bytes,2,opt,name=arena,proto3,casttype=github.com/estuary/protocols/flow.Arena" json:"arena,omitempty"`
	// Captured JSON documents.
	DocsJson             []flow.Slice `protobuf:"bytes,3,rep,name=docs_json,json=docsJson,proto3" json:"docs_json"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

type DriverClient interface {
	// Spec returns the specification definition of this driver.
	// Notably this includes its endpoint and resource configuration JSON schema.
	Spec(ctx context.Context, in *SpecRequest, opts ...grpc.CallOption) (*SpecResponse, error)
	// Discover returns the set of resources available from this Driver.
	Discover(ctx context.Context, in *DiscoverRequest, opts ...grpc.CallOption) (*DiscoverResponse, error)
	// Validate that store resources and proposed collection bindings are
	// compatible.
	Validate(ctx context.Context, in *ValidateRequest, opts ...grpc.CallOption) (*ValidateResponse, error)
	// ApplyUpsert applies a new or updated capture to the store.
	ApplyUpsert(ctx context.Context, in *ApplyRequest, opts ...grpc.CallOption) (*ApplyResponse, error)
	// ApplyDelete deletes an existing capture from the store.
	ApplyDelete(ctx context.Context, in *ApplyRequest, opts ...grpc.CallOption) (*ApplyResponse, error)
	// Pull is a very long lived RPC through which the Flow runtime and a
	// Driver cooperatively execute an unbounded number of transactions.
	//
	// The Pull workflow pulls streams of documents into capturing Flow
	// collections. Streams are incremental and resume-able, with resumption
	// semantics defined by the driver. The Flow Runtime uses a transactional
	// recovery log to support this workflow, and the driver may persist arbitrary
	// driver checkpoints into that log as part of the RPC lifecycle,
	// to power its chosen resumption semantics.
	//
	// Pull tasks are split-able, and many concurrent invocations of the RPC
	// may collectively capture from a source, where each task split has an
	// identified range of keys it's responsible for. The meaning of a "key",
	// and it's application within the remote store being captured from, is up
	// to the driver. The driver might map partitions or shards into the keyspace,
	// and from there to a covering task split. Or, it might map distinct files,
	// or some other unit of scaling.
	//
	// RPC Lifecycle
	// =============
	//
	// :PullRequest.Open:
	//    - The Flow runtime opens the pull stream.
	// :PullResponse.Opened:
	//    - The driver responds with Opened.
	//
	// PullRequest.Open and PullRequest.Opened are sent only once, at the
	// commencement of the stream. Thereafter the protocol loops:
	//
	// :PullResponse.Documents:
	//    - The driver tells the runtime of some documents, which are pending a
	//      future Checkpoint.
	//    - If the driver sends multiple Documents messages without an
	//      interleaving Checkpoint, the Flow runtime MUST commit
	//      documents of all such messages in a single transaction.
	// :PullResponse.Checkpoint:
	//    - The driver tells the runtime of a checkpoint: a watermark in the
	//      captured documents stream which is eligble to be used as a
	//      transaction commit boundary.
	//    - Whether the checkpoint becomes a commit boundary is at the
	//      discretion of the Flow runtime. It may combine multiple checkpoints
	//      into a single transaction.
	// :PullRequest.Acknowledge:
	//    - The Flow runtime tells the driver that its Checkpoint has committed.
	//    - The runtime sends one ordered Acknowledge for each Checkpoint.
	//
	Pull(ctx context.Context, opts ...grpc.CallOption) (Driver_PullClient, error)
}

type DriverServer interface {
	// Spec returns the specification definition of this driver.
	// Notably this includes its endpoint and resource configuration JSON schema.
	Spec(context.Context, *SpecRequest) (*SpecResponse, error)
	// Discover returns the set of resources available from this Driver.
	Discover(context.Context, *DiscoverRequest) (*DiscoverResponse, error)
	// Validate that store resources and proposed collection bindings are
	// compatible.
	Validate(context.Context, *ValidateRequest) (*ValidateResponse, error)
	// ApplyUpsert applies a new or updated capture to the store.
	ApplyUpsert(context.Context, *ApplyRequest) (*ApplyResponse, error)
	// ApplyDelete deletes an existing capture from the store.
	ApplyDelete(context.Context, *ApplyRequest) (*ApplyResponse, error)
	// Pull is a very long lived RPC through which the Flow runtime and a
	// Driver cooperatively execute an unbounded number of transactions.
	//
	// The Pull workflow pulls streams of documents into capturing Flow
	// collections. Streams are incremental and resume-able, with resumption
	// semantics defined by the driver. The Flow Runtime uses a transactional
	// recovery log to support this workflow, and the driver may persist arbitrary
	// driver checkpoints into that log as part of the RPC lifecycle,
	// to power its chosen resumption semantics.
	//
	// Pull tasks are split-able, and many concurrent invocations of the RPC
	// may collectively capture from a source, where each task split has an
	// identified range of keys it's responsible for. The meaning of a "key",
	// and it's application within the remote store being captured from, is up
	// to the driver. The driver might map partitions or shards into the keyspace,
	// and from there to a covering task split. Or, it might map distinct files,
	// or some other unit of scaling.
	//
	// RPC Lifecycle
	// =============
	//
	// :PullRequest.Open:
	//    - The Flow runtime opens the pull stream.
	// :PullResponse.Opened:
	//    - The driver responds with Opened.
	//
	// PullRequest.Open and PullRequest.Opened are sent only once, at the
	// commencement of the stream. Thereafter the protocol loops:
	//
	// :PullResponse.Documents:
	//    - The driver tells the runtime of some documents, which are pending a
	//      future Checkpoint.
	//    - If the driver sends multiple Documents messages without an
	//      interleaving Checkpoint, the Flow runtime MUST commit
	//      documents of all such messages in a single transaction.
	// :PullResponse.Checkpoint:
	//    - The driver tells the runtime of a checkpoint: a watermark in the
	//      captured documents stream which is eligble to be used as a
	//      transaction commit boundary.
	//    - Whether the checkpoint becomes a commit boundary is at the
	//      discretion of the Flow runtime. It may combine multiple checkpoints
	//      into a single transaction.
	// :PullRequest.Acknowledge:
	//    - The Flow runtime tells the driver that its Checkpoint has committed.
	//    - The runtime sends one ordered Acknowledge for each Checkpoint.
	//
	Pull(Driver_PullServer) error
}

type Driver_PullClient interface {
	Send(*PullRequest) error
	Recv() (*PullResponse, error)
	grpc.ClientStream
}

type Driver_PullServer interface {
	Send(*PullResponse) error
	Recv() (*PullRequest, error)
	grpc.ServerStream
}

type PullClient struct {
	// contains filtered or unexported fields
}

type PullRequest struct {
	Open *PullRequest_Open `protobuf:"bytes,1,opt,name=open,proto3" json:"open,omitempty"`
	// Tell the driver that its Checkpoint has committed to the Flow recovery log.
	Acknowledge          *Acknowledge `protobuf:"bytes,2,opt,name=acknowledge,proto3" json:"acknowledge,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

type PullRequest_Open struct {
	// CaptureSpec to be pulled.
	Capture *flow.CaptureSpec `protobuf:"bytes,1,opt,name=capture,proto3" json:"capture,omitempty"`
	// Version of the opened CaptureSpec.
	// The driver may want to require that this match the version last
	// provided to a successful Apply RPC. It's possible that it won't,
	// due to expected propagation races in Flow's distributed runtime.
	Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
	// [key_begin, key_end] inclusive range of keys processed by this
	// transaction stream. Ranges reflect the disjoint chunks of ownership
	// specific to each instance of a scale-out capture implementation.
	KeyBegin uint32 `protobuf:"fixed32,3,opt,name=key_begin,json=keyBegin,proto3" json:"key_begin,omitempty"`
	KeyEnd   uint32 `protobuf:"fixed32,4,opt,name=key_end,json=keyEnd,proto3" json:"key_end,omitempty"`
	// Last-persisted driver checkpoint from a previous capture stream.
	// Or empty, if the driver has cleared or never set its checkpoint.
	DriverCheckpointJson encoding_json.RawMessage `` /* 153-byte string literal not displayed */
	// If true, perform a blocking tail of the capture.
	// If false, produce all ready output and then close the stream.
	Tail                 bool     `protobuf:"varint,6,opt,name=tail,proto3" json:"tail,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type PullResponse struct {
	Opened *PullResponse_Opened `protobuf:"bytes,1,opt,name=opened,proto3" json:"opened,omitempty"`
	// Captured documents of the stream.
	Documents *Documents `protobuf:"bytes,2,opt,name=documents,proto3" json:"documents,omitempty"`
	// Checkpoint all preceeding Documents of this stream.
	Checkpoint           *flow.DriverCheckpoint `protobuf:"bytes,3,opt,name=checkpoint,proto3" json:"checkpoint,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

type PullResponseError struct {
	*PullResponse
	Error error
}

type PullResponse_Opened struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type PushRequest struct {
	Open *PushRequest_Open `protobuf:"bytes,1,opt,name=open,proto3" json:"open,omitempty"`
	// Captured documents of the stream.
	Documents *Documents `protobuf:"bytes,2,opt,name=documents,proto3" json:"documents,omitempty"`
	// Checkpoint all preceeding Documents of this stream.
	Checkpoint           *flow.DriverCheckpoint `protobuf:"bytes,3,opt,name=checkpoint,proto3" json:"checkpoint,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

type PushRequest_Open struct {
	// Header identifies a specific Shard and Route to which this stream is
	// directed. It's optional, and is typically attached by a proxying peer.
	Header *protocol.Header `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	// Name of the capture under which we're pushing.
	Capture              github_com_estuary_protocols_flow.Capture `protobuf:"bytes,2,opt,name=capture,proto3,casttype=github.com/estuary/protocols/flow.Capture" json:"capture,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                  `json:"-"`
	XXX_unrecognized     []byte                                    `json:"-"`
	XXX_sizecache        int32                                     `json:"-"`
}

type PushResponse struct {
	Opened *PushResponse_Opened `protobuf:"bytes,1,opt,name=opened,proto3" json:"opened,omitempty"`
	// Tell the driver that its Checkpoint has committed to the Flow recovery log.
	Acknowledge          *Acknowledge `protobuf:"bytes,2,opt,name=acknowledge,proto3" json:"acknowledge,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

type PushResponse_Opened struct {
	// Status of the Push open.
	Status protocol1.Status `protobuf:"varint,1,opt,name=status,proto3,enum=consumer.Status" json:"status,omitempty"`
	// Header of the response.
	Header protocol.Header `protobuf:"bytes,2,opt,name=header,proto3" json:"header"`
	// CaptureSpec to be pushed.
	Capture *flow.CaptureSpec `protobuf:"bytes,3,opt,name=capture,proto3" json:"capture,omitempty"`
	// Version of the opened CaptureSpec.
	// The driver may want to require that this match the version last
	// provided to a successful Apply RPC. It's possible that it won't,
	// due to expected propagation races in Flow's distributed runtime.
	Version string `protobuf:"bytes,4,opt,name=version,proto3" json:"version,omitempty"`
	// [key_begin, key_end] inclusive range of keys processed by this
	// transaction stream. Ranges reflect the disjoint chunks of ownership
	// specific to each instance of a scale-out capture implementation.
	KeyBegin uint32 `protobuf:"fixed32,5,opt,name=key_begin,json=keyBegin,proto3" json:"key_begin,omitempty"`
	KeyEnd   uint32 `protobuf:"fixed32,6,opt,name=key_end,json=keyEnd,proto3" json:"key_end,omitempty"`
	// Last-persisted driver checkpoint from a previous capture stream.
	// Or empty, if the driver has cleared or never set its checkpoint.
	DriverCheckpointJson encoding_json.RawMessage `` /* 153-byte string literal not displayed */
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

type PushServer struct {
	// contains filtered or unexported fields
}

type RuntimeClient interface {
	// Push may be a short or very long lived RPC through which the Flow runtime
	// and a driver cooperatively execute an unbounded number of transactions.
	//
	// The Push workflow pushes streams of documents into capturing Flow
	// collections. The driver is responsible for initiation and resumption of
	// push streams. The Flow runtime uses a transactional recovery log to support
	// this workflow, and the driver may persist arbitrary driver checkpoints into
	// that log as part of the RPC lifecycle, to power its chosen resumption
	// semantics.
	//
	// A push RPC is evaluated against a specific task shard split, which is
	// encoded in the PushRequest.Open.Header. A driver may perform its own load
	// balancing by obtain a shard listing and embedding a selected shard into
	// that header. Or, it may leave it empty and an arbitary shard will be
	// randomly chosen for it.
	//
	// RPC Lifecycle
	// =============
	//
	// :PushRequest.Open:
	//    - The driver opens the push stream, naming its capture and
	//      optional routing header.
	// :PushResponse.Opened:
	//    - The Flow runtime responds with Opened, which tells the driver
	//      of the specific CaptureSpec and [key_begin, key_end] range of
	//      this RPC, as well as the last driver checkpoint.
	//    - The semantics and treatment of the key range is up to the driver.
	//
	// PushRequest.Open and PushRequest.Opened are sent only once, at the
	// commencement of the stream. Thereafter the protocol loops:
	//
	// :PushRequest.Documents:
	//    - The driver tells the runtime of some documents, which are pending a
	//      future Checkpoint.
	//    - If the driver sends multiple Documents messages without an
	//      interleaving Checkpoint, the Flow runtime MUST commit
	//      documents of all such messages in a single transaction.
	// :PushRequest.Checkpoint:
	//    - The driver tells the runtime of a checkpoint: a watermark in the
	//      captured documents stream which is eligble to be used as a
	//      transaction commit boundary.
	//    - Whether the checkpoint becomes a commit boundary is at the
	//      discretion of the Flow runtime. It may combine multiple checkpoints
	//      into a single transaction.
	// :PushResponse.Acknowledge:
	//    - The Flow runtime tells the driver that its Checkpoint has committed.
	//    - The runtime sends one ordered Acknowledge for each Checkpoint.
	//
	Push(ctx context.Context, opts ...grpc.CallOption) (Runtime_PushClient, error)
}

type RuntimeServer interface {
	// Push may be a short or very long lived RPC through which the Flow runtime
	// and a driver cooperatively execute an unbounded number of transactions.
	//
	// The Push workflow pushes streams of documents into capturing Flow
	// collections. The driver is responsible for initiation and resumption of
	// push streams. The Flow runtime uses a transactional recovery log to support
	// this workflow, and the driver may persist arbitrary driver checkpoints into
	// that log as part of the RPC lifecycle, to power its chosen resumption
	// semantics.
	//
	// A push RPC is evaluated against a specific task shard split, which is
	// encoded in the PushRequest.Open.Header. A driver may perform its own load
	// balancing by obtain a shard listing and embedding a selected shard into
	// that header. Or, it may leave it empty and an arbitary shard will be
	// randomly chosen for it.
	//
	// RPC Lifecycle
	// =============
	//
	// :PushRequest.Open:
	//    - The driver opens the push stream, naming its capture and
	//      optional routing header.
	// :PushResponse.Opened:
	//    - The Flow runtime responds with Opened, which tells the driver
	//      of the specific CaptureSpec and [key_begin, key_end] range of
	//      this RPC, as well as the last driver checkpoint.
	//    - The semantics and treatment of the key range is up to the driver.
	//
	// PushRequest.Open and PushRequest.Opened are sent only once, at the
	// commencement of the stream. Thereafter the protocol loops:
	//
	// :PushRequest.Documents:
	//    - The driver tells the runtime of some documents, which are pending a
	//      future Checkpoint.
	//    - If the driver sends multiple Documents messages without an
	//      interleaving Checkpoint, the Flow runtime MUST commit
	//      documents of all such messages in a single transaction.
	// :PushRequest.Checkpoint:
	//    - The driver tells the runtime of a checkpoint: a watermark in the
	//      captured documents stream which is eligble to be used as a
	//      transaction commit boundary.
	//    - Whether the checkpoint becomes a commit boundary is at the
	//      discretion of the Flow runtime. It may combine multiple checkpoints
	//      into a single transaction.
	// :PushResponse.Acknowledge:
	//    - The Flow runtime tells the driver that its Checkpoint has committed.
	//    - The runtime sends one ordered Acknowledge for each Checkpoint.
	//
	Push(Runtime_PushServer) error
}

type Runtime_PushClient interface {
	Send(*PushRequest) error
	Recv() (*PushResponse, error)
	grpc.ClientStream
}

type Runtime_PushServer interface {
	Send(*PushResponse) error
	Recv() (*PushRequest, error)
	grpc.ServerStream
}

type SpecRequest struct {
	// Endpoint type addressed by this request.
	EndpointType flow.EndpointType `protobuf:"varint,1,opt,name=endpoint_type,json=endpointType,proto3,enum=flow.EndpointType" json:"endpoint_type,omitempty"`
	// Driver specification, as an encoded JSON object.
	// This may be a partial specification (for example, a Docker image),
	// providing only enough information to fetch the remainder of the
	// specification schema.
	EndpointSpecJson     encoding_json.RawMessage `` /* 141-byte string literal not displayed */
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

type SpecResponse struct {
	// JSON schema of an endpoint specification.
	EndpointSpecSchemaJson encoding_json.RawMessage `` /* 161-byte string literal not displayed */
	// JSON schema of a resource specification.
	ResourceSpecSchemaJson encoding_json.RawMessage `` /* 161-byte string literal not displayed */
	// URL for connector's documention.
	DocumentationUrl     string   `protobuf:"bytes,3,opt,name=documentation_url,json=documentationUrl,proto3" json:"documentation_url,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type UnimplementedDriverServer struct {
}

type UnimplementedRuntimeServer struct {
}

type ValidateRequest struct {
	// Name of the capture being validated.
	Capture github_com_estuary_protocols_flow.Capture `protobuf:"bytes,1,opt,name=capture,proto3,casttype=github.com/estuary/protocols/flow.Capture" json:"capture,omitempty"`
	// Endpoint type addressed by this request.
	EndpointType flow.EndpointType `protobuf:"varint,2,opt,name=endpoint_type,json=endpointType,proto3,enum=flow.EndpointType" json:"endpoint_type,omitempty"`
	// Driver specification, as an encoded JSON object.
	EndpointSpecJson     encoding_json.RawMessage   `` /* 141-byte string literal not displayed */
	Bindings             []*ValidateRequest_Binding `protobuf:"bytes,4,rep,name=bindings,proto3" json:"bindings,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

type ValidateRequest_Binding struct {
	// JSON-encoded object which specifies the endpoint resource to be captured.
	ResourceSpecJson encoding_json.RawMessage `` /* 141-byte string literal not displayed */
	// Collection to be captured.
	Collection           flow.CollectionSpec `protobuf:"bytes,2,opt,name=collection,proto3" json:"collection"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

type ValidateResponse struct {
	Bindings             []*ValidateResponse_Binding `protobuf:"bytes,1,rep,name=bindings,proto3" json:"bindings,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

type ValidateResponse_Binding struct {
	// Components of the resource path which fully qualify the resource
	// identified by this binding.
	// - For an RDBMS, this might be []{dbname, schema, table}.
	// - For Kafka, this might be []{topic}.
	// - For Redis, this might be []{key_prefix}.
	ResourcePath         []string `protobuf:"bytes,1,rep,name=resource_path,json=resourcePath,proto3" json:"resource_path,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}