pb

type BreakingChange struct {
	Type        BreakingChangeType `protobuf:"varint,1,opt,name=type,proto3,enum=cvt.BreakingChangeType" json:"type,omitempty"`
	Path        string             `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`                         // API path affected (e.g., "/users/{id}")
	Method      string             `protobuf:"bytes,3,opt,name=method,proto3" json:"method,omitempty"`                     // HTTP method affected (e.g., "POST")
	Description string             `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"`           // Human-readable description
	OldValue    string             `protobuf:"bytes,5,opt,name=old_value,json=oldValue,proto3" json:"old_value,omitempty"` // Previous value (for context)
	NewValue    string             `protobuf:"bytes,6,opt,name=new_value,json=newValue,proto3" json:"new_value,omitempty"` // New value (for context)
	// contains filtered or unexported fields
}

type BreakingChangeType int32

type CanIDeployRequest struct {
	SchemaId    string `protobuf:"bytes,1,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"`       // Schema to deploy
	NewVersion  string `protobuf:"bytes,2,opt,name=new_version,json=newVersion,proto3" json:"new_version,omitempty"` // New version to deploy
	Environment string `protobuf:"bytes,3,opt,name=environment,proto3" json:"environment,omitempty"`                 // Target environment (dev, staging, prod)
	// contains filtered or unexported fields
}

type CanIDeployResponse struct {
	SafeToDeploy      bool              `protobuf:"varint,1,opt,name=safe_to_deploy,json=safeToDeploy,proto3" json:"safe_to_deploy,omitempty"`             // True if safe to deploy
	Summary           string            `protobuf:"bytes,2,opt,name=summary,proto3" json:"summary,omitempty"`                                              // Human-readable summary
	BreakingChanges   []*BreakingChange `protobuf:"bytes,3,rep,name=breaking_changes,json=breakingChanges,proto3" json:"breaking_changes,omitempty"`       // All breaking changes in new version
	AffectedConsumers []*ConsumerImpact `protobuf:"bytes,4,rep,name=affected_consumers,json=affectedConsumers,proto3" json:"affected_consumers,omitempty"` // Impact on each consumer
	// contains filtered or unexported fields
}

type CompareSchemasRequest struct {
	SchemaId   string `protobuf:"bytes,1,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"`
	OldVersion string `protobuf:"bytes,2,opt,name=old_version,json=oldVersion,proto3" json:"old_version,omitempty"` // Version to compare from (empty = previous)
	NewVersion string `protobuf:"bytes,3,opt,name=new_version,json=newVersion,proto3" json:"new_version,omitempty"` // Version to compare to (empty = latest)
	// contains filtered or unexported fields
}

type CompareSchemasResponse struct {
	Compatible      bool              `protobuf:"varint,1,opt,name=compatible,proto3" json:"compatible,omitempty"` // True if no breaking changes
	BreakingChanges []*BreakingChange `protobuf:"bytes,2,rep,name=breaking_changes,json=breakingChanges,proto3" json:"breaking_changes,omitempty"`
	OldSchema       *SchemaMetadata   `protobuf:"bytes,3,opt,name=old_schema,json=oldSchema,proto3" json:"old_schema,omitempty"`
	NewSchema       *SchemaMetadata   `protobuf:"bytes,4,opt,name=new_schema,json=newSchema,proto3" json:"new_schema,omitempty"`
	// contains filtered or unexported fields
}

type ConsumerImpact struct {
	ConsumerId           string            `protobuf:"bytes,1,opt,name=consumer_id,json=consumerId,proto3" json:"consumer_id,omitempty"`
	ConsumerVersion      string            `protobuf:"bytes,2,opt,name=consumer_version,json=consumerVersion,proto3" json:"consumer_version,omitempty"`
	CurrentSchemaVersion string            `protobuf:"bytes,3,opt,name=current_schema_version,json=currentSchemaVersion,proto3" json:"current_schema_version,omitempty"` // Version consumer was tested against
	Environment          string            `protobuf:"bytes,4,opt,name=environment,proto3" json:"environment,omitempty"`
	WillBreak            bool              `protobuf:"varint,5,opt,name=will_break,json=willBreak,proto3" json:"will_break,omitempty"`                  // True if consumer will be affected
	RelevantChanges      []*BreakingChange `protobuf:"bytes,6,rep,name=relevant_changes,json=relevantChanges,proto3" json:"relevant_changes,omitempty"` // Breaking changes affecting this consumer
	// contains filtered or unexported fields
}

