forges

type Fixture struct {
	ForgeRoot *ForgeRoot
	Forge     *Forge

	Asset       *ForgeAsset
	AssetFormat *format.ReleaseAsset

	PullRequestComment       *ForgePullRequestComment
	PullRequestCommentFormat *format.Comment

	IssueComment       *ForgeIssueComment
	IssueCommentFormat *format.Comment

	CommentReaction       *ForgeCommentReaction
	CommentReactionFormat *format.Reaction

	IssueReaction       *ForgeIssueReaction
	IssueReactionFormat *format.Reaction

	Issue       *ForgeIssue
	IssueFormat *format.Issue

	Label       *ForgeLabel
	LabelFormat *format.Label

	Milestone       *ForgeMilestone
	MilestoneFormat *format.Milestone

	Project       *ForgeProject
	ProjectFormat *format.Project

	PullRequest       *ForgePullRequest
	PullRequestFormat *format.PullRequest

	Release       *ForgeRelease
	ReleaseFormat *format.Release

	Repository              *ForgeRepository
	RepositoryFormat        *format.Repository
	FixtureRepositoryFormat *format.Repository
	RepositoryHelper        *tests.RepositoryTestHelper

	Review       *ForgeReview
	ReviewFormat *format.Review

	Topic       *ForgeTopic
	TopicFormat *format.Topic

	UserIsAdmin bool
	User        *ForgeUser
	UserFormat  *format.User
	// contains filtered or unexported fields
}

type FixtureForgeFactory struct {
	Fun           FixtureForgeFactoryFun
	AdminRequired bool
}

type FixtureForgeFactoryFun func(t tests.TestingT, logger *config_types.Logger, user *format.User, tmpDir string) *ForgeRoot

type Forge struct {
	ForgeElement[common.ContainerElement, *common.ContainerElement]
	Users *ForgeUsers
}

type ForgeAsset struct {
	ForgeElement[ForgeRelease, *ForgeRelease]
}

type ForgeAssets struct {
	ForgeContainer[ForgeAsset, ForgeRelease, format.ReleaseAsset, *ForgeAsset, *ForgeRelease, *format.ReleaseAsset]
}

type ForgeCommentReaction struct {
	ForgeElement[ForgeIssueComment, *ForgeIssueComment]
}

type ForgeCommentReactions struct {
	ForgeContainer[ForgeCommentReaction, ForgeIssueComment, format.Reaction, *ForgeCommentReaction, *ForgeIssueComment, *format.Reaction]
}

type ForgeContainer[
	ForgeElement any,
	Parent any,
	Format any,
	ForgeElementPtr ForgeElementConstraint[ForgeElement, ParentPtr],
	ParentPtr ParentConstraint[Parent],
	FormatPtr FormatConstraint[Format],
] struct {
	common.Container
}

type ForgeElement[
	Parent any,
	ParentPtr ParentConstraint[Parent],
] struct {
	common.ContainerElement
}

type ForgeElementConstraint[ForgeElement any, ParentPtr any] interface {
	*ForgeElement
	common.ContainerElementInterface
	Init(common.NodeInterface, *ForgeRoot, ParentPtr, common.ProviderInterface)
}

type ForgeIssue struct {
	ForgeElement[ForgeProject, *ForgeProject]
	Comments  *ForgeIssueComments
	Reactions *ForgeIssueReactions
}

type ForgeIssueComment struct {
	ForgeElement[ForgeIssue, *ForgeIssue]
	Reactions *ForgeCommentReactions
}

type ForgeIssueComments struct {
	ForgeContainer[ForgeIssueComment, ForgeIssue, format.Comment, *ForgeIssueComment, *ForgeIssue, *format.Comment]
}

type ForgeIssueReaction struct {
	ForgeElement[ForgeIssue, *ForgeIssue]
}

type ForgeIssueReactions struct {
	ForgeContainer[ForgeIssueReaction, ForgeIssue, format.Reaction, *ForgeIssueReaction, *ForgeIssue, *format.Reaction]
}

