dbgen

type AcceptInvitationRow struct {
	OwnerID string
	Role    string
	Email   string
}

type App struct {
	ID              uuid.UUID
	OwnerID         string
	Name            string
	Namespace       string
	Image           string
	Replicas        int32
	Port            int32
	CpuRequest      string
	CpuLimit        string
	MemoryRequest   string
	MemoryLimit     string
	CreatedAt       time.Time
	UpdatedAt       time.Time
	HealthPath      string
	HealthLiveness  bool
	Source          string
	Internal        bool
	ProjectID       pgtype.UUID
	CanvasX         *int32
	CanvasY         *int32
	HttpsOnly       bool
	CnameOnly       bool
	RepoUrl         string
	RepoBranch      string
	RepoSubdir      string
	RunAsUser       int64
	ConfigVersion   int64
	ActiveReleaseID pgtype.UUID
}

type AppHook struct {
	AppID           uuid.UUID
	OwnerID         string
	Secret          []byte
	CreatedAt       time.Time
	PendingAt       pgtype.Timestamptz
	PendingRevision string
	LastDeliveryAt  pgtype.Timestamptz
	LastDelivery    string
}

type AppLink struct {
	OwnerID   string
	FromAppID uuid.UUID
	ToAppID   uuid.UUID
	ViaKey    string
	CreatedAt time.Time
}

type AppRelease struct {
	ID                     uuid.UUID
	OwnerID                string
	AppID                  uuid.UUID
	ImageRef               string
	ImageDigest            string
	Source                 string
	SourceRevision         string
	Replicas               int32
	Port                   int32
	CpuRequest             string
	CpuLimit               string
	MemoryRequest          string
	MemoryLimit            string
	Internal               bool
	RunAsUser              int64
	FsGroup                int64
	ScratchPaths           []string
	WritableRootFilesystem bool
	HealthPath             string
	HealthLiveness         bool
	Env                    []byte
	SecretKeys             []string
	ConfigVersion          int64
	CreatedAt              time.Time
	Origin                 string
}

type AppReleaseBackfill struct {
	AppID         uuid.UUID
	OwnerID       string
	State         string
	LastError     string
	Attempts      int32
	NextAttemptAt time.Time
	UpdatedAt     time.Time
}

type AppendBuildLogParams struct {
	Chunk string
	ID    uuid.UUID
}

type Build struct {
	ID           uuid.UUID
	OwnerID      string
	AppID        uuid.UUID
	DeploymentID uuid.UUID
	RepoUrl      string
	RepoRef      string
	CommitSha    string
	Image        string
	Status       string
	Message      string
	Log          string
	StartedAt    time.Time
	FinishedAt   pgtype.Timestamptz
	JobName      string
}

type CancelDeploymentOperationParams struct {
	OwnerID string
	ID      uuid.UUID
}

type ClaimDeploymentOperationParams struct {
	LeaseDuration       pgtype.Interval
	ID                  uuid.UUID
	OwnerID             string
	MaxConcurrentBuilds int64
}

type ClaimDomainsDueForCheckParams struct {
	LeaseUntil time.Time
	DueBefore  time.Time
	Lim        int32
}

type ClaimNextDeploymentOperationParams struct {
	LeaseDuration       pgtype.Interval
	MaxConcurrentBuilds int64
}

type ClaimRecoverableDeploymentOperationParams struct {
	LeaseDuration pgtype.Interval
	OwnerID       string
	ID            uuid.UUID
}

type ClearProjectPositionsParams struct {
	OwnerID   string
	ProjectID pgtype.UUID
}

type ClusterJoin struct {
	ID          int32
	ServerUrl   string
	TokenSealed []byte
	UpdatedAt   time.Time
	UpdatedBy   pgtype.UUID
}

type CreateAppLinkParams struct {
	OwnerID   string
	FromAppID uuid.UUID
	ToAppID   uuid.UUID
	ViaKey    string
}

type CreateAppParams struct {
	OwnerID       string
	Name          string
	Namespace     string
	Image         string
	Replicas      int32
	Port          int32
	Source        string
	Internal      bool
	CpuRequest    string
	CpuLimit      string
	MemoryRequest string
	MemoryLimit   string
	ProjectID     pgtype.UUID
	RepoUrl       string
	RepoBranch    string
	RepoSubdir    string
}

type CreateAppReleaseParams struct {
	OwnerID                string
	AppID                  uuid.UUID
	ImageRef               string
	ImageDigest            string
	Source                 string
	SourceRevision         string
	Replicas               int32
	Port                   int32
	CpuRequest             string
	CpuLimit               string
	MemoryRequest          string
	MemoryLimit            string
	Internal               bool
	RunAsUser              int64
	FsGroup                int64
	ScratchPaths           []string
	WritableRootFilesystem bool
	HealthPath             string
	HealthLiveness         bool
	Env                    []byte
	SecretKeys             []string
	ConfigVersion          int64
	Origin                 string
}

type CreateBuildParams struct {
	OwnerID      string
	AppID        uuid.UUID
	DeploymentID uuid.UUID
	RepoUrl      string
	RepoRef      string
}

type CreateCustomDomainParams struct {
	OwnerID      string
	AppID        uuid.UUID
	Host         string
	VerifyTarget string
}

type CreateDeploymentOperationParams struct {
	OwnerID       string
	AppID         uuid.UUID
	DeploymentID  uuid.UUID
	ReleaseID     pgtype.UUID
	RequiresBuild bool
}

type CreateDeploymentParams struct {
	OwnerID   string
	AppID     uuid.UUID
	Image     string
	Revision  string
	Status    string
	ReleaseID pgtype.UUID
	Trigger   string
	ActorKind string
	ActorID   string
}

type CreateMagicLinkParams struct {
	UserID    uuid.UUID
	TokenHash []byte
	ExpiresAt time.Time
}

type CreateProjectParams struct {
	OwnerID string
	Slug    string
	Name    string
}

type CreateSessionParams struct {
	UserID       uuid.UUID
	TokenHash    []byte
	ActiveTeamID *string
	UserAgent    string
	Ip           string
	ExpiresAt    time.Time
}

type CreateTeamParams struct {
	ID          string
	DisplayName string
}

type CreateTeamRowParams struct {
	ID          string
	DisplayName string
	Email       string
}

type CreateVolumeAndBumpParams struct {
	OwnerID   string
	AppID     uuid.UUID
	Name      string
	MountPath string
	SizeBytes int64
	Class     string
}

type CreateVolumeAndBumpRow struct {
	ID            uuid.UUID
	OwnerID       string
	AppID         uuid.UUID
	Name          string
	MountPath     string
	SizeBytes     int64
	Class         string
	CreatedAt     time.Time
	UpdatedAt     time.Time
	ConfigVersion int64
}

type CreateVolumeParams struct {
	OwnerID   string
	AppID     uuid.UUID
	Name      string
	MountPath string
	SizeBytes int64
	Class     string
}

type DBTX interface {
	Exec(context.Context, string, ...interface{}) (pgconn.CommandTag, error)
	Query(context.Context, string, ...interface{}) (pgx.Rows, error)
	QueryRow(context.Context, string, ...interface{}) pgx.Row
}