type ConsumerInfo struct {
	ConsumerId      string           `protobuf:"bytes,1,opt,name=consumer_id,json=consumerId,proto3" json:"consumer_id,omitempty"`                   // Unique consumer identifier (e.g., "order-service")
	ConsumerVersion string           `protobuf:"bytes,2,opt,name=consumer_version,json=consumerVersion,proto3" json:"consumer_version,omitempty"`    // Consumer's version (e.g., "2.1.0")
	SchemaId        string           `protobuf:"bytes,3,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"`                         // Schema this consumer depends on
	SchemaVersion   string           `protobuf:"bytes,4,opt,name=schema_version,json=schemaVersion,proto3" json:"schema_version,omitempty"`          // Schema version consumer was tested against
	Environment     string           `protobuf:"bytes,5,opt,name=environment,proto3" json:"environment,omitempty"`                                   // Environment (dev, staging, prod)
	RegisteredAt    int64            `protobuf:"varint,6,opt,name=registered_at,json=registeredAt,proto3" json:"registered_at,omitempty"`            // Unix timestamp of registration
	LastValidatedAt int64            `protobuf:"varint,7,opt,name=last_validated_at,json=lastValidatedAt,proto3" json:"last_validated_at,omitempty"` // Unix timestamp of last successful validation
	UsedEndpoints   []*EndpointUsage `protobuf:"bytes,8,rep,name=used_endpoints,json=usedEndpoints,proto3" json:"used_endpoints,omitempty"`          // Which endpoints the consumer uses
	// contains filtered or unexported fields
}

type ContractValidatorClient interface {
	// Registers an OpenAPI schema for future validation
	RegisterSchema(ctx context.Context, in *RegisterSchemaRequest, opts ...grpc.CallOption) (*RegisterSchemaResponse, error)
	// Validates a single request/response interaction against a registered schema
	ValidateInteraction(ctx context.Context, in *InteractionRequest, opts ...grpc.CallOption) (*ValidationResult, error)
	// Gets metadata for a registered schema
	GetSchema(ctx context.Context, in *GetSchemaRequest, opts ...grpc.CallOption) (*GetSchemaResponse, error)
	// Lists all registered schemas
	ListSchemas(ctx context.Context, in *ListSchemasRequest, opts ...grpc.CallOption) (*ListSchemasResponse, error)
	// Compares two schema versions for breaking changes
	CompareSchemas(ctx context.Context, in *CompareSchemasRequest, opts ...grpc.CallOption) (*CompareSchemasResponse, error)
	// Generates test fixtures from an OpenAPI schema
	GenerateFixture(ctx context.Context, in *GenerateFixtureRequest, opts ...grpc.CallOption) (*GenerateFixtureResponse, error)
	// Lists all endpoints available in a schema
	ListEndpoints(ctx context.Context, in *ListEndpointsRequest, opts ...grpc.CallOption) (*ListEndpointsResponse, error)
	// Validates a producer's response against its OpenAPI schema (for producer contract tests)
	ValidateProducerResponse(ctx context.Context, in *ValidateProducerRequest, opts ...grpc.CallOption) (*ValidationResult, error)
	// Registers a consumer's dependency on a schema
	RegisterConsumer(ctx context.Context, in *RegisterConsumerRequest, opts ...grpc.CallOption) (*RegisterConsumerResponse, error)
	// Lists all consumers that depend on a schema
	ListConsumers(ctx context.Context, in *ListConsumersRequest, opts ...grpc.CallOption) (*ListConsumersResponse, error)
	// Removes a consumer registration
	DeregisterConsumer(ctx context.Context, in *DeregisterConsumerRequest, opts ...grpc.CallOption) (*DeregisterConsumerResponse, error)
	// Checks if a schema version can be safely deployed
	CanIDeploy(ctx context.Context, in *CanIDeployRequest, opts ...grpc.CallOption) (*CanIDeployResponse, error)
}

