forgepb

type ActivityOptions struct {

	// Verb is the action, a lower_snake token: "promote", "rotate",
	// "restart". It is stored as written; the UI phrases it ("promoted").
	Verb string `protobuf:"bytes,1,opt,name=verb,proto3" json:"verb,omitempty"`
	// Target names the object the action was done to.
	Target *ActivityTarget `protobuf:"bytes,2,opt,name=target,proto3" json:"target,omitempty"`
	// Env is the field path whose value is the environment the action
	// happened in. Empty records a project-level event.
	Env string `protobuf:"bytes,3,opt,name=env,proto3" json:"env,omitempty"`
	// Scope is the field path whose value is the scope (an org, a project)
	// reads are filtered by. Empty takes the interceptor's
	// ScopeFrom default (the caller's org).
	Scope string `protobuf:"bytes,4,opt,name=scope,proto3" json:"scope,omitempty"`
	// Detail lists field paths copied into the event's detail map, keyed by
	// each path's last segment.
	Detail []string `protobuf:"bytes,5,rep,name=detail,proto3" json:"detail,omitempty"`
	// Writer says who writes the event. The default, the interceptor, writes
	// it after the handler succeeds. HANDLER means the handler calls
	// activity.Record inside its own transaction, so the event commits or
	// rolls back with the mutation.
	Writer ActivityWriter `protobuf:"varint,6,opt,name=writer,proto3,enum=forge.v1.ActivityWriter" json:"writer,omitempty"`
	// None records that this rpc changes nothing worth an activity event,
	// and says why: `activity: { none: "dry run: computes a plan only" }`.
	// It excludes every other field, and the reason must not be empty.
	None string `protobuf:"bytes,7,opt,name=none,proto3" json:"none,omitempty"`
	// contains filtered or unexported fields
}

type ActivityTarget struct {

	// Kind is the target's type, a lower_snake literal: "release", "secret".
	Kind string `protobuf:"bytes,1,opt,name=kind,proto3" json:"kind,omitempty"`
	// Id is the field path of the target's id. Required.
	Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	// Label is the field path of a human-readable label for the target.
	// Empty falls back to the id.
	Label string `protobuf:"bytes,3,opt,name=label,proto3" json:"label,omitempty"`
	// contains filtered or unexported fields
}

type ActivityWriter int32

type AuthConfig struct {

	// Whether authentication is required for this service by default.
	AuthRequired bool `protobuf:"varint,1,opt,name=auth_required,json=authRequired,proto3" json:"auth_required,omitempty"`
	// Authentication provider identifier (e.g., "jwt", "api_key", "oauth2").
	AuthProvider string `protobuf:"bytes,2,opt,name=auth_provider,json=authProvider,proto3" json:"auth_provider,omitempty"`
	// contains filtered or unexported fields
}

type BinaryConfigOptions struct {

	// Binary is the cmd/<name> leaf whose process loads this config — the same
	// name `forge scaffold binary` creates and the deploy layer names its
	// workload after. A message annotated with a binary that has no cmd/<name>
	// directory is a generate-time error, not a silently unused config.
	Binary string `protobuf:"bytes,1,opt,name=binary,proto3" json:"binary,omitempty"`
	// Command is the cobra command path BELOW the binary whose process loads
	// this config, one command name per element: ["server", "api"] for
	// `reliant server api`. Empty binds the binary's root config. Two
	// messages may not bind the same (binary, command).
	//
	// forge validates the SHAPE at generate time (each element one command
	// name: non-empty, no whitespace, not a flag) but cannot prove the path
	// exists there: a cobra tree is assembled at runtime by AddCommand calls in
	// any package, from `Use` strings that may be computed, so a static scan
	// would be a guess that is wrong in both directions — and a wrong refusal
	// blocks generate. The exact check runs where the tree is real: the
	// generated Load<Msg>(cmd) refuses a command whose path is not this one.
	Command []string `protobuf:"bytes,2,rep,name=command,proto3" json:"command,omitempty"`
	// Subtrees binds this config to every command AT OR BELOW each path:
	// [{path: ["daemon"]}] is loaded by `daemon start`, `daemon status` and
	// every other command under `daemon`, and by `daemon` itself. Exclusive
	// with `command` (a config is one process's, or a subtree's); both empty
	// binds the binary's root config. Each path is shaped like `command`, and
	// no path may lie below another of the same message (the outer one already
	// covers it). Register<Msg>Flags is called on each path's command; the
	// generated Load<Msg>(cmd) refuses a command under none of them.
	Subtrees []*CommandPath `protobuf:"bytes,3,rep,name=subtrees,proto3" json:"subtrees,omitempty"`
	// contains filtered or unexported fields
}