type DeleteAppHookParams struct {
	OwnerID string
	AppID   uuid.UUID
}

type DeleteAppParams struct {
	OwnerID string
	ID      uuid.UUID
}

type DeleteCustomDomainParams struct {
	OwnerID string
	ID      uuid.UUID
}

type DeleteInvitationParams struct {
	ID      uuid.UUID
	OwnerID string
}

type DeleteInvitationsByInviterParams struct {
	OwnerID   string
	InvitedBy uuid.UUID
}

type DeleteMembershipParams struct {
	UserID  uuid.UUID
	OwnerID string
}

type DeleteOtherSessionsForUserParams struct {
	UserID uuid.UUID
	Keep   uuid.UUID
}

type DeleteProjectParams struct {
	OwnerID string
	ID      uuid.UUID
}

type DeleteVariableAndBumpParams struct {
	OwnerID string
	AppID   uuid.UUID
	Key     string
}

type DeleteVariableAndBumpRow struct {
	Secret        bool
	ConfigVersion int64
}

type DeleteVariableParams struct {
	OwnerID string
	AppID   uuid.UUID
	Key     string
}

type DeleteVolumeAndBumpParams struct {
	OwnerID string
	AppID   uuid.UUID
	Name    string
}

type DeleteVolumeAndBumpRow struct {
	ID            uuid.UUID
	OwnerID       string
	AppID         uuid.UUID
	Name          string
	MountPath     string
	SizeBytes     int64
	Class         string
	CreatedAt     time.Time
	UpdatedAt     time.Time
	ConfigVersion int64
}

type DeleteVolumeParams struct {
	OwnerID string
	AppID   uuid.UUID
	Name    string
}

type DeployActivityParams struct {
	OwnerID   string
	StartedAt time.Time
}

type DeployActivityRow struct {
	Day    time.Time
	Status string
	Total  int64
}

type Deployment struct {
	ID         uuid.UUID
	OwnerID    string
	AppID      uuid.UUID
	Image      string
	Revision   string
	Status     string
	Message    string
	StartedAt  time.Time
	FinishedAt pgtype.Timestamptz
	ReleaseID  pgtype.UUID
	Trigger    string
	ActorKind  string
	ActorID    string
}

type DeploymentOperation struct {
	ID             uuid.UUID
	OwnerID        string
	AppID          uuid.UUID
	DeploymentID   uuid.UUID
	ReleaseID      pgtype.UUID
	RequiresBuild  bool
	Status         string
	Message        string
	CreatedAt      time.Time
	ClaimedAt      pgtype.Timestamptz
	FinishedAt     pgtype.Timestamptz
	ClaimToken     pgtype.UUID
	LeaseExpiresAt pgtype.Timestamptz
	CancelledAt    pgtype.Timestamptz
	Checkpoint     string
	StageStartedAt time.Time
}

type Domain struct {
	ID            uuid.UUID
	OwnerID       string
	AppID         uuid.UUID
	Host          string
	Tls           bool
	CreatedAt     time.Time
	Managed       bool
	VerifiedAt    pgtype.Timestamptz
	VerifyTarget  string
	State         string
	Observed      string
	LastError     string
	LastCheckedAt pgtype.Timestamptz
	NextCheckAt   time.Time
	CheckAttempts int32
	Verified      bool
}

type FailQueuedBuildOperationParams struct {
	Message      string
	OwnerID      string
	DeploymentID uuid.UUID
}

type FinishBuildParams struct {
	Status    string
	Message   string
	Image     string
	CommitSha string
	ID        uuid.UUID
}

type FinishDeploymentOperationParams struct {
	Status         string
	Message        string
	OwnerID        string
	ID             uuid.UUID
	ExpectedStatus string
	ClaimToken     pgtype.UUID
}

type FinishDeploymentParams struct {
	OwnerID string
	ID      uuid.UUID
	Status  string
	Message string
}

type GetAppByIDParams struct {
	OwnerID string
	ID      uuid.UUID
}

type GetAppForReleaseBackfillParams struct {
	OwnerID string
	AppID   uuid.UUID
}

type GetAppHookParams struct {
	OwnerID string
	AppID   uuid.UUID
}

type GetAppParams struct {
	OwnerID string
	Name    string
}

type GetAppReleaseParams struct {
	OwnerID string
	AppID   uuid.UUID
	ID      uuid.UUID
}

type GetBuildForDeploymentParams struct {
	OwnerID      string
	DeploymentID uuid.UUID
}

type GetBuildParams struct {
	OwnerID string
	ID      uuid.UUID
}

type GetBuildRecoveryOperationParams struct {
	OwnerID      string
	DeploymentID uuid.UUID
}

type GetCustomDomainParams struct {
	OwnerID string
	ID      uuid.UUID
}

type GetDeploymentOperationByDeploymentParams struct {
	OwnerID      string
	DeploymentID uuid.UUID
}

type GetDeploymentOperationParams struct {
	OwnerID string
	ID      uuid.UUID
}

type GetDeploymentParams struct {
	OwnerID string
	ID      uuid.UUID
}

type GetHookForDeliveryRow struct {
	App    App
	Secret []byte
}

type GetInvitationByHashRow struct {
	ID        uuid.UUID
	OwnerID   string
	Email     string
	Role      string
	ExpiresAt time.Time
	CreatedAt time.Time
}

type GetLatestSuccessfulBuildForAppParams struct {
	OwnerID string
	AppID   uuid.UUID
}

type GetLiveDeploymentOperationForAppParams struct {
	OwnerID string
	AppID   uuid.UUID
}

type GetLiveSessionRow struct {
	ID              uuid.UUID
	UserID          uuid.UUID
	ActiveTeamID    *string
	AuthenticatedAt time.Time
	ExpiresAt       time.Time
	CreatedAt       time.Time
}

type GetMembershipParams struct {
	UserID  uuid.UUID
	OwnerID string
}

type GetPasswordByEmailRow struct {
	Secret      string
	ID          uuid.UUID
	Email       string
	DisplayName string
	CreatedAt   time.Time
	UpdatedAt   time.Time
}

type GetProjectByIDParams struct {
	OwnerID string
	ID      uuid.UUID
}

type GetProjectBySlugParams struct {
	OwnerID string
	Slug    string
}

type GetReleaseBackfillStateParams struct {
	OwnerID string
	AppID   uuid.UUID
}

type GetSessionByHashRow struct {
	ID              uuid.UUID
	UserID          uuid.UUID
	TokenHash       []byte
	ActiveTeamID    *string
	UserAgent       string
	Ip              string
	ExpiresAt       time.Time
	CreatedAt       time.Time
	AuthenticatedAt time.Time
	TeamName        string
	TeamEmail       string
	MemberRole      string
}

type GetSuccessfulBuildForImageParams struct {
	OwnerID string
	AppID   uuid.UUID
	Image   string
}

type GetVariableParams struct {
	OwnerID string
	AppID   uuid.UUID
	Key     string
}

type GetVolumeParams struct {
	OwnerID string
	AppID   uuid.UUID
	Name    string
}

type GrowVolumeAndBumpParams struct {
	SizeBytes int64
	OwnerID   string
	AppID     uuid.UUID
	Name      string
}

