git_pages

type AuditConfig struct {
	// Globally unique machine identifier (0 to 63 inclusive).
	NodeID int `toml:"node-id"`
	// Whether audit reports should be stored whenever an audit event occurs.
	Collect bool `toml:"collect"`
	// If not empty, includes the principal's IP address in audit reports, with the value specifying
	// the source of the IP address. If the value is "X-Forwarded-For", the last item of the
	// corresponding header field (assumed to be comma-separated) is used. If the value is
	// "RemoteAddr", the connecting host's address is used. Any other value is disallowed.
	IncludeIPs string `toml:"include-ip"`
	// Endpoint to notify with a `GET /<notify-url>?<id>` whenever an audit event occurs.
	NotifyURL *URL `toml:"notify-url"`
}

type AuditEvent int32

type AuditID int64

type AuditRecord struct {

	// Audit event metadata.
	Id        *int64                 `protobuf:"varint,1,opt,name=id" json:"id,omitempty"`
	Timestamp *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=timestamp" json:"timestamp,omitempty"`
	Event     *AuditEvent            `protobuf:"varint,3,opt,name=event,enum=AuditEvent" json:"event,omitempty"`
	Principal *Principal             `protobuf:"bytes,4,opt,name=principal" json:"principal,omitempty"`
	// Affected resource.
	Domain  *string `protobuf:"bytes,10,opt,name=domain" json:"domain,omitempty"`
	Project *string `protobuf:"bytes,11,opt,name=project" json:"project,omitempty"` // only for `*Manifest` events
	// Snapshot of site manifest.
	Manifest *Manifest `protobuf:"bytes,12,opt,name=manifest" json:"manifest,omitempty"` // only for `*Manifest` events
	// contains filtered or unexported fields
}

type AuditRecordScope int

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

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

type Backend interface {
	// Returns true if the feature has been enabled for this store, false otherwise.
	HasFeature(ctx context.Context, feature BackendFeature) bool

	// Enables the feature for this store.
	EnableFeature(ctx context.Context, feature BackendFeature) error

	// Retrieve a blob. Returns `reader, size, mtime, err`.
	GetBlob(ctx context.Context, name string) (
		reader io.ReadSeeker, metadata BlobMetadata, err error,
	)

	// Store a blob. If a blob called `name` already exists, this function returns `nil` without
	// regards to the old or new contents. It is expected that blobs are content-addressed, i.e.
	// the `name` contains a cryptographic hash of `data`, but the backend is ignorant of this.
	PutBlob(ctx context.Context, name string, data []byte) error

	// Delete a blob. This is an unconditional operation that can break integrity of manifests.
	DeleteBlob(ctx context.Context, name string) error

	// Iterate through all blobs. Whether blobs that are newly added during iteration will appear
	// in the results is unspecified.
	EnumerateBlobs(ctx context.Context) iter.Seq2[BlobMetadata, error]

	// Retrieve a manifest.
	GetManifest(ctx context.Context, name string, opts GetManifestOptions) (
		manifest *Manifest, metadata ManifestMetadata, err error,
	)

	// Stage a manifest. This operation stores a new version of a manifest, locking any blobs
	// referenced from it in place (for garbage collection purposes) but without any other side
	// effects.
	StageManifest(ctx context.Context, manifest *Manifest) error

	// Whether a compare-and-swap operation on a manifest is truly race-free, or only best-effort
	// atomic with a small but non-zero window where two requests may race where the one committing
	// first will have its update lost. (Plain swap operations are always guaranteed to be atomic.)
	HasAtomicCAS(ctx context.Context) bool

	// Commit a manifest. This is an atomic operation; `GetManifest` calls will return either
	// the old version or the new version of the manifest, never anything else.
	CommitManifest(ctx context.Context, name string, manifest *Manifest, opts ModifyManifestOptions) error

	// Delete a manifest.
	DeleteManifest(ctx context.Context, name string, opts ModifyManifestOptions) error

	// Iterate through all manifests. Whether manifests that are newly added during iteration
	// will appear in the results is unspecified.
	EnumerateManifests(ctx context.Context) iter.Seq2[ManifestMetadata, error]

	// Check whether a domain has any deployments.
	CheckDomain(ctx context.Context, domain string) (found bool, err error)

	// Create a domain. This allows us to start serving content for the domain.
	CreateDomain(ctx context.Context, domain string) error

	// Freeze  a domain. This allows a site to be administratively locked, e.g. if it
	// is discovered serving abusive content.
	FreezeDomain(ctx context.Context, domain string) error

	// Thaw a domain. This removes the previously placed administrative lock (if any).
	UnfreezeDomain(ctx context.Context, domain string) error

	// Append a record to the audit log.
	AppendAuditLog(ctx context.Context, id AuditID, record *AuditRecord) error

	// Retrieve a single record from the audit log.
	QueryAuditLog(ctx context.Context, id AuditID) (record *AuditRecord, err error)

	// Retrieve records from the audit log by time range.
	SearchAuditLog(ctx context.Context, opts SearchAuditLogOptions) iter.Seq2[AuditID, error]
}