type ContractValidatorServer interface {
	// Registers an OpenAPI schema for future validation
	RegisterSchema(context.Context, *RegisterSchemaRequest) (*RegisterSchemaResponse, error)
	// Validates a single request/response interaction against a registered schema
	ValidateInteraction(context.Context, *InteractionRequest) (*ValidationResult, error)
	// Gets metadata for a registered schema
	GetSchema(context.Context, *GetSchemaRequest) (*GetSchemaResponse, error)
	// Lists all registered schemas
	ListSchemas(context.Context, *ListSchemasRequest) (*ListSchemasResponse, error)
	// Compares two schema versions for breaking changes
	CompareSchemas(context.Context, *CompareSchemasRequest) (*CompareSchemasResponse, error)
	// Generates test fixtures from an OpenAPI schema
	GenerateFixture(context.Context, *GenerateFixtureRequest) (*GenerateFixtureResponse, error)
	// Lists all endpoints available in a schema
	ListEndpoints(context.Context, *ListEndpointsRequest) (*ListEndpointsResponse, error)
	// Validates a producer's response against its OpenAPI schema (for producer contract tests)
	ValidateProducerResponse(context.Context, *ValidateProducerRequest) (*ValidationResult, error)
	// Registers a consumer's dependency on a schema
	RegisterConsumer(context.Context, *RegisterConsumerRequest) (*RegisterConsumerResponse, error)
	// Lists all consumers that depend on a schema
	ListConsumers(context.Context, *ListConsumersRequest) (*ListConsumersResponse, error)
	// Removes a consumer registration
	DeregisterConsumer(context.Context, *DeregisterConsumerRequest) (*DeregisterConsumerResponse, error)
	// Checks if a schema version can be safely deployed
	CanIDeploy(context.Context, *CanIDeployRequest) (*CanIDeployResponse, error)
	// contains filtered or unexported methods
}

type DeregisterConsumerRequest struct {
	ConsumerId  string `protobuf:"bytes,1,opt,name=consumer_id,json=consumerId,proto3" json:"consumer_id,omitempty"`
	SchemaId    string `protobuf:"bytes,2,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"` // Required: which schema dependency to remove
	Environment string `protobuf:"bytes,3,opt,name=environment,proto3" json:"environment,omitempty"`
	// contains filtered or unexported fields
}

type DeregisterConsumerResponse struct {
	Success bool   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	// contains filtered or unexported fields
}

type EndpointInfo struct {
	Method      string `protobuf:"bytes,1,opt,name=method,proto3" json:"method,omitempty"`                              // HTTP method
	Path        string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`                                  // API path
	OperationId string `protobuf:"bytes,3,opt,name=operation_id,json=operationId,proto3" json:"operation_id,omitempty"` // OpenAPI operationId (if defined)
	Summary     string `protobuf:"bytes,4,opt,name=summary,proto3" json:"summary,omitempty"`                            // OpenAPI summary (if defined)
	// contains filtered or unexported fields
}

type EndpointUsage struct {
	Method     string   `protobuf:"bytes,1,opt,name=method,proto3" json:"method,omitempty"`                           // HTTP method
	Path       string   `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`                               // API path
	UsedFields []string `protobuf:"bytes,3,rep,name=used_fields,json=usedFields,proto3" json:"used_fields,omitempty"` // Fields used in response (e.g., ["email", "name"])
	// contains filtered or unexported fields
}

type GenerateFixtureRequest struct {
	SchemaId    string     `protobuf:"bytes,1,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"`                            // Schema to generate fixtures from
	Method      string     `protobuf:"bytes,2,opt,name=method,proto3" json:"method,omitempty"`                                                // HTTP method (GET, POST, etc.)
	Path        string     `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"`                                                    // API path (e.g., /users/{id})
	StatusCode  int32      `protobuf:"varint,4,opt,name=status_code,json=statusCode,proto3" json:"status_code,omitempty"`                     // Response status code (0 = auto-select)
	UseExamples bool       `protobuf:"varint,5,opt,name=use_examples,json=useExamples,proto3" json:"use_examples,omitempty"`                  // Use schema examples when available
	ContentType string     `protobuf:"bytes,6,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"`                   // Content type (default: application/json)
	OutputType  OutputType `protobuf:"varint,7,opt,name=output_type,json=outputType,proto3,enum=cvt.OutputType" json:"output_type,omitempty"` // What to generate
	// contains filtered or unexported fields
}