type GrowVolumeAndBumpRow struct {
	ID            uuid.UUID
	OwnerID       string
	AppID         uuid.UUID
	Name          string
	MountPath     string
	SizeBytes     int64
	Class         string
	CreatedAt     time.Time
	UpdatedAt     time.Time
	ConfigVersion int64
}

type GrowVolumeParams struct {
	SizeBytes int64
	OwnerID   string
	AppID     uuid.UUID
	Name      string
}

type HasVerifiedDomainsForAppParams struct {
	OwnerID string
	AppID   uuid.UUID
}

type IncrementAppConfigVersionParams struct {
	OwnerID string
	AppID   uuid.UUID
}

type Invitation struct {
	ID         uuid.UUID
	OwnerID    string
	Email      string
	Role       string
	TokenHash  []byte
	InvitedBy  pgtype.UUID
	ExpiresAt  time.Time
	AcceptedAt pgtype.Timestamptz
	CreatedAt  time.Time
}

type ListAdmissiblePushesRow struct {
	App             App
	PendingRevision string
}

type ListAppLinksRow struct {
	FromAppID uuid.UUID
	ToAppID   uuid.UUID
	ViaKey    string
	FromName  string
	ToName    string
}

type ListAppReleasesParams struct {
	OwnerID     string
	AppID       uuid.UUID
	ResultLimit int32
}

type ListAppsInProjectParams struct {
	OwnerID   string
	ProjectID pgtype.UUID
}

type ListAppsWithLastDeployRow struct {
	App              App
	LastDeployStatus string
}

type ListCustomDomainsForOwnerRow struct {
	Domain  Domain
	AppName string
}

type ListCustomDomainsParams struct {
	OwnerID string
	AppID   uuid.UUID
}

type ListDeploymentOperationsParams struct {
	OwnerID     string
	ResultLimit int32
}

type ListDeploymentsParams struct {
	OwnerID string
	AppID   uuid.UUID
	Limit   int32
}

type ListMembersOfTeamRow struct {
	UserID    uuid.UUID
	OwnerID   string
	Role      string
	CreatedAt time.Time
	Email     string
	UserName  string
}

type ListMembershipsForUserRow struct {
	UserID    uuid.UUID
	OwnerID   string
	Role      string
	CreatedAt time.Time
	TeamName  string
}

type ListPendingInvitationsRow struct {
	ID        uuid.UUID
	OwnerID   string
	Email     string
	Role      string
	ExpiresAt time.Time
	CreatedAt time.Time
}

type ListPendingReleaseBackfillsRow struct {
	App       App
	State     string
	LastError string
	Attempts  int32
}

type ListProjectsRow struct {
	ID        uuid.UUID
	OwnerID   string
	Slug      string
	Name      string
	CreatedAt time.Time
	UpdatedAt time.Time
	AppCount  int64
}

type ListRecentDeploymentsParams struct {
	OwnerID string
	Limit   int32
}

type ListRecentDeploymentsRow struct {
	ID              uuid.UUID
	OwnerID         string
	AppID           uuid.UUID
	Image           string
	Revision        string
	Status          string
	Message         string
	StartedAt       time.Time
	FinishedAt      pgtype.Timestamptz
	ReleaseID       pgtype.UUID
	Trigger         string
	ActorKind       string
	ActorID         string
	AppName         string
	AppNamespace    string
	ActiveReleaseID pgtype.UUID
}

type LockPasswordRow struct {
	ID     uuid.UUID
	Secret string
}

type MagicLink struct {
	ID         uuid.UUID
	UserID     uuid.UUID
	TokenHash  []byte
	ExpiresAt  time.Time
	ConsumedAt pgtype.Timestamptz
	CreatedAt  time.Time
}

type MarkHookPendingParams struct {
	Revision string
	AppID    uuid.UUID
}

type MarkVerifiedDomainsRoutedForAppParams struct {
	OwnerID string
	AppID   uuid.UUID
}

type Membership struct {
	UserID    uuid.UUID
	OwnerID   string
	Role      string
	CreatedAt time.Time
}

type MoveAppsWithoutProjectParams struct {
	OwnerID   string
	ProjectID pgtype.UUID
}

type PlatformDn struct {
	ID          int32
	CnameTarget string
	TxtPrefix   string
	UpdatedAt   time.Time
}

type PlatformRegistry struct {
	ID             int32
	Host           string
	Repository     string
	Username       string
	PasswordSealed []byte
	UpdatedAt      time.Time
	UpdatedBy      pgtype.UUID
	Insecure       bool
}

type Project struct {
	ID        uuid.UUID
	OwnerID   string
	Slug      string
	Name      string
	CreatedAt time.Time
	UpdatedAt time.Time
}