type BackendFeature string

type BlobMetadata struct {
	Name         string
	Size         int64
	LastModified time.Time
}

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

type CacheConfig struct {
	MaxSize  datasize.ByteSize `toml:"max-size"`
	MaxAge   Duration          `toml:"max-age"`
	MaxStale Duration          `toml:"max-stale"`
}

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

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

type Config struct {
	Insecure      bool                `toml:"-" env:"insecure"`
	Features      []string            `toml:"features"`
	LogFormat     string              `toml:"log-format" default:"text"`
	Server        ServerConfig        `toml:"server"`
	Wildcard      []WildcardConfig    `toml:"wildcard"`
	Fallback      FallbackConfig      `toml:"fallback"`
	Storage       StorageConfig       `toml:"storage"`
	Limits        LimitsConfig        `toml:"limits"`
	Audit         AuditConfig         `toml:"audit"`
	Observability ObservabilityConfig `toml:"observability"`
}

type CreateParentsMode int

type Duration time.Duration

type Entry struct {
	Type *Type `protobuf:"varint,1,opt,name=type,enum=Type" json:"type,omitempty"`
	// Only present for `type == InlineFile` and `type == ExternalFile`.
	// For transformed entries, refers to the pre-transformation (decompressed) size; otherwise
	// equal to `compressed_size`.
	OriginalSize *int64 `protobuf:"varint,7,opt,name=original_size,json=originalSize" json:"original_size,omitempty"`
	// Only present for `type == InlineFile` and `type == ExternalFile`.
	// For transformed entries, refers to the post-transformation (compressed) size; otherwise
	// equal to `original_size`.
	CompressedSize *int64 `protobuf:"varint,2,opt,name=compressed_size,json=compressedSize" json:"compressed_size,omitempty"`
	// Meaning depends on `type`:
	//   - If `type == InlineFile`, contains file data.
	//   - If `type == ExternalFile`, contains blob name (an otherwise unspecified
	//     cryptographically secure content hash).
	//   - If `type == Symlink`, contains link target.
	//   - Otherwise not present.
	Data []byte `protobuf:"bytes,3,opt,name=data" json:"data,omitempty"`
	// Only present for `type == InlineFile` and `type == ExternalFile` that
	// have been transformed.
	Transform *Transform `protobuf:"varint,4,opt,name=transform,enum=Transform" json:"transform,omitempty"`
	// Only present for `type == InlineFile` and `type == ExternalFile`.
	// Currently, optional (not present on certain legacy manifests).
	ContentType *string `protobuf:"bytes,5,opt,name=content_type,json=contentType" json:"content_type,omitempty"`
	// May be present for `type == InlineFile` and `type == ExternalFile`.
	// Used to reduce the amount of work being done during git checkouts.
	// The type of hash used is determined by the length:
	//   - 40 bytes: SHA1DC (as hex)
	//   - 64 bytes: SHA256 (as hex)
	GitHash *string `protobuf:"bytes,6,opt,name=git_hash,json=gitHash" json:"git_hash,omitempty"`
	// contains filtered or unexported fields
}

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

type FSConfig struct {
	Root string `toml:"root"`
}

type FallbackConfig struct {
	ProxyTo  *URL `toml:"proxy-to"`
	Insecure bool `toml:"insecure"`
}