type GenerateFixtureResponse struct {
	Success     bool               `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	Message     string             `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	Fixture     *GeneratedFixture  `protobuf:"bytes,3,opt,name=fixture,proto3" json:"fixture,omitempty"`                            // Full fixture (if output_type = FIXTURE)
	RequestBody string             `protobuf:"bytes,4,opt,name=request_body,json=requestBody,proto3" json:"request_body,omitempty"` // Request body JSON (if output_type = REQUEST)
	Response    *GeneratedResponse `protobuf:"bytes,5,opt,name=response,proto3" json:"response,omitempty"`                          // Response (if output_type = RESPONSE)
	// contains filtered or unexported fields
}

type GeneratedFixture struct {
	Request  *GeneratedRequest  `protobuf:"bytes,1,opt,name=request,proto3" json:"request,omitempty"`
	Response *GeneratedResponse `protobuf:"bytes,2,opt,name=response,proto3" json:"response,omitempty"`
	// contains filtered or unexported fields
}

type GeneratedRequest struct {
	Method  string            `protobuf:"bytes,1,opt,name=method,proto3" json:"method,omitempty"`
	Path    string            `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	Headers map[string]string ``                                                              /* 141-byte string literal not displayed */
	Body    string            `protobuf:"bytes,4,opt,name=body,proto3" json:"body,omitempty"` // JSON body as string
	// contains filtered or unexported fields
}

type GeneratedResponse struct {
	StatusCode int32             `protobuf:"varint,1,opt,name=status_code,json=statusCode,proto3" json:"status_code,omitempty"`
	Headers    map[string]string ``                                                              /* 141-byte string literal not displayed */
	Body       string            `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"` // JSON body as string
	// contains filtered or unexported fields
}

type GetSchemaRequest struct {
	SchemaId      string `protobuf:"bytes,1,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"`
	SchemaVersion string `protobuf:"bytes,2,opt,name=schema_version,json=schemaVersion,proto3" json:"schema_version,omitempty"` // Optional: specific version (empty = latest)
	// contains filtered or unexported fields
}

type GetSchemaResponse struct {
	Found         bool            `protobuf:"varint,1,opt,name=found,proto3" json:"found,omitempty"`
	Metadata      *SchemaMetadata `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"`
	SchemaContent string          `protobuf:"bytes,3,opt,name=schema_content,json=schemaContent,proto3" json:"schema_content,omitempty"` // The actual schema content
	// contains filtered or unexported fields
}

type InteractionRequest struct {
	SchemaId      string        `protobuf:"bytes,1,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"`
	Request       *RequestData  `protobuf:"bytes,2,opt,name=request,proto3" json:"request,omitempty"`
	Response      *ResponseData `protobuf:"bytes,3,opt,name=response,proto3" json:"response,omitempty"`
	SchemaVersion string        `protobuf:"bytes,4,opt,name=schema_version,json=schemaVersion,proto3" json:"schema_version,omitempty"` // Optional: validate against specific version
	// contains filtered or unexported fields
}

type ListConsumersRequest struct {
	SchemaId    string `protobuf:"bytes,1,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"` // Required: schema to query
	Environment string `protobuf:"bytes,2,opt,name=environment,proto3" json:"environment,omitempty"`           // Optional: filter by environment
	// contains filtered or unexported fields
}

type ListConsumersResponse struct {
	Consumers []*ConsumerInfo `protobuf:"bytes,1,rep,name=consumers,proto3" json:"consumers,omitempty"`
	// contains filtered or unexported fields
}

type ListEndpointsRequest struct {
	SchemaId string `protobuf:"bytes,1,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"`
	// contains filtered or unexported fields
}