type Querier interface {
	// One conditional UPDATE, like the magic link: checking first and writing after
	// leaves a window in which the same invitation is accepted twice.
	AcceptInvitation(ctx context.Context, tokenHash []byte) (AcceptInvitationRow, error)
	// Appended rather than replaced, so a build streaming its output does not have
	// to hold the whole log in memory to write any of it.
	AppendBuildLog(ctx context.Context, arg AppendBuildLogParams) error
	CancelDeploymentOperation(ctx context.Context, arg CancelDeploymentOperationParams) (DeploymentOperation, error)
	ClaimDeploymentOperation(ctx context.Context, arg ClaimDeploymentOperationParams) (DeploymentOperation, error)
	// Claims the domains whose next check is due, and leases them.
	//
	// Two things at once, and both matter.
	//
	// FOR UPDATE SKIP LOCKED is what lets the checker run on every replica without
	// those replicas agreeing on anything: each takes rows nobody else holds, and a
	// row already being worked on is skipped rather than waited for. The build
	// reconciler is safe on several replicas for the same reason.
	//
	// Pushing next_check_at forward in the same statement is what keeps the lock
	// short. The alternative — holding the transaction open while the lookups run —
	// would hold row locks for as long as DNS takes to answer, which is unbounded
	// and occasionally seconds. Leasing instead means the claim is committed
	// immediately and the network happens outside any transaction; a checker that
	// dies mid-pass simply lets the lease expire, and the next pass picks the row
	// up again.
	ClaimDomainsDueForCheck(ctx context.Context, arg ClaimDomainsDueForCheckParams) ([]Domain, error)
	ClaimNextDeploymentOperation(ctx context.Context, arg ClaimNextDeploymentOperationParams) (DeploymentOperation, error)
	// Applying and verifying are recovered from workload observation, never by
	// the ordinary admission worker. The checkpoint tells this claimant which
	// stage the dead worker had durably entered.
	ClaimRecoverableDeploymentOperation(ctx context.Context, arg ClaimRecoverableDeploymentOperationParams) (DeploymentOperation, error)
	ClearClusterJoin(ctx context.Context) (int64, error)
	ClearPlatformRegistry(ctx context.Context) error
	// Forget every saved position in a project, so the next render lays it out
	// again from the dependencies.
	ClearProjectPositions(ctx context.Context, arg ClearProjectPositionsParams) (int64, error)
	// Marking consumed and reading the user are one statement, so there is no
	// window between the two in which a second request can also find the link
	// unconsumed. Expiry is in the same condition for the same reason: a link that
	// has just expired must fail here rather than in whatever checks it later.
	ConsumeMagicLink(ctx context.Context, tokenHash []byte) (User, error)
	CountApps(ctx context.Context, ownerID string) (int64, error)
	CountOwnersOfTeam(ctx context.Context, ownerID string) (int64, error)
	CountPendingReleaseBackfills(ctx context.Context) (int64, error)
	CreateApp(ctx context.Context, arg CreateAppParams) (App, error)
	CreateAppLink(ctx context.Context, arg CreateAppLinkParams) error
	// Release snapshots are owner-scoped at every read and write, like every
	// other resource. There is intentionally no update query: a release is a fact
	// about a past deployment, not editable configuration.
	CreateAppRelease(ctx context.Context, arg CreateAppReleaseParams) (AppRelease, error)
	// Builds. Owner-scoped in the row rather than through the deployment, because
	// the log is readable output and the scoping has to be checkable in the query
	// that reads it.
	CreateBuild(ctx context.Context, arg CreateBuildParams) (Build, error)
	// ---------------------------------------------------------- custom domains
	// Claims a hostname for an app, unverified.
	//
	// Deliberately not an upsert on host: the global unique index is what makes two
	// teams claiming one name an error rather than a silent transfer, and papering
	// over it here is exactly how a domain gets stolen.
	//
	// next_check_at defaults to now(), so a claim is picked up by the checker on its
	// next pass rather than waiting for somebody to press a button. That is the
	// whole difference between this and what it replaced.
	CreateCustomDomain(ctx context.Context, arg CreateCustomDomainParams) (Domain, error)
	CreateDeployment(ctx context.Context, arg CreateDeploymentParams) (Deployment, error)
	CreateDeploymentOperation(ctx context.Context, arg CreateDeploymentOperationParams) (DeploymentOperation, error)
	CreateMagicLink(ctx context.Context, arg CreateMagicLinkParams) (MagicLink, error)
	// Every query filters by owner_id, for the reason apps.sql gives: the scope is
	// the check, not a duplicate of one.
	CreateProject(ctx context.Context, arg CreateProjectParams) (Project, error)
	CreateSession(ctx context.Context, arg CreateSessionParams) (Session, error)
	CreateTeam(ctx context.Context, arg CreateTeamParams) (Team, error)
	// Every query filters by owner_id.
	//
	// This is not defensive duplication of an application-level check — it is the
	// check. A handler that forgets to scope produces no rows here rather than
	// another owner's data, and sqlc makes the parameter impossible to omit
	// because the generated signature requires it.
	CreateTeamRow(ctx context.Context, arg CreateTeamRowParams) (Team, error)
	// Storage attached to an app. Scoped by owner_id like every other resource
	// query: a handler that forgets to scope produces no rows here rather than
	// another team's storage.
	CreateVolume(ctx context.Context, arg CreateVolumeParams) (Volume, error)
	CreateVolumeAndBump(ctx context.Context, arg CreateVolumeAndBumpParams) (CreateVolumeAndBumpRow, error)
	DeleteApp(ctx context.Context, arg DeleteAppParams) error
	DeleteAppHook(ctx context.Context, arg DeleteAppHookParams) (int64, error)
	DeleteCustomDomain(ctx context.Context, arg DeleteCustomDomainParams) (int64, error)
	DeleteExpiredInvitations(ctx context.Context) error
	DeleteExpiredMagicLinks(ctx context.Context) error
	DeleteExpiredSessions(ctx context.Context) error
	// Scoped by owner_id as well as id: an id from another team must not be
	// reachable by someone who happens to administer this one.
	DeleteInvitation(ctx context.Context, arg DeleteInvitationParams) (int64, error)
	// Withdraws the invitations somebody issued, used when they lose the authority
	// to have issued them. An administrator who leaves must not keep a live token
	// for an address they control.
	DeleteInvitationsByInviter(ctx context.Context, arg DeleteInvitationsByInviterParams) error
	// Releases an app's platform hostname.
	//
	// Deleting rather than leaving the row is what makes the feature reversible:
	// hostnames are globally unique, so a retired row keeps the name reserved
	// against every other app forever.
	DeleteManagedDomain(ctx context.Context, appID uuid.UUID) error
	DeleteMembership(ctx context.Context, arg DeleteMembershipParams) error
	// Ends every session but the one asking.
	//
	// DeleteSessionsForUser cannot serve here: it takes out the caller's own, so
	// changing a password from the account page would sign the person out of the
	// browser they are looking at, and they would read that as the change having
	// failed rather than having worked.
	// The surviving session is named `keep` rather than `except`, which is a
	// reserved word the query parser will not take as an identifier.
	DeleteOtherSessionsForUser(ctx context.Context, arg DeleteOtherSessionsForUserParams) error
	// execrows so that "there was nothing to remove" is distinguishable from
	// success. Reporting a credential withdrawn when none existed is how somebody
	// stops looking for the one that is still there.
	DeletePassword(ctx context.Context, userID uuid.UUID) (int64, error)
	DeleteProject(ctx context.Context, arg DeleteProjectParams) (int64, error)
	DeleteSessionByHash(ctx context.Context, tokenHash []byte) error
	DeleteSessionsForUser(ctx context.Context, userID uuid.UUID) error
	DeleteVariable(ctx context.Context, arg DeleteVariableParams) (int64, error)
	DeleteVariableAndBump(ctx context.Context, arg DeleteVariableAndBumpParams) (DeleteVariableAndBumpRow, error)
	DeleteVolume(ctx context.Context, arg DeleteVolumeParams) (int64, error)
	DeleteVolumeAndBump(ctx context.Context, arg DeleteVolumeAndBumpParams) (DeleteVolumeAndBumpRow, error)
	// Deploys per day and outcome, for the overview chart.
	//
	// Counted in the database rather than by reading rows and tallying them in Go:
	// a busy month is thousands of deployments, and none of them are wanted here
	// except as a number.
	//
	// Days with no deploys are absent from this result. The caller fills them in;
	// see app.DeployActivity for why that cannot be skipped.
	DeployActivity(ctx context.Context, arg DeployActivityParams) ([]DeployActivityRow, error)
	FailQueuedBuildOperation(ctx context.Context, arg FailQueuedBuildOperationParams) (int64, error)
	FinishBuild(ctx context.Context, arg FinishBuildParams) (Build, error)
	FinishDeployment(ctx context.Context, arg FinishDeploymentParams) (Deployment, error)
	FinishDeploymentOperation(ctx context.Context, arg FinishDeploymentOperationParams) (int64, error)
	GetApp(ctx context.Context, arg GetAppParams) (App, error)
	GetAppByID(ctx context.Context, arg GetAppByIDParams) (App, error)
	GetAppForReleaseBackfill(ctx context.Context, arg GetAppForReleaseBackfillParams) (App, error)
	GetAppHook(ctx context.Context, arg GetAppHookParams) (AppHook, error)
	GetAppRelease(ctx context.Context, arg GetAppReleaseParams) (AppRelease, error)
	GetBuild(ctx context.Context, arg GetBuildParams) (Build, error)
	GetBuildForDeployment(ctx context.Context, arg GetBuildForDeploymentParams) (Build, error)
	GetBuildRecoveryOperation(ctx context.Context, arg GetBuildRecoveryOperationParams) (DeploymentOperation, error)
	// The join settings are install-wide, so unlike every other query here these
	// take no owner_id. See the 00012 migration for why.
	GetClusterJoin(ctx context.Context) (ClusterJoin, error)
	GetCustomDomain(ctx context.Context, arg GetCustomDomainParams) (Domain, error)
	GetDeployment(ctx context.Context, arg GetDeploymentParams) (Deployment, error)
	GetDeploymentOperation(ctx context.Context, arg GetDeploymentOperationParams) (DeploymentOperation, error)
	GetDeploymentOperationByDeployment(ctx context.Context, arg GetDeploymentOperationByDeploymentParams) (DeploymentOperation, error)
	// By app id alone: a delivery carries no session and no owner. The signature,
	// checked against the secret read here, is what authorises it.
	GetHookForDelivery(ctx context.Context, appID uuid.UUID) (GetHookForDeliveryRow, error)
	// Reads an invitation without spending it, so a signed-out visitor can be sent
	// a sign-in link to the address it names. token_hash is not among the columns,
	// for the same reason it is absent from ListPendingInvitations.
	GetInvitationByHash(ctx context.Context, tokenHash []byte) (GetInvitationByHashRow, error)
	GetLatestSuccessfulBuildForApp(ctx context.Context, arg GetLatestSuccessfulBuildForAppParams) (Build, error)
	// The live operation is the only candidate allowed to displace an app's
	// active release. Steady-state convergence must stand down while one exists.
	GetLiveDeploymentOperationForApp(ctx context.Context, arg GetLiveDeploymentOperationForAppParams) (DeploymentOperation, error)
	// ---------------------------------------------------------------------------
	// Step-up and session revocation
	// ---------------------------------------------------------------------------
	// Reads a session that is still alive, for a caller about to change how the
	// account it belongs to can be signed in to.
	//
	// GetSession has no expiry filter, so an expired row comes back from it looking
	// valid. GetSessionByHash filters expiry in SQL precisely so that a caller
	// cannot forget, and this is the caller that would: a session that ended an hour
	// ago must not be able to set a password. FOR UPDATE serialises two tabs
	// changing one at the same moment.
	//
	// Columns are named because the row exists to answer three questions — whose it
	// is, how recently it was proved, whether it is still alive — and starring it
	// would hand the caller a struct that grows every time `sessions` does.
	GetLiveSession(ctx context.Context, id uuid.UUID) (GetLiveSessionRow, error)
	GetManagedDomain(ctx context.Context, appID uuid.UUID) (Domain, error)
	GetMembership(ctx context.Context, arg GetMembershipParams) (Membership, error)
	// ---------------------------------------------------------------------------
	// Passwords
	//
	// Every query below either names its columns or returns an id. `secret` appears
	// in two of them — the sign-in lookup and the locking read that a change or a
	// removal goes through — and both row types are consumed inside the account
	// package and never returned from it. That is the whole storage rule, and it is
	// easier to keep by making the leak impossible than by remembering not to write
	// it. Anything added here that does not need the hash must not select it.
	// ---------------------------------------------------------------------------
	// The only query that returns a hash, and the only one that ever should.
	//
	// The join is INNER, so an unknown address and a known address with no password
	// come back as the same pgx.ErrNoRows. There is no branch in Go that could tell
	// them apart, which is what makes the equal-cost verify in AuthenticatePassword
	// structural rather than something a caller has to remember to write.
	//
	// The user's columns are named rather than starred, so this cannot quietly start
	// returning whatever is added to `users` next.
	GetPasswordByEmail(ctx context.Context, email string) (GetPasswordByEmailRow, error)
	// Install-wide DNS settings. No owner_id, for the reason cluster_join has
	// none: they configure one controller shared by every team.
	GetPlatformDNS(ctx context.Context) (PlatformDn, error)
	// The install's image registry. No owner_id, for the reason platform_dns has
	// none: one registry serves every team's builds.
	GetPlatformRegistry(ctx context.Context) (PlatformRegistry, error)
	GetProjectByID(ctx context.Context, arg GetProjectByIDParams) (Project, error)
	GetProjectBySlug(ctx context.Context, arg GetProjectBySlugParams) (Project, error)
	GetReleaseBackfillState(ctx context.Context, arg GetReleaseBackfillStateParams) (AppReleaseBackfill, error)
	// Expiry is filtered here for the reason GetSessionByHash gives: so that an
	// expired row can never be treated as valid by a caller that forgets to check.
	// This one used to be the caller that forgot. It was not reachable with a dead
	// session — the route gate resolves a live one first — but "not reachable"
	// is a property of today's routing rather than of this query, and the whole
	// point of putting the condition in SQL is that it does not depend on that.
	GetSession(ctx context.Context, id uuid.UUID) (Session, error)
	// The team is joined in because the request that carries this cookie needs the
	// owner it resolves to, and a second round trip per request buys nothing. The
	// join is LEFT: a session whose team was deleted still exists, it just has no
	// owner to act as.
	//
	// Expiry is filtered in SQL rather than in Go so that an expired row can never
	// be treated as valid by a caller that forgets to check.
	// Resolves a session only while the membership behind it still exists.
	//
	// The join to memberships is the security boundary, not decoration. Revoking
	// sessions imperatively when someone is removed would work only for the call
	// sites that remember to do it, and would still miss membership lost by
	// cascade. Joining makes a departed member's cookie stop resolving the instant
	// the row goes, by whatever route it went.
	//
	// INNER JOIN on teams too: a session with no active team resolves to no owner,
	// and returning a row the caller must then remember to reject is how that
	// check gets skipped.
	GetSessionByHash(ctx context.Context, tokenHash []byte) (GetSessionByHashRow, error)
	GetSuccessfulBuildForImage(ctx context.Context, arg GetSuccessfulBuildForImageParams) (Build, error)
	GetTeam(ctx context.Context, id string) (Team, error)
	GetTeamRow(ctx context.Context, id string) (Team, error)
	GetUserByEmail(ctx context.Context, email string) (User, error)
	GetUserByID(ctx context.Context, id uuid.UUID) (User, error)
	GetVariable(ctx context.Context, arg GetVariableParams) (Variable, error)
	GetVolume(ctx context.Context, arg GetVolumeParams) (Volume, error)
	// Expansion only, enforced in the WHERE clause rather than by reading the row
	// and comparing in Go: a check the caller performs is one a caller can skip,
	// and Kubernetes cannot shrink a claim afterwards to undo it.
	GrowVolume(ctx context.Context, arg GrowVolumeParams) (int64, error)
	GrowVolumeAndBump(ctx context.Context, arg GrowVolumeAndBumpParams) (GrowVolumeAndBumpRow, error)
	HasPassword(ctx context.Context, userID uuid.UUID) (bool, error)
	HasVerifiedDomainsForApp(ctx context.Context, arg HasVerifiedDomainsForAppParams) (bool, error)
	IncrementAppConfigVersion(ctx context.Context, arg IncrementAppConfigVersionParams) (int64, error)
	// The platform CNAME target is an install-wide live overlay, but it only
	// renders into apps that explicitly opted into CNAME routing.
	IncrementCNAMEAppConfigVersions(ctx context.Context) error
	// Registry credentials are a live overlay for every Git-built image. They are
	// install-wide, so one settings mutation invalidates each Git app exactly
	// once without manufacturing release history.
	IncrementGitAppConfigVersions(ctx context.Context) error
	// Pushes waiting behind a deploy that has since ended. An app whose deploy is
	// still live is left out, rather than tried and refused every half second.
	ListAdmissiblePushes(ctx context.Context, resultLimit int32) ([]ListAdmissiblePushesRow, error)
	ListAppLinks(ctx context.Context, ownerID string) ([]ListAppLinksRow, error)
	ListAppReleases(ctx context.Context, arg ListAppReleasesParams) ([]AppRelease, error)
	ListApps(ctx context.Context, ownerID string) ([]App, error)
	// Apps whose database pointer names the workload the cluster must converge to.
	// This is intentionally install-scoped: the reconciler acts from stored
	// ownership rather than from an authenticated request.
	ListAppsForReconciliation(ctx context.Context) ([]App, error)
	ListAppsInProject(ctx context.Context, arg ListAppsInProjectParams) ([]App, error)
	// Every app, with how its most recent deployment ended.
	//
	// A failed deploy leaves the previous workload running, so the app's live
	// status stays green and nothing in a list of apps says the last attempt to
	// change it did not take. That is exactly the deploy somebody needs to find,
	// and until this query existed the only way to find it was to open each app.
	//
	// LATERAL rather than a window function or a join on max(started_at): one index
	// lookup per app, and it reads as what it is — the latest row for this app.
	ListAppsWithLastDeploy(ctx context.Context, ownerID string) ([]ListAppsWithLastDeployRow, error)
	// Apps that predate projects, or whose project was deleted.
	//
	// Returned separately rather than folded into a default project by the query,
	// because assigning one is a write and a read should not have side effects
	// that a caller cannot see.
	ListAppsWithoutProject(ctx context.Context, ownerID string) ([]App, error)
	ListCustomDomains(ctx context.Context, arg ListCustomDomainsParams) ([]Domain, error)
	// Every custom domain on the install, worst first.
	//
	// Nothing answered "which domains are stuck" before this. A domain that is not
	// routed is the only kind anybody needs to find, so it sorts to the top.
	ListCustomDomainsForOwner(ctx context.Context, ownerID string) ([]ListCustomDomainsForOwnerRow, error)
	ListDeploymentOperations(ctx context.Context, arg ListDeploymentOperationsParams) ([]DeploymentOperation, error)
	ListDeployments(ctx context.Context, arg ListDeploymentsParams) ([]Deployment, error)
	ListDomainsByApp(ctx context.Context, appID uuid.UUID) ([]Domain, error)
	ListMembersOfTeam(ctx context.Context, ownerID string) ([]ListMembersOfTeamRow, error)
	ListMembershipsForUser(ctx context.Context, userID uuid.UUID) ([]ListMembershipsForUserRow, error)
	// The columns are named rather than starred, and token_hash is not among them.
	// This list feeds the team page, and a hash that never leaves the database
	// cannot be rendered into it by a template that innocently prints a struct.
	ListPendingInvitations(ctx context.Context, ownerID string) ([]ListPendingInvitationsRow, error)
	ListPendingReleaseBackfills(ctx context.Context, resultLimit int32) ([]ListPendingReleaseBackfillsRow, error)
	ListProjects(ctx context.Context, ownerID string) ([]ListProjectsRow, error)
	// Joined to apps so the activity feed can name the workload without a second
	// round trip per row. The join is on app_id AND owner_id: joining on app_id
	// alone would be correct today and wrong the moment more than one owner exists.
	ListRecentDeployments(ctx context.Context, arg ListRecentDeploymentsParams) ([]ListRecentDeploymentsRow, error)
	// Every build still claiming to run, oldest first. Not owner-scoped: this
	// feeds the reconciler, which is the platform settling its own records rather
	// than a team reading theirs.
	ListRunningBuilds(ctx context.Context) ([]Build, error)
	ListVariablesForApp(ctx context.Context, appID uuid.UUID) ([]Variable, error)
	ListVolumesForApp(ctx context.Context, appID uuid.UUID) ([]Volume, error)
	// Claim counting and selection must share this transaction-wide lock. Row
	// locks alone protect candidates, not the cluster-wide count: two connections
	// can otherwise lock different rows after both observed one free build slot.
	LockDeploymentAdmission(ctx context.Context) error
	// Reads and locks the person's password, for a caller inside a transaction that
	// is about to replace or remove it.
	//
	// Returns the secret as well as the id because one row answers two questions the
	// caller needs at the same moment: whether this is an add or a replace, since
	// only a replace revokes the person's other sessions, and whether a current
	// password offered as proof of recent authentication is the right one. Asking
	// twice would be two round trips and one more chance for the second to read a
	// different row than the first.
	//
	// FOR UPDATE is what serialises two tabs. Read outside the transaction this
	// would be check-then-act: both see no password, both insert, one upserts over
	// the other, and neither revokes.
	LockPassword(ctx context.Context, userID uuid.UUID) (LockPasswordRow, error)
	// A role change reads the owner count and then writes; taking the team row
	// first serialises those pairs, so two concurrent demotions cannot both see
	// two owners and both proceed.
	LockTeam(ctx context.Context, id string) (Team, error)
	// Moves a proven domain to routed, once the Ingress actually carries it.
	//
	// Guarded on the state it is coming from, so a check that has since found drift
	// is not overwritten by an apply that started before it.
	MarkDomainRouted(ctx context.Context, id uuid.UUID) (int64, error)
	MarkHookPending(ctx context.Context, arg MarkHookPendingParams) error
	// A verified domain becomes routed only after the app reconciler has observed
	// or produced the matching workload convergence key. This app-scoped form
	// closes the asynchronous handoff from the DNS checker.
	MarkVerifiedDomainsRoutedForApp(ctx context.Context, arg MarkVerifiedDomainsRoutedForAppParams) (int64, error)
	MoveAppsWithoutProject(ctx context.Context, arg MoveAppsWithoutProjectParams) (int64, error)
	NormalizeLegacyDeploymentStatuses(ctx context.Context) (int64, error)
	ReclaimExpiredDeploymentOperations(ctx context.Context) ([]DeploymentOperation, error)
	// Records what a check saw.
	//
	// Not scoped by owner, and deliberately: the background checker works through
	// every install's rows by id, having already claimed them below. Owner scoping
	// protects a request that names a row; this is not one. Every path that reaches
	// here from a request goes through GetCustomDomain first, which is scoped.
	//
	// The schedule arrives already computed rather than being worked out in SQL, so
	// the backoff can be tested against an injected clock instead of against now().
	RecordDomainCheck(ctx context.Context, arg RecordDomainCheckParams) (int64, error)
	RecordHookDelivery(ctx context.Context, arg RecordHookDeliveryParams) error
	RecoverBuiltDeploymentOperation(ctx context.Context, arg RecoverBuiltDeploymentOperationParams) (DeploymentOperation, error)
	// A cluster outage is not a deployment failure. Give observation recovery
	// back to the queue without changing its checkpoint or verification budget.
	ReleaseRecoverableDeploymentOperation(ctx context.Context, arg ReleaseRecoverableDeploymentOperationParams) (int64, error)
	RenameProject(ctx context.Context, arg RenameProjectParams) (Project, error)
	RenewDeploymentOperationLease(ctx context.Context, arg RenewDeploymentOperationLeaseParams) (int64, error)
	ReplaceAppLinks(ctx context.Context, arg ReplaceAppLinksParams) error
	// Brings a domain's next check forward. What the "Check now" button does.
	//
	// It resets the attempt count as well, because somebody pressing it is telling
	// us the situation changed — and a domain that had backed off to a fifteen
	// minute interval should not go straight back to one.
	RequestDomainCheck(ctx context.Context, arg RequestDomainCheckParams) (int64, error)
	// Rollback makes the app's desired state the release's again, so the next edit
	// builds on what is running rather than quietly rolling forward to what was
	// replaced. Only release-owned fields: hostnames, networking, storage and the
	// repository are current state and stay as they are. The uid is a build's
	// discovery for a Git app, and belongs to the image being restored.
	RestoreAppFromRelease(ctx context.Context, arg RestoreAppFromReleaseParams) (App, error)
	// Hostnames that may actually be routed to.
	//
	// A managed host is routable because the platform issued it; a custom one only
	// once it is proven. This is the query the Ingress is built from, so the gate
	// lives here rather than in a caller that might forget it.
	RoutableHostsForApp(ctx context.Context, appID uuid.UUID) ([]string, error)
	SetActiveRelease(ctx context.Context, arg SetActiveReleaseParams) (int64, error)
	SetAppHealth(ctx context.Context, arg SetAppHealthParams) (App, error)
	// The image a build produced. Separate from UpdateApp because a build sets
	// only this: the replicas and limits a person configured are not a build's to
	// overwrite, and passing them through would make every build a chance to.
	SetAppImage(ctx context.Context, arg SetAppImageParams) (App, error)
	SetAppNetworking(ctx context.Context, arg SetAppNetworkingParams) (int64, error)
	SetAppPosition(ctx context.Context, arg SetAppPositionParams) (int64, error)
	SetAppProject(ctx context.Context, arg SetAppProjectParams) (int64, error)
	SetAppReplicas(ctx context.Context, arg SetAppReplicasParams) (App, error)
	// Recorded by a build, which is the only thing that can discover it. The
	// image update owns the build operation's single config_version increment.
	SetAppRunAsUser(ctx context.Context, arg SetAppRunAsUserParams) error
	SetBuildJob(ctx context.Context, arg SetBuildJobParams) error
	SetClaimedOperationRelease(ctx context.Context, arg SetClaimedOperationReleaseParams) (int64, error)
	SetClusterJoin(ctx context.Context, arg SetClusterJoinParams) (ClusterJoin, error)
	SetDeploymentRelease(ctx context.Context, arg SetDeploymentReleaseParams) (int64, error)
	SetPlatformDNS(ctx context.Context, arg SetPlatformDNSParams) (PlatformDn, error)
	SetPlatformRegistry(ctx context.Context, arg SetPlatformRegistryParams) (PlatformRegistry, error)
	SetReleaseBackfillState(ctx context.Context, arg SetReleaseBackfillStateParams) (int64, error)
	SetSessionTeam(ctx context.Context, arg SetSessionTeamParams) error
	// Cleared in the same transaction that admits the deploy, so a push is either
	// still waiting or has a deployment — never neither.
	TakeHookPending(ctx context.Context, appID uuid.UUID) (int64, error)
	// Opens the step-up window. Scoped by expiry so an expired session cannot be
	// revived into a recently-authenticated one; execrows so the caller can tell
	// that it was not.
	TouchSessionAuthentication(ctx context.Context, id uuid.UUID) (int64, error)
	TransitionDeploymentOperation(ctx context.Context, arg TransitionDeploymentOperationParams) (DeploymentOperation, error)
	// Everything about an app a person is allowed to change after creating it.
	//
	// Deliberately not replicas: scaling has its own query because it has its own
	// rule about storage, and folding it in here would make every settings save a
	// chance to silently reset a scale somebody had chosen.
	//
	// Nor the health probe, the networking toggles or run_as_user — each of those
	// already has a query shaped to what it means, and this one exists for the
	// fields that had no way to be changed at all.
	UpdateApp(ctx context.Context, arg UpdateAppParams) (App, error)
	// Rehash-on-login, for a stored hash made at a cost this build has moved past.
	// Best effort and never on the critical path: the sign-in has already succeeded
	// by the time this runs.
	//
	// Conditional on the old value, which makes it a compare-and-swap. Between the
	// verify and this update the person may have changed their password in another
	// tab; without the condition, the rehash of the OLD password would overwrite the
	// new one and lock them out of an account they had just secured. With it, a
	// stale rehash matches no rows and nothing happens.
	UpdatePasswordSecret(ctx context.Context, arg UpdatePasswordSecretParams) (int64, error)
	// Deploy-on-push webhooks. See migration 00028.
	// A new secret replaces the old one outright, so regenerating is also how a
	// leaked secret is revoked.
	UpsertAppHook(ctx context.Context, arg UpsertAppHookParams) (AppHook, error)
	// Re-inviting replaces the pending invitation rather than adding a second one,
	// so the token in the older mail stops working. Two live tokens for one address
	// would mean revoking the invitation on screen leaves the other one usable.
	UpsertInvitation(ctx context.Context, arg UpsertInvitationParams) (uuid.UUID, error)
	// Platform-issued hostnames. Custom domains get their own queries when that
	// sub-project lands; keeping them in one file rather than in apps.sql is so
	// that apps.sql stays about apps.
	// Issues or reissues the platform hostname for an app.
	//
	// The conflict target is the partial index, so a second call for the same app
	// moves its hostname rather than adding one. A collision on the global host
	// index is a different conflict and is deliberately left to raise, because two
	// apps claiming one hostname is a real error, not something to paper over.
	//
	// The state is 'routed' because a name the platform issued needs no proof of
	// ownership; requiring proof would mean inventing a verification step for a
	// name we already control. verified follows from it and is not written here —
	// it is generated from state, so that the routing gate and the state on screen
	// cannot disagree.
	UpsertManagedDomain(ctx context.Context, arg UpsertManagedDomainParams) (Domain, error)
	UpsertMembership(ctx context.Context, arg UpsertMembershipParams) (Membership, error)
	// Returns an id and not the row. RETURNING * here would put the hash into a Go
	// struct for no reason at all, which is the shortest route to it being logged.
	UpsertPassword(ctx context.Context, arg UpsertPasswordParams) (uuid.UUID, error)
	// Users, sessions and credentials carry no owner_id: a person exists before they
	// belong to any team, and what proves who they are is not a fact about a tenant.
	// Memberships and invitations do, and stay scoped by it like everything else.
	UpsertUser(ctx context.Context, arg UpsertUserParams) (User, error)
	// Environment variables, one row each so a secret can be sealed while its
	// neighbour stays readable.
	// Upsert rather than insert: setting a variable that already exists is what a
	// person means by editing one, and a separate update path would need the
	// caller to know which case they are in.
	UpsertVariable(ctx context.Context, arg UpsertVariableParams) (Variable, error)
	UpsertVariableAndBump(ctx context.Context, arg UpsertVariableAndBumpParams) (UpsertVariableAndBumpRow, error)
}

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