type ForgeIssues struct {
	ForgeContainer[ForgeIssue, ForgeProject, format.Issue, *ForgeIssue, *ForgeProject, *format.Issue]
}

type ForgeLabel struct {
	ForgeElement[ForgeProject, *ForgeProject]
}

type ForgeLabels struct {
	ForgeContainer[ForgeLabel, ForgeProject, format.Label, *ForgeLabel, *ForgeProject, *format.Label]
}

type ForgeMilestone struct {
	ForgeElement[ForgeProject, *ForgeProject]
}

type ForgeMilestones struct {
	ForgeContainer[ForgeMilestone, ForgeProject, format.Milestone, *ForgeMilestone, *ForgeProject, *format.Milestone]
}

type ForgeProject struct {
	ForgeElement[ForgeUser, *ForgeUser]
	Issues       *ForgeIssues
	PullRequests *ForgePullRequests
	Milestones   *ForgeMilestones
	Repositories *ForgeRepositories
	Releases     *ForgeReleases
	Topics       *ForgeTopics
	Labels       *ForgeLabels
}

type ForgeProjects struct {
	ForgeContainer[ForgeProject, ForgeUser, format.Project, *ForgeProject, *ForgeUser, *format.Project]
}

type ForgePullRequest struct {
	ForgeElement[ForgeProject, *ForgeProject]
	Comments *ForgePullRequestComments
	Reviews  *ForgeReviews
}

type ForgePullRequestComment struct {
	ForgeElement[ForgePullRequest, *ForgePullRequest]
}

type ForgePullRequestComments struct {
	ForgeContainer[ForgePullRequestComment, ForgePullRequest, format.Comment, *ForgePullRequestComment, *ForgePullRequest, *format.Comment]
}

type ForgePullRequests struct {
	ForgeContainer[ForgePullRequest, ForgeProject, format.PullRequest, *ForgePullRequest, *ForgeProject, *format.PullRequest]
}

type ForgeRelease struct {
	ForgeElement[ForgeProject, *ForgeProject]
	Assets *ForgeAssets
}

type ForgeReleases struct {
	ForgeContainer[ForgeRelease, ForgeProject, format.Release, *ForgeRelease, *ForgeProject, *format.Release]
}

type ForgeRepositories struct {
	ForgeContainer[ForgeRepository, ForgeProject, format.Repository, *ForgeRepository, *ForgeProject, *format.Repository]
}

type ForgeRepository struct {
	ForgeElement[ForgeProject, *ForgeProject]
}

type ForgeReview struct {
	ForgeElement[ForgePullRequest, *ForgePullRequest]
}

type ForgeReviews struct {
	ForgeContainer[ForgeReview, ForgePullRequest, format.Review, *ForgeReview, *ForgePullRequest, *format.Review]
}

type ForgeRoot struct {
	Forge *Forge
	// contains filtered or unexported fields
}

type ForgeTopic struct {
	ForgeElement[ForgeProject, *ForgeProject]
}

type ForgeTopics struct {
	ForgeContainer[ForgeTopic, ForgeProject, format.Topic, *ForgeTopic, *ForgeProject, *format.Topic]
}

type ForgeUser struct {
	ForgeElement[Forge, *Forge]
	Projects *ForgeProjects
}

type ForgeUsers struct {
	ForgeContainer[ForgeUser, Forge, format.User, *ForgeUser, *Forge, *format.User]
}

type FormatConstraint[Format any] interface {
	*Format
	format.Interface
}

type NewForgeContainerConstraint[ForgeContainer any, ParentPtr any] interface {
	*ForgeContainer
	common.NodeInterface
	Init(common.NodeInterface, *ForgeRoot, ParentPtr, string)
}

type NewForgeElementConstraint[ForgeElement any, ParentPtr any] interface {
	*ForgeElement
	common.NodeInterface
	Init(common.NodeInterface, *ForgeRoot, ParentPtr, common.ProviderInterface)
}

type NewParentConstraint[Parent any] interface {
	*Parent
	common.NodeInterface
}

type ParentConstraint[Parent any] interface {
	*Parent
	common.NodeInterface
}