type ListEndpointsResponse struct {
	Endpoints []*EndpointInfo `protobuf:"bytes,1,rep,name=endpoints,proto3" json:"endpoints,omitempty"`
	// contains filtered or unexported fields
}

type ListSchemasRequest struct {
	PageSize  int32  `protobuf:"varint,1,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`   // Max results per page (default 100)
	PageToken string `protobuf:"bytes,2,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"` // Token for pagination
	Owner     string `protobuf:"bytes,3,opt,name=owner,proto3" json:"owner,omitempty"`                          // Optional: filter by owner
	Team      string `protobuf:"bytes,4,opt,name=team,proto3" json:"team,omitempty"`                            // Optional: filter by team
	// contains filtered or unexported fields
}

type ListSchemasResponse struct {
	Schemas       []*SchemaMetadata `protobuf:"bytes,1,rep,name=schemas,proto3" json:"schemas,omitempty"`
	NextPageToken string            `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"` // Token for next page (empty if no more)
	TotalCount    int32             `protobuf:"varint,3,opt,name=total_count,json=totalCount,proto3" json:"total_count,omitempty"`           // Total number of schemas matching filter
	// contains filtered or unexported fields
}

type OutputType int32

type RegisterConsumerRequest struct {
	ConsumerId      string           `protobuf:"bytes,1,opt,name=consumer_id,json=consumerId,proto3" json:"consumer_id,omitempty"`
	ConsumerVersion string           `protobuf:"bytes,2,opt,name=consumer_version,json=consumerVersion,proto3" json:"consumer_version,omitempty"`
	SchemaId        string           `protobuf:"bytes,3,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"`
	SchemaVersion   string           `protobuf:"bytes,4,opt,name=schema_version,json=schemaVersion,proto3" json:"schema_version,omitempty"`
	Environment     string           `protobuf:"bytes,5,opt,name=environment,proto3" json:"environment,omitempty"`
	UsedEndpoints   []*EndpointUsage `protobuf:"bytes,6,rep,name=used_endpoints,json=usedEndpoints,proto3" json:"used_endpoints,omitempty"`
	// contains filtered or unexported fields
}

type RegisterConsumerResponse struct {
	Success  bool          `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	Message  string        `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	Consumer *ConsumerInfo `protobuf:"bytes,3,opt,name=consumer,proto3" json:"consumer,omitempty"`
	// contains filtered or unexported fields
}

type RegisterSchemaRequest struct {
	SchemaId           string           `protobuf:"bytes,1,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"`                                // Unique identifier for the schema
	SchemaContent      string           `protobuf:"bytes,2,opt,name=schema_content,json=schemaContent,proto3" json:"schema_content,omitempty"`                 // The OpenAPI spec content (YAML or JSON)
	SchemaVersion      string           `protobuf:"bytes,3,opt,name=schema_version,json=schemaVersion,proto3" json:"schema_version,omitempty"`                 // Optional semantic version
	Ownership          *SchemaOwnership `protobuf:"bytes,4,opt,name=ownership,proto3" json:"ownership,omitempty"`                                              // Optional ownership information
	CheckCompatibility bool             `protobuf:"varint,5,opt,name=check_compatibility,json=checkCompatibility,proto3" json:"check_compatibility,omitempty"` // If true, check for breaking changes
	// contains filtered or unexported fields
}

type RegisterSchemaResponse struct {
	Success         bool              `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	Message         string            `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	Metadata        *SchemaMetadata   `protobuf:"bytes,3,opt,name=metadata,proto3" json:"metadata,omitempty"`                                      // Metadata for the registered schema
	BreakingChanges []*BreakingChange `protobuf:"bytes,4,rep,name=breaking_changes,json=breakingChanges,proto3" json:"breaking_changes,omitempty"` // Breaking changes if any detected
	// contains filtered or unexported fields
}

type RequestData struct {
	Method  string            `protobuf:"bytes,1,opt,name=method,proto3" json:"method,omitempty"` // GET, POST, etc.
	Path    string            `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`     // /users/123
	Headers map[string]string ``                                                                  /* 141-byte string literal not displayed */
	Body    string            `protobuf:"bytes,4,opt,name=body,proto3" json:"body,omitempty"`     // JSON body as string
	// contains filtered or unexported fields
}