type RecordDomainCheckParams struct {
	State         string
	Observed      string
	LastError     string
	CheckedAt     pgtype.Timestamptz
	NextCheckAt   time.Time
	CheckAttempts int32
	ID            uuid.UUID
}

type RecordHookDeliveryParams struct {
	Result string
	AppID  uuid.UUID
}

type RecoverBuiltDeploymentOperationParams struct {
	ReleaseID     pgtype.UUID
	LeaseDuration pgtype.Interval
	OwnerID       string
	DeploymentID  uuid.UUID
}

type ReleaseRecoverableDeploymentOperationParams struct {
	OwnerID        string
	ID             uuid.UUID
	ExpectedStatus string
	ClaimToken     pgtype.UUID
}

type RenameProjectParams struct {
	OwnerID string
	ID      uuid.UUID
	Name    string
}

type RenewDeploymentOperationLeaseParams struct {
	LeaseDuration pgtype.Interval
	OwnerID       string
	ID            uuid.UUID
	ClaimToken    pgtype.UUID
}

type ReplaceAppLinksParams struct {
	FromAppID uuid.UUID
	ViaKey    string
}

type RequestDomainCheckParams struct {
	Due     time.Time
	OwnerID string
	ID      uuid.UUID
}

type RestoreAppFromReleaseParams struct {
	OwnerID   string
	AppID     uuid.UUID
	ReleaseID uuid.UUID
}