type CommandPath struct {
	Path []string `protobuf:"bytes,1,rep,name=path,proto3" json:"path,omitempty"`
	// contains filtered or unexported fields
}

type ConfigCondition struct {

	// Field is the PROTO name of a sibling string field ("hosting"), not its
	// env_var: the condition is part of the message, and a rename of the
	// field's env spelling must not silently detach it.
	Field string `protobuf:"bytes,1,opt,name=field,proto3" json:"field,omitempty"`
	// Equals is the value that field must hold for the condition to be true.
	// When the field declares allowed_values it must be one of them.
	Equals string `protobuf:"bytes,2,opt,name=equals,proto3" json:"equals,omitempty"`
	// contains filtered or unexported fields
}

type ConfigFieldOptions struct {

	// Environment variable name to read this field from (e.g., "DATABASE_URL").
	// A variable set to "" counts as unset, whatever the field's type: the file
	// or default value stands. An explicitly empty value is a flag's to set.
	EnvVar string `protobuf:"bytes,1,opt,name=env_var,json=envVar,proto3" json:"env_var,omitempty"`
	// CLI flag name, without leading dashes (e.g., "database-url").
	Flag string `protobuf:"bytes,2,opt,name=flag,proto3" json:"flag,omitempty"`
	// Default value as a string: what the SOURCE says. A build can override
	// it — the generated pkg/config.BuildDefaults, stamped with -ldflags -X in
	// URL query form keyed by env_var ("SERVER_URL=https://api&REGION=eu") —
	// and the config file, env var and flag override both:
	//   default_value < build default < config file < env var < flag.
	// A sensitive field takes neither (a secret in a binary is published).
	DefaultValue string `protobuf:"bytes,3,opt,name=default_value,json=defaultValue,proto3" json:"default_value,omitempty"`
	// Whether this field must be provided. Loading fails if no layer (default,
	// config file, env var, flag) gives it a value. It is the ONE runtime
	// presence check, for every field kind: `sensitive` does not imply it (see
	// `optional` for why). A credential the process cannot run without says
	// `required: true` alongside `sensitive: true`.
	Required bool `protobuf:"varint,4,opt,name=required,proto3" json:"required,omitempty"`
	// Human-readable description shown in --help output and documentation.
	Description string `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
	// Sensitive marks this field as secret — its value MUST come from a
	// Kubernetes Secret (or equivalent) rather than a literal env-var, and
	// it is never written to forge.yaml inline. The deploy generator emits
	// a `secretKeyRef`-shaped EnvVar referencing a project-level Secret
	// (default name: <project>-secrets, key: <env_var>), projected into a
	// workload's env only when that workload names it in `config_secrets`.
	// Sensitive says where a value comes from (a Secret, never a flag or an
	// inline manifest value), not whether there must be one: that is
	// `required`, at runtime, and the secret pre-flight for a ref a workload
	// declares (see `optional`).
	Sensitive bool `protobuf:"varint,6,opt,name=sensitive,proto3" json:"sensitive,omitempty"`
	// Category groups related fields for KCL emission. Fields with the same
	// category are rendered together as a single env-var group (e.g.
	// category: "stripe" → STRIPE_ENV bundle). Empty category lands the
	// field in the default APP_ENV bundle.
	Category string `protobuf:"bytes,7,opt,name=category,proto3" json:"category,omitempty"`
	// Role tags a field with a SEMANTIC meaning that drives behavior, so
	// forge/pkg/config can offer annotation-driven helpers without matching
	// on the field's NAME. Renaming a field never changes behavior — the
	// behavior follows the annotation. Naming a field "environment" without
	// the annotation does NOT make it the mode field.
	Role ConfigFieldRole `protobuf:"varint,8,opt,name=role,proto3,enum=forge.v1.ConfigFieldRole" json:"role,omitempty"`
	// AllowedValues constrains a STRING field to a closed set of valid
	// values, enforced when the config loads (Load runs config.Validate, so
	// an out-of-set value fails the load, naming the field). It is the
	// type/annotation-driven replacement for the old name-matched log-format
	// check ("json"/"text"): a string field carrying allowed_values is a
	// string ENUM, rejected when its resolved value is outside the set. The
	// empty value is always permitted (an unset, non-required field). True
	// proto enum fields don't need this — protoreflect already enforces their
	// domain. Renaming the field changes nothing; the set follows the
	// annotation.
	AllowedValues []string `protobuf:"bytes,9,rep,name=allowed_values,json=allowedValues,proto3" json:"allowed_values,omitempty"`
	// Optional marks a field the application TOLERATES being unset. It acts
	// at DEPLOY time; at runtime presence is `required`'s alone.
	//
	//   - sensitive: a secret_ref a workload declares (by naming the field in
	//     its `config_secrets`) is validated against the env's store before
	//     anything starts (secrets.ValidateDeclaredRefs), and a declared ref
	//     with no value is an error by default: discovering a missing
	//     production credential at runtime is the failure the pre-flight
	//     exists to prevent. `optional: true` exempts the field from that
	//     check and marks the rendered ref optional (secretKeyRef.optional /
	//     managedSecret.optional), so the pod starts without it.
	//   - not sensitive: the env projection omits the field while its value is
	//     the schema default, so a knob only some environments set does not
	//     churn every other environment's manifests.
	//
	// WHY sensitive DOES NOT IMPLY REQUIRED AT RUNTIME. Whether a credential
	// must exist is a property of the WORKLOAD that reads it, not of the
	// field: one config is loaded by several workloads, and each projects only
	// the secrets its `config_secrets` names. A runtime check implied by
	// `sensitive` would refuse to start every workload that deliberately does
	// not read one (a worker sharing the API server's config, a key source the
	// process uses only when another is unset), forcing a fake value into the
	// store. So the deploy pre-flight checks what a workload declares, and a
	// field the PROCESS cannot run without says so with `required: true`, the
	// same way any other field does.
	//
	// But an OPTIONAL-BY-DESIGN credential is a real thing, and forge had no
	// way to say so. The case that forced this: a config block whose
	// admin_user + admin_password are documented as the tier's ON SWITCH —
	// with either unset the reconciler is deliberately not registered. Every
	// non-sensitive field in that block projects as `str = ""` and unset is
	// fine; only the sensitive one became a hard startup requirement, so an
	// environment that had deliberately not enabled the tier could not start
	// at all. The operator's only recourse was to invent a fake value, which
	// puts a real-looking credential in the store and defeats the check for
	// everyone.
	//
	// So: `optional: true` says the absence is intended, and the secret-store
	// validation skips the field. It is deliberately an OPT-IN — the safe
	// default stays "a declared secret must have a value", and an author has
	// to state the exception.
	//
	// It is an ERROR to set both `required: true` and `optional: true`; they
	// are direct contradictions and forge rejects the pair rather than
	// silently picking one.
	Optional bool `protobuf:"varint,10,opt,name=optional,proto3" json:"optional,omitempty"`
	// EnvVarAliases are further environment variables the field is read from,
	// in order, when env_var is unset: the first one set wins, and a variable
	// set to "" counts as unset, exactly as for env_var. A flag still beats
	// all of them.
	//
	//   string environment = 1 [(forge.v1.config) = {
	//     env_var: "RELIANT_ENV"
	//     env_var_aliases: [{name: "NODE_ENV"}]
	//   }];
	//   int32 port = 2 [(forge.v1.config) = {
	//     env_var: "DAEMON_LISTEN_PORT"
	//     env_var_aliases: [{name: "TOOLS_DAEMON_PORT", deprecated: true}]
	//   }];
	//
	// An alias is for a SETTER forge does not control: a convention another
	// tool owns (NODE_ENV), or an older name a deployment elsewhere still
	// exports. forge's own setters use env_var alone — the KCL env map and the
	// secret store key name only the primary — so every manifest forge renders
	// converges on one name. A flag's --help lists env_var and the permanent
	// aliases; a deprecated alias is never advertised.
	//
	// Aliases need env_var, are read only from the environment, and must not
	// repeat any env var or alias another field of the same process reads;
	// `forge generate` refuses each of those. A frontend config field takes
	// no aliases: its values come from the rendered config document, not
	// from an environment.
	EnvVarAliases []*EnvVarAlias `protobuf:"bytes,11,rep,name=env_var_aliases,json=envVarAliases,proto3" json:"env_var_aliases,omitempty"`
	// EnvPrefix (with EnvSuffix) binds a `map<string, V>` field, V a scalar,
	// to a FAMILY of environment variables: every variable named
	// <env_prefix><KEY><env_suffix> with a non-empty KEY is one entry,
	// map[KEY] = value parsed as V. KEY is taken verbatim.
	//
	//   map<string, string> oauth_client_ids = 1 [(forge.v1.config) = {
	//     env_prefix: "APP_OAUTH_", env_suffix: "_CLIENT_ID"
	//   }];
	//   map<string, string> oauth_client_secrets = 2 [(forge.v1.config) = {
	//     env_prefix: "APP_OAUTH_", env_suffix: "_CLIENT_SECRET", sensitive: true
	//   }];
	//   map<string, bool> features = 3 [(forge.v1.config) = {env_prefix: "APP_FEATURE_"}];
	//
	// APP_OAUTH_GITHUB_CLIENT_ID=abc loads oauth_client_ids["GITHUB"] = "abc".
	// It is for a set of keys the PROCESS does not know at build time (an
	// integration catalog, feature names an operator invents); a set the proto
	// can name is fields.
	//
	// The prefix is OWNED: a variable that starts with a family's env_prefix
	// and matches no family and no env_var of the process fails the load,
	// naming it — APP_OAUTH_GITHUB_CLIENT_SECERT is a typo, never an entry
	// silently missing. Env entries overlay the config file's map key by key.
	// `required: true` means at least one entry; allowed_values constrains
	// every value; `sensitive` keeps the values off flags and inline manifests.
	// A family takes no env_var, env_var_aliases, flag or default_value, and
	// `forge generate` refuses two families (or a family and an env_var) of one
	// process that could claim the same variable.
	//
	// Families are read from the environment and the config file. The KCL
	// config schema projects one as a map keyed by KEY — `{str: str}`, or
	// `{str: ConfigSecretRef}` for a sensitive one — and the env projection
	// expands each entry to its variable: inline for a plain family, one
	// forge.SecretRef per KEY for a sensitive one, which a workload selects
	// by naming the family's pattern (APP_OAUTH_<KEY>_CLIENT_SECRET) in
	// `config_secrets`.
	EnvPrefix string `protobuf:"bytes,12,opt,name=env_prefix,json=envPrefix,proto3" json:"env_prefix,omitempty"`
	// EnvSuffix is the fixed tail of an env_prefix family's variable names
	// ("_CLIENT_ID"); empty when the KEY runs to the end of the name.
	EnvSuffix string `protobuf:"bytes,13,opt,name=env_suffix,json=envSuffix,proto3" json:"env_suffix,omitempty"`
	// RequiredWhen makes the field required in a MODE of the config: when any
	// listed condition holds, the runtime config document must carry a
	// non-empty value for this field. The field's default does not satisfy
	// it — the condition names a mode the default is wrong for (a managed
	// deployment, where the default is a self-hosted value), or the field
	// would not need the condition.
	//
	//   string hosting = 6 [(forge.v1.config) = {
	//     env_var: "HOSTING", allowed_values: ["cloud"]
	//   }];
	//   string api_url = 1 [(forge.v1.config) = {
	//     env_var: "API_URL"
	//     required_when: [{field: "hosting", equals: "cloud"}]
	//   }];
	//
	// It is for a (forge.v1.frontend_config) message, whose values arrive in
	// one document (config.js) that every check can see whole:
	//   - the generated config_gen.ts refuses the document at boot
	//     (loadConfig, and missingRequiredConfig for an app that renders its
	//     own message), naming each missing key and the condition;
	//   - config_schema_gen.json records it, so a project declaring the
	//     frontend's environments from ANOTHER repository refuses a
	//     runtime_config without the key at render, instead of shipping an
	//     app that boots in the wrong mode;
	//   - the frontend's typed KCL schema checks it for an in-tree frontend.
	// `forge generate` refuses it on a binary config (the loader there layers
	// defaults, files, env and flags, and has no single document to judge),
	// with `required: true` (redundant), and with a condition naming a field
	// that is not a sibling string field or a value outside its
	// allowed_values.
	RequiredWhen []*ConfigCondition `protobuf:"bytes,14,rep,name=required_when,json=requiredWhen,proto3" json:"required_when,omitempty"`
	// contains filtered or unexported fields
}

type ConfigFieldRole int32

type EntityOptions struct {

	// Database table name. Inferred from the message name (snake_case, pluralized)
	// when left empty.
	Table string `protobuf:"bytes,1,opt,name=table,proto3" json:"table,omitempty"`
	// Enable soft-delete semantics (adds a deleted_at column).
	SoftDelete bool `protobuf:"varint,2,opt,name=soft_delete,json=softDelete,proto3" json:"soft_delete,omitempty"`
	// Automatically manage created_at and updated_at timestamp columns.
	Timestamps bool `protobuf:"varint,3,opt,name=timestamps,proto3" json:"timestamps,omitempty"`
	// Composite or single-column indexes to create on this table.
	Indexes []*IndexDef `protobuf:"bytes,4,rep,name=indexes,proto3" json:"indexes,omitempty"`
	// Contract middleware to wire around generated repository methods.
	// Supported values: "tracing", "metrics", "logging".
	Middleware []string `protobuf:"bytes,5,rep,name=middleware,proto3" json:"middleware,omitempty"`
	// contains filtered or unexported fields
}

type EnvVarAlias struct {

	// Name is the environment variable, e.g. "NODE_ENV".
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Deprecated marks a name kept only so existing setters keep working
	// while they move to env_var. A process that finds it set prints one
	// line to stderr at load naming env_var, whether the alias supplied the
	// value or was shadowed by an earlier name. A permanent alias (the
	// default) is read silently: NODE_ENV is somebody else's convention, not
	// a migration in flight, and a notice at every start would be noise.
	Deprecated bool `protobuf:"varint,2,opt,name=deprecated,proto3" json:"deprecated,omitempty"`
	// Values maps the alias's values onto the FIELD's: the alias is read only
	// when it is set to one of the keys, and the field takes the mapped value.
	// Any other value — and unset, and "" — reads as the alias being unset, so
	// the next name is tried.
	//
	//   string level = 1 [(forge.v1.config) = {
	//     env_var: "APP_LOG_LEVEL"
	//     env_var_aliases: [{name: "DEBUG", values: [{key: "true", value: "debug"}, {key: "1", value: "debug"}]}]
	//   }];
	//
	// It is for a variable whose CONVENTION implies one of this field's values
	// without carrying it: DEBUG=true meaning a debug log level, CI=true a
	// non-interactive mode. Such a variable is not this field's to parse —
	// DEBUG=express:* belongs to another tool — so a value outside the map is
	// ignored rather than refused, which is the one place the config loader
	// ignores a value it was handed. Keys match exactly (no trimming, no case
	// folding: the convention decides its spelling). Each mapped value must be
	// valid for the field (its kind and allowed_values); `forge generate`
	// refuses one that is not. A variable your own project owns needs no map:
	// name its values after the field's and make it env_var or a plain alias.
	Values map[string]string `` /* 139-byte string literal not displayed */
	// contains filtered or unexported fields
}

type FieldOptions struct {

	// Mark this field as the primary key.
	Pk bool `protobuf:"varint,1,opt,name=pk,proto3" json:"pk,omitempty"`
	// How to store complex or non-scalar types in the database.
	Store StoreAs `protobuf:"varint,3,opt,name=store,proto3,enum=forge.v1.StoreAs" json:"store,omitempty"`
	// Foreign key reference in "table.column" format (e.g., "users.id").
	Ref string `protobuf:"bytes,4,opt,name=ref,proto3" json:"ref,omitempty"`
	// Column has a UNIQUE constraint.
	Unique bool `protobuf:"varint,5,opt,name=unique,proto3" json:"unique,omitempty"`
	// Create a single-column index on this field.
	Index bool `protobuf:"varint,6,opt,name=index,proto3" json:"index,omitempty"`
	// SQL default expression (e.g., "0", "'active'", "NOW()").
	DefaultValue string `protobuf:"bytes,7,opt,name=default_value,json=defaultValue,proto3" json:"default_value,omitempty"`
	// Skip this field in code generation entirely.
	Skip bool `protobuf:"varint,8,opt,name=skip,proto3" json:"skip,omitempty"`
	// Application-layer validation rules for this field.
	Validate *ValidationRules `protobuf:"bytes,9,opt,name=validate,proto3" json:"validate,omitempty"`
	// Field cannot be updated after initial creation.
	Immutable bool `protobuf:"varint,10,opt,name=immutable,proto3" json:"immutable,omitempty"`
	// contains filtered or unexported fields
}

type FrontendConfigOptions struct {

	// Frontend is the forge.yaml `frontends[].name` whose bundle loads this
	// config — the same name `forge scaffold frontend` creates. A message
	// annotated with a frontend that no forge.yaml declares is a
	// generate-time error, not a silently unused config.
	Frontend string `protobuf:"bytes,1,opt,name=frontend,proto3" json:"frontend,omitempty"`
	// contains filtered or unexported fields
}

type IndexDef struct {

	// Index name. Auto-generated from field names when left empty.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Column names included in this index, in order.
	Fields []string `protobuf:"bytes,2,rep,name=fields,proto3" json:"fields,omitempty"`
	// Whether this index enforces a uniqueness constraint.
	Unique bool `protobuf:"varint,3,opt,name=unique,proto3" json:"unique,omitempty"`
	// contains filtered or unexported fields
}

type MethodOptions struct {

	// Whether this method requires authentication. Optional so the default
	// (fail-closed: auth required) is distinguishable from an explicit
	// `auth_required = false` opt-out at the proto level.
	// Overrides the service-level AuthConfig.auth_required default.
	AuthRequired *bool `protobuf:"varint,1,opt,name=auth_required,json=authRequired,proto3,oneof" json:"auth_required,omitempty"`
	// Whether this method is idempotent (safe to retry without side effects).
	Idempotent bool `protobuf:"varint,3,opt,name=idempotent,proto3" json:"idempotent,omitempty"`
	// Server-side deadline for this method. forge projects it into
	// pkg/middleware/procedures_gen.go (ProcedureDeadlines), which the
	// scaffolded chain hands its Deadline slot; that slot runs ahead of
	// authentication, so the deadline bounds the credential lookup too. Unset
	// or zero is the slot's default (serverkit.DefaultUnaryDeadline for a unary
	// rpc, none for a stream); negative is no server deadline.
	Timeout *durationpb.Duration `protobuf:"bytes,4,opt,name=timeout,proto3" json:"timeout,omitempty"`
	// Whether callers should supply an idempotency key for this method.
	// This is a convention marker — Forge does not enforce or inspect the key.
	// When set, tooling, docs, and generated clients advise callers to pass a
	// unique key (e.g., an Idempotency-Key header) so the server can safely
	// deduplicate retried mutations.
	IdempotencyKey bool `protobuf:"varint,5,opt,name=idempotency_key,json=idempotencyKey,proto3" json:"idempotency_key,omitempty"`
	// Declared Connect/gRPC error codes this method can return. Codegen
	// surfaces these so handler authors (and LLMs implementing handlers)
	// can see the typed error contract at a glance. Values match
	// connect.Code names — e.g. "NotFound", "PermissionDenied",
	// "InvalidArgument". Empty (or unset) means "no declared errors" — the
	// method either succeeds or returns an undeclared Connect.Code.
	//
	// The list is informational at runtime today; future work may enforce
	// that handlers can only return declared codes.
	Errors []string `protobuf:"bytes,6,rep,name=errors,proto3" json:"errors,omitempty"`
	// Activity declares the typed activity event a successful call records:
	// who (the caller) did what (verb) to which object (target), where (env)
	// and through what (via). forge/pkg/activity's interceptor reads this
	// option from the method descriptor and writes the event, so no handler
	// writes one by hand; `forge lint` fails a mutating rpc that declares
	// nothing (forgeconv-activity-declared). See ActivityOptions.
	Activity *ActivityOptions `protobuf:"bytes,7,opt,name=activity,proto3" json:"activity,omitempty"`
	// contains filtered or unexported fields
}

type ServiceOptions struct {

	// Human-readable service name used in code generation and logging.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// API version string (e.g., "v1", "v2beta1").
	Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
	// Brief description of the service's purpose.
	Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
	// Controls how the service is exposed.
	Visibility ServiceVisibility `protobuf:"varint,4,opt,name=visibility,proto3,enum=forge.v1.ServiceVisibility" json:"visibility,omitempty"`
	// Other services this service depends on (for dependency injection).
	Dependencies []string `protobuf:"bytes,5,rep,name=dependencies,proto3" json:"dependencies,omitempty"`
	// Authentication configuration for the service.
	Auth *AuthConfig `protobuf:"bytes,6,opt,name=auth,proto3" json:"auth,omitempty"`
	// The trust domain whose callers this service serves: "user" (the
	// default, when empty) for the product's own signed-in users, or a name
	// the project chooses for another kind of caller ("daemon", "operator").
	// A serverkit.Listener refuses to start when it mounts a service whose
	// audience differs from its chain's Authenticator.Audience(), so a
	// listener authenticating one kind of caller can never serve another
	// kind's RPCs.
	Audience string `protobuf:"bytes,7,opt,name=audience,proto3" json:"audience,omitempty"`
	// contains filtered or unexported fields
}

type ServiceVisibility int32

type StoreAs int32

type ValidationRules struct {

	// Field value is required (must be non-zero-value).
	Required bool `protobuf:"varint,1,opt,name=required,proto3" json:"required,omitempty"`
	// Minimum length for string fields.
	MinLength int32 `protobuf:"varint,2,opt,name=min_length,json=minLength,proto3" json:"min_length,omitempty"`
	// Maximum length for string fields.
	MaxLength int32 `protobuf:"varint,3,opt,name=max_length,json=maxLength,proto3" json:"max_length,omitempty"`
	// Regex pattern the value must match.
	Pattern string `protobuf:"bytes,4,opt,name=pattern,proto3" json:"pattern,omitempty"`
	// Semantic format constraint (e.g., "email", "url", "uuid", "ip").
	Format string `protobuf:"bytes,5,opt,name=format,proto3" json:"format,omitempty"`
	// Minimum value for numeric fields.
	Min float64 `protobuf:"fixed64,6,opt,name=min,proto3" json:"min,omitempty"`
	// Maximum value for numeric fields.
	Max float64 `protobuf:"fixed64,7,opt,name=max,proto3" json:"max,omitempty"`
	// Allowed values (for enum-like string fields).
	AllowedValues []string `protobuf:"bytes,8,rep,name=allowed_values,json=allowedValues,proto3" json:"allowed_values,omitempty"`
	// Custom validation function name to call during validation.
	Custom string `protobuf:"bytes,9,opt,name=custom,proto3" json:"custom,omitempty"`
	// contains filtered or unexported fields
}