type ResponseData struct {
	StatusCode int32             `protobuf:"varint,1,opt,name=status_code,json=statusCode,proto3" json:"status_code,omitempty"`
	Headers    map[string]string ``                                                              /* 141-byte string literal not displayed */
	Body       string            `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"` // JSON body as string
	// contains filtered or unexported fields
}

type SchemaMetadata struct {
	SchemaId       string           `protobuf:"bytes,1,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"`                // Unique identifier
	SchemaVersion  string           `protobuf:"bytes,2,opt,name=schema_version,json=schemaVersion,proto3" json:"schema_version,omitempty"` // Semantic version (e.g., "1.2.3")
	SchemaHash     string           `protobuf:"bytes,3,opt,name=schema_hash,json=schemaHash,proto3" json:"schema_hash,omitempty"`          // SHA256 hash of schema content
	RegisteredAt   int64            `protobuf:"varint,4,opt,name=registered_at,json=registeredAt,proto3" json:"registered_at,omitempty"`   // Unix timestamp of initial registration
	UpdatedAt      int64            `protobuf:"varint,5,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`            // Unix timestamp of last update
	Ownership      *SchemaOwnership `protobuf:"bytes,6,opt,name=ownership,proto3" json:"ownership,omitempty"`
	OpenapiVersion string           `protobuf:"bytes,7,opt,name=openapi_version,json=openapiVersion,proto3" json:"openapi_version,omitempty"` // Detected OpenAPI version (e.g., "3.0.0")
	EndpointCount  int32            `protobuf:"varint,8,opt,name=endpoint_count,json=endpointCount,proto3" json:"endpoint_count,omitempty"`   // Number of endpoints in schema
	// contains filtered or unexported fields
}

type SchemaOwnership struct {
	Owner        string `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"`                                   // Owner name or identifier
	Team         string `protobuf:"bytes,2,opt,name=team,proto3" json:"team,omitempty"`                                     // Team responsible for the schema
	ContactEmail string `protobuf:"bytes,3,opt,name=contact_email,json=contactEmail,proto3" json:"contact_email,omitempty"` // Contact email for schema issues
	ReadOnly     bool   `protobuf:"varint,4,opt,name=read_only,json=readOnly,proto3" json:"read_only,omitempty"`            // If true, schema cannot be updated
	// contains filtered or unexported fields
}

type UnimplementedContractValidatorServer struct{}

type UnsafeContractValidatorServer interface {
	// contains filtered or unexported methods
}

type ValidateProducerRequest struct {
	SchemaId      string        `protobuf:"bytes,1,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"`                // Schema to validate against
	SchemaVersion string        `protobuf:"bytes,2,opt,name=schema_version,json=schemaVersion,proto3" json:"schema_version,omitempty"` // Optional: specific schema version
	Method        string        `protobuf:"bytes,3,opt,name=method,proto3" json:"method,omitempty"`                                    // HTTP method (GET, POST, etc.)
	Path          string        `protobuf:"bytes,4,opt,name=path,proto3" json:"path,omitempty"`                                        // API path with actual values (e.g., /users/123)
	Response      *ResponseData `protobuf:"bytes,5,opt,name=response,proto3" json:"response,omitempty"`                                // The response to validate
	Request       *RequestData  `protobuf:"bytes,6,opt,name=request,proto3" json:"request,omitempty"`                                  // Optional: request context (for path param extraction)
	// contains filtered or unexported fields
}

type ValidationResult struct {
	Valid                   bool     `protobuf:"varint,1,opt,name=valid,proto3" json:"valid,omitempty"`
	Errors                  []string `protobuf:"bytes,2,rep,name=errors,proto3" json:"errors,omitempty"`
	ValidatedAgainstVersion string   `` // Version of schema used for validation
	/* 132-byte string literal not displayed */
	ValidatedAgainstHash string `protobuf:"bytes,4,opt,name=validated_against_hash,json=validatedAgainstHash,proto3" json:"validated_against_hash,omitempty"` // Hash of schema used for validation
	// contains filtered or unexported fields
}