type Session struct {
	ID              uuid.UUID
	UserID          uuid.UUID
	TokenHash       []byte
	ActiveTeamID    *string
	UserAgent       string
	Ip              string
	ExpiresAt       time.Time
	CreatedAt       time.Time
	AuthenticatedAt time.Time
}

type SetActiveReleaseParams struct {
	ReleaseID pgtype.UUID
	OwnerID   string
	AppID     uuid.UUID
}

type SetAppHealthParams struct {
	HealthPath     string
	HealthLiveness bool
	OwnerID        string
	ID             uuid.UUID
}

type SetAppImageParams struct {
	OwnerID string
	ID      uuid.UUID
	Image   string
}

type SetAppNetworkingParams struct {
	HttpsOnly bool
	CnameOnly bool
	OwnerID   string
	Name      string
}

type SetAppPositionParams struct {
	OwnerID string
	Name    string
	CanvasX *int32
	CanvasY *int32
}

type SetAppProjectParams struct {
	OwnerID   string
	ID        uuid.UUID
	ProjectID pgtype.UUID
}

type SetAppReplicasParams struct {
	OwnerID  string
	ID       uuid.UUID
	Replicas int32
}

type SetAppRunAsUserParams struct {
	RunAsUser int64
	OwnerID   string
	ID        uuid.UUID
}