type Flusher interface {
	Flush() error
}

type GetManifestOptions struct {
	// If true and the manifest is past the cache `MaxAge`, `GetManifest` blocks and returns
	// a fresh object instead of revalidating in background and returning a stale object.
	BypassCache bool
}

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

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

type Header struct {
	Name   *string  `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Values []string `protobuf:"bytes,2,rep,name=values" json:"values,omitempty"`
	// contains filtered or unexported fields
}

type HeaderRule struct {
	Path      *string   `protobuf:"bytes,1,opt,name=path" json:"path,omitempty"`
	HeaderMap []*Header `protobuf:"bytes,2,rep,name=header_map,json=headerMap" json:"header_map,omitempty"`
	// contains filtered or unexported fields
}

type LimitsConfig struct {
	// Maximum size of a single published site. Also used to limit the size of archive
	// uploads and other similar overconsumption conditions.
	MaxSiteSize datasize.ByteSize `toml:"max-site-size" default:"128M"`
	// Maximum size of a single site manifest, computed over its binary Protobuf
	// serialization.
	MaxManifestSize datasize.ByteSize `toml:"max-manifest-size" default:"1M"`
	// Maximum size of a file that will still be inlined into the site manifest.
	MaxInlineFileSize datasize.ByteSize `toml:"max-inline-file-size" default:"256B"`
	// Maximum size of a Git object that will be cached in memory during Git operations.
	GitLargeObjectThreshold datasize.ByteSize `toml:"git-large-object-threshold" default:"1M"`
	// Maximum number of symbolic link traversals before the path is considered unreachable.
	MaxSymlinkDepth uint `toml:"max-symlink-depth" default:"16"`
	// Maximum time that an update operation (PUT or POST request) could take before being
	// interrupted.
	UpdateTimeout Duration `toml:"update-timeout" default:"60s"`
	// Soft limit on Go heap size, expressed as a fraction of total available RAM.
	MaxHeapSizeRatio float64 `toml:"max-heap-size-ratio" default:"0.5"`
	// List of domains unconditionally forbidden for uploads.
	ForbiddenDomains []string `toml:"forbidden-domains" default:"[]"`
	// List of allowed repository URL prefixes. Setting this option prohibits uploading archives.
	AllowedRepositoryURLPrefixes []string `toml:"allowed-repository-url-prefixes" default:"[]"`
	// List of allowed custom headers. Header name must be in the MIME canonical form,
	// e.g. `Foo-Bar`. Setting this option permits including this custom header in `_headers`,
	// unless it is fundamentally unsafe.
	AllowedCustomHeaders []string `toml:"allowed-custom-headers" default:"[\"X-Clacks-Overhead\"]"`
}

type Manifest struct {

	// Source metadata.
	RepoUrl *string `protobuf:"bytes,1,opt,name=repo_url,json=repoUrl" json:"repo_url,omitempty"`
	Branch  *string `protobuf:"bytes,2,opt,name=branch" json:"branch,omitempty"`
	Commit  *string `protobuf:"bytes,3,opt,name=commit" json:"commit,omitempty"`
	// Site contents.
	Contents       map[string]*Entry ``                                                                                                  /* 136-byte string literal not displayed */
	OriginalSize   *int64            `protobuf:"varint,10,opt,name=original_size,json=originalSize" json:"original_size,omitempty"`      // sum of each `entry.original_size`
	CompressedSize *int64            `protobuf:"varint,5,opt,name=compressed_size,json=compressedSize" json:"compressed_size,omitempty"` // sum of each `entry.compressed_size`
	StoredSize     *int64            `protobuf:"varint,8,opt,name=stored_size,json=storedSize" json:"stored_size,omitempty"`             // sum of deduplicated `entry.compressed_size` for external files only
	// Netlify-style `_redirects` and `_headers` rules.
	Redirects []*RedirectRule `protobuf:"bytes,6,rep,name=redirects" json:"redirects,omitempty"`
	Headers   []*HeaderRule   `protobuf:"bytes,9,rep,name=headers" json:"headers,omitempty"`
	// Diagnostics for non-fatal errors.
	Problems []*Problem `protobuf:"bytes,7,rep,name=problems" json:"problems,omitempty"`
	// contains filtered or unexported fields
}

type ManifestMetadata struct {
	Name         string
	Size         int64
	LastModified time.Time
	ETag         string
}

type ModifyManifestOptions struct {
	// If non-zero, the request will only succeed if the manifest hasn't been changed since
	// the given time. Whether this is racy or not is can be determined via `HasAtomicCAS()`.
	IfUnmodifiedSince time.Time
	// If non-empty, the request will only succeed if the manifest hasn't changed from
	// the state corresponding to the ETag. Whether this is racy or not is can be determined
	// via `HasAtomicCAS()`.
	IfMatch string
}

type ObservabilityConfig struct {
	// Minimum duration for an HTTP request transaction to be unconditionally sampled.
	SlowResponseThreshold Duration `toml:"slow-response-threshold" default:"500ms"`
}

type Principal struct {
	IpAddress *string `protobuf:"bytes,1,opt,name=ip_address,json=ipAddress" json:"ip_address,omitempty"`
	CliAdmin  *bool   `protobuf:"varint,2,opt,name=cli_admin,json=cliAdmin" json:"cli_admin,omitempty"`
	// contains filtered or unexported fields
}

type Problem struct {
	Path  *string `protobuf:"bytes,1,opt,name=path" json:"path,omitempty"`
	Cause *string `protobuf:"bytes,2,opt,name=cause" json:"cause,omitempty"`
	// contains filtered or unexported fields
}

type RedirectKind int

type RedirectRule struct {
	From   *string `protobuf:"bytes,1,opt,name=from" json:"from,omitempty"`
	To     *string `protobuf:"bytes,2,opt,name=to" json:"to,omitempty"`
	Status *uint32 `protobuf:"varint,3,opt,name=status" json:"status,omitempty"`
	Force  *bool   `protobuf:"varint,4,opt,name=force" json:"force,omitempty"`
	// contains filtered or unexported fields
}

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

type S3Config struct {
	Endpoint        string      `toml:"endpoint"`
	Insecure        bool        `toml:"insecure"`
	AccessKeyID     string      `toml:"access-key-id"`
	SecretAccessKey string      `toml:"secret-access-key"`
	Region          string      `toml:"region"`
	Bucket          string      `toml:"bucket"`
	BlobCache       CacheConfig `toml:"blob-cache" default:"{\"MaxSize\":\"256MB\"}"`
	SiteCache       CacheConfig `toml:"site-cache" default:"{\"MaxAge\":\"60s\",\"MaxStale\":\"1h\",\"MaxSize\":\"16MB\"}"`
}

type SearchAuditLogOptions struct {
	// Inclusive lower bound on returned audit records, per their Snowflake ID (which may differ
	// slightly from the embedded timestamp). If zero, audit records are returned since beginning
	// of time.
	Since time.Time
	// Inclusive upper bound on returned audit records, per their Snowflake ID (which may differ
	// slightly from the embedded timestamp). If zero, audit records are returned until the end
	// of time.
	Until time.Time
}

type SearchAuditLogResult struct {
	ID  AuditID
	Err error
}

type ServerConfig struct {
	Pages   string `toml:"pages" default:"tcp/localhost:3000"`
	Caddy   string `toml:"caddy" default:"tcp/localhost:3001"`
	Metrics string `toml:"metrics" default:"tcp/localhost:3002"`
}

type StorageConfig struct {
	Type string   `toml:"type" default:"fs"`
	FS   FSConfig `toml:"fs"  default:"{\"Root\":\"./data\"}"`
	S3   S3Config `toml:"s3"`
}

type Transform int32

type Type int32

type URL struct {
	url.URL
}

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

type UpdateOutcome int

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

type WildcardConfig struct {
	Domain          string   `toml:"domain"`
	CloneURL        string   `toml:"clone-url"` // URL template, not an exact URL
	IndexRepos      []string `toml:"index-repos" default:"[]"`
	IndexRepoBranch string   `toml:"index-repo-branch" default:"pages"`
	Authorization   string   `toml:"authorization"`
}

type WildcardPattern struct {
	Domain        []string
	CloneURL      *fasttemplate.Template
	IndexRepos    []*fasttemplate.Template
	IndexBranch   string
	Authorization bool
}