type SetBuildJobParams struct {
	JobName string
	ID      uuid.UUID
}

type SetClaimedOperationReleaseParams struct {
	ReleaseID      pgtype.UUID
	OwnerID        string
	ID             uuid.UUID
	ExpectedStatus string
	ClaimToken     pgtype.UUID
}

type SetClusterJoinParams struct {
	ServerUrl   string
	TokenSealed []byte
	UpdatedBy   pgtype.UUID
}

type SetDeploymentReleaseParams struct {
	ReleaseID    pgtype.UUID
	OwnerID      string
	DeploymentID uuid.UUID
}

type SetPlatformDNSParams struct {
	CnameTarget string
	TxtPrefix   string
}

type SetPlatformRegistryParams struct {
	Host           string
	Repository     string
	Username       string
	PasswordSealed []byte
	Insecure       bool
	UpdatedBy      pgtype.UUID
}

type SetReleaseBackfillStateParams struct {
	State     string
	LastError string
	OwnerID   string
	AppID     uuid.UUID
}

type SetSessionTeamParams struct {
	ActiveTeamID *string
	ID           uuid.UUID
}

type Team struct {
	ID          string
	DisplayName string
	Email       string
	CreatedAt   time.Time
	UpdatedAt   time.Time
}

type TransitionDeploymentOperationParams struct {
	NextStatus     string
	OwnerID        string
	ID             uuid.UUID
	ExpectedStatus string
	ClaimToken     pgtype.UUID
}

type UpdateAppParams struct {
	Image         string
	Port          int32
	CpuRequest    string
	CpuLimit      string
	MemoryRequest string
	MemoryLimit   string
	Internal      bool
	RepoUrl       string
	RepoBranch    string
	RepoSubdir    string
	OwnerID       string
	ID            uuid.UUID
}

type UpdatePasswordSecretParams struct {
	Secret    string
	UserID    uuid.UUID
	OldSecret string
}

type UpsertAppHookParams struct {
	AppID   uuid.UUID
	OwnerID string
	Secret  []byte
}

type UpsertInvitationParams struct {
	OwnerID   string
	Email     string
	Role      string
	TokenHash []byte
	InvitedBy uuid.UUID
	ExpiresAt time.Time
}

type UpsertManagedDomainParams struct {
	OwnerID string
	AppID   uuid.UUID
	Host    string
	Tls     bool
}

type UpsertMembershipParams struct {
	UserID  uuid.UUID
	OwnerID string
	Role    string
}

type UpsertPasswordParams struct {
	UserID uuid.UUID
	Secret string
}

type UpsertUserParams struct {
	Email       string
	DisplayName string
}

type UpsertVariableAndBumpParams struct {
	OwnerID string
	AppID   uuid.UUID
	Key     string
	Value   string
	Sealed  []byte
	Secret  bool
}

type UpsertVariableAndBumpRow struct {
	ID            uuid.UUID
	OwnerID       string
	AppID         uuid.UUID
	Key           string
	Value         string
	Sealed        []byte
	Secret        bool
	CreatedAt     time.Time
	UpdatedAt     time.Time
	ConfigVersion int64
}

type UpsertVariableParams struct {
	OwnerID string
	AppID   uuid.UUID
	Key     string
	Value   string
	Sealed  []byte
	Secret  bool
}

type User struct {
	ID            uuid.UUID
	Email         string
	DisplayName   string
	TotpSecret    *string
	TotpConfirmed bool
	CreatedAt     time.Time
	UpdatedAt     time.Time
}

type UserCredential struct {
	ID        uuid.UUID
	UserID    uuid.UUID
	Kind      string
	Secret    string
	CreatedAt time.Time
	UpdatedAt time.Time
}

type Variable struct {
	ID        uuid.UUID
	OwnerID   string
	AppID     uuid.UUID
	Key       string
	Value     string
	Sealed    []byte
	Secret    bool
	CreatedAt time.Time
	UpdatedAt time.Time
}

type Volume struct {
	ID        uuid.UUID
	OwnerID   string
	AppID     uuid.UUID
	Name      string
	MountPath string
	SizeBytes int64
	Class     string
	CreatedAt time.Time
	UpdatedAt time.Time
}