type (
	// StockPubSlice is an alias for a slice of pointers to StockPub.
	// This should generally be used opposed to []StockPub.
	StockPubSlice []*StockPub
	// StockPubHook is the signature for custom StockPub hook methods
	StockPubHook func(boil.Executor, *StockPub) error

	stockPubQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	stockPubType                 = reflect.TypeOf(&StockPub{})
	stockPubMapping              = queries.MakeStructMapping(stockPubType)
	stockPubPrimaryKeyMapping, _ = queries.BindMapping(stockPubType, stockPubMapping, stockPubPrimaryKeyColumns)
	stockPubInsertCacheMut       sync.RWMutex
	stockPubInsertCache          = make(map[string]insertCache)
	stockPubUpdateCacheMut       sync.RWMutex
	stockPubUpdateCache          = make(map[string]updateCache)
	stockPubUpsertCacheMut       sync.RWMutex
	stockPubUpsertCache          = make(map[string]insertCache)
)

var (
	// Force time package dependency for automated UpdatedAt/CreatedAt.
	_ = time.Second
	// Force bytes in case of primary key column that uses []byte (for relationship compares)
	_ = bytes.MinRead
)

type (
	// FeaturepropSlice is an alias for a slice of pointers to Featureprop.
	// This should generally be used opposed to []Featureprop.
	FeaturepropSlice []*Featureprop
	// FeaturepropHook is the signature for custom Featureprop hook methods
	FeaturepropHook func(boil.Executor, *Featureprop) error

	featurepropQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	featurepropType                 = reflect.TypeOf(&Featureprop{})
	featurepropMapping              = queries.MakeStructMapping(featurepropType)
	featurepropPrimaryKeyMapping, _ = queries.BindMapping(featurepropType, featurepropMapping, featurepropPrimaryKeyColumns)
	featurepropInsertCacheMut       sync.RWMutex
	featurepropInsertCache          = make(map[string]insertCache)
	featurepropUpdateCacheMut       sync.RWMutex
	featurepropUpdateCache          = make(map[string]updateCache)
	featurepropUpsertCacheMut       sync.RWMutex
	featurepropUpsertCache          = make(map[string]insertCache)
)

var (
	// Force time package dependency for automated UpdatedAt/CreatedAt.
	_ = time.Second
	// Force bytes in case of primary key column that uses []byte (for relationship compares)
	_ = bytes.MinRead
)

type (
	// FeatureDbxrefSlice is an alias for a slice of pointers to FeatureDbxref.
	// This should generally be used opposed to []FeatureDbxref.
	FeatureDbxrefSlice []*FeatureDbxref
	// FeatureDbxrefHook is the signature for custom FeatureDbxref hook methods
	FeatureDbxrefHook func(boil.Executor, *FeatureDbxref) error

	featureDbxrefQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	featureDbxrefType                 = reflect.TypeOf(&FeatureDbxref{})
	featureDbxrefMapping              = queries.MakeStructMapping(featureDbxrefType)
	featureDbxrefPrimaryKeyMapping, _ = queries.BindMapping(featureDbxrefType, featureDbxrefMapping, featureDbxrefPrimaryKeyColumns)
	featureDbxrefInsertCacheMut       sync.RWMutex
	featureDbxrefInsertCache          = make(map[string]insertCache)
	featureDbxrefUpdateCacheMut       sync.RWMutex
	featureDbxrefUpdateCache          = make(map[string]updateCache)
	featureDbxrefUpsertCacheMut       sync.RWMutex
	featureDbxrefUpsertCache          = make(map[string]insertCache)
)

var (
	// Force time package dependency for automated UpdatedAt/CreatedAt.
	_ = time.Second
	// Force bytes in case of primary key column that uses []byte (for relationship compares)
	_ = bytes.MinRead
)

type (
	// AnalysisfeatureSlice is an alias for a slice of pointers to Analysisfeature.
	// This should generally be used opposed to []Analysisfeature.
	AnalysisfeatureSlice []*Analysisfeature
	// AnalysisfeatureHook is the signature for custom Analysisfeature hook methods
	AnalysisfeatureHook func(boil.Executor, *Analysisfeature) error

	analysisfeatureQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	analysisfeatureType                 = reflect.TypeOf(&Analysisfeature{})
	analysisfeatureMapping              = queries.MakeStructMapping(analysisfeatureType)
	analysisfeaturePrimaryKeyMapping, _ = queries.BindMapping(analysisfeatureType, analysisfeatureMapping, analysisfeaturePrimaryKeyColumns)
	analysisfeatureInsertCacheMut       sync.RWMutex
	analysisfeatureInsertCache          = make(map[string]insertCache)
	analysisfeatureUpdateCacheMut       sync.RWMutex
	analysisfeatureUpdateCache          = make(map[string]updateCache)
	analysisfeatureUpsertCacheMut       sync.RWMutex
	analysisfeatureUpsertCache          = make(map[string]insertCache)
)

var (
	// Force time package dependency for automated UpdatedAt/CreatedAt.
	_ = time.Second
	// Force bytes in case of primary key column that uses []byte (for relationship compares)
	_ = bytes.MinRead
)

type (
	// FeatureRelationshippropPubSlice is an alias for a slice of pointers to FeatureRelationshippropPub.
	// This should generally be used opposed to []FeatureRelationshippropPub.
	FeatureRelationshippropPubSlice []*FeatureRelationshippropPub
	// FeatureRelationshippropPubHook is the signature for custom FeatureRelationshippropPub hook methods
	FeatureRelationshippropPubHook func(boil.Executor, *FeatureRelationshippropPub) error

	featureRelationshippropPubQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	featureRelationshippropPubType                 = reflect.TypeOf(&FeatureRelationshippropPub{})
	featureRelationshippropPubMapping              = queries.MakeStructMapping(featureRelationshippropPubType)
	featureRelationshippropPubPrimaryKeyMapping, _ = queries.BindMapping(featureRelationshippropPubType, featureRelationshippropPubMapping, featureRelationshippropPubPrimaryKeyColumns)
	featureRelationshippropPubInsertCacheMut       sync.RWMutex
	featureRelationshippropPubInsertCache          = make(map[string]insertCache)
	featureRelationshippropPubUpdateCacheMut       sync.RWMutex
	featureRelationshippropPubUpdateCache          = make(map[string]updateCache)
	featureRelationshippropPubUpsertCacheMut       sync.RWMutex
	featureRelationshippropPubUpsertCache          = make(map[string]insertCache)
)

var (
	// Force time package dependency for automated UpdatedAt/CreatedAt.
	_ = time.Second
	// Force bytes in case of primary key column that uses []byte (for relationship compares)
	_ = bytes.MinRead
)

type (
	// StockRelationshipCvtermSlice is an alias for a slice of pointers to StockRelationshipCvterm.
	// This should generally be used opposed to []StockRelationshipCvterm.
	StockRelationshipCvtermSlice []*StockRelationshipCvterm
	// StockRelationshipCvtermHook is the signature for custom StockRelationshipCvterm hook methods
	StockRelationshipCvtermHook func(boil.Executor, *StockRelationshipCvterm) error

	stockRelationshipCvtermQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	stockRelationshipCvtermType                 = reflect.TypeOf(&StockRelationshipCvterm{})
	stockRelationshipCvtermMapping              = queries.MakeStructMapping(stockRelationshipCvtermType)
	stockRelationshipCvtermPrimaryKeyMapping, _ = queries.BindMapping(stockRelationshipCvtermType, stockRelationshipCvtermMapping, stockRelationshipCvtermPrimaryKeyColumns)
	stockRelationshipCvtermInsertCacheMut       sync.RWMutex
	stockRelationshipCvtermInsertCache          = make(map[string]insertCache)
	stockRelationshipCvtermUpdateCacheMut       sync.RWMutex
	stockRelationshipCvtermUpdateCache          = make(map[string]updateCache)
	stockRelationshipCvtermUpsertCacheMut       sync.RWMutex
	stockRelationshipCvtermUpsertCache          = make(map[string]insertCache)
)

var (
	// Force time package dependency for automated UpdatedAt/CreatedAt.
	_ = time.Second
	// Force bytes in case of primary key column that uses []byte (for relationship compares)
	_ = bytes.MinRead
)

type (
	// StockcollectionSlice is an alias for a slice of pointers to Stockcollection.
	// This should generally be used opposed to []Stockcollection.
	StockcollectionSlice []*Stockcollection
	// StockcollectionHook is the signature for custom Stockcollection hook methods
	StockcollectionHook func(boil.Executor, *Stockcollection) error

	stockcollectionQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	stockcollectionType                 = reflect.TypeOf(&Stockcollection{})
	stockcollectionMapping              = queries.MakeStructMapping(stockcollectionType)
	stockcollectionPrimaryKeyMapping, _ = queries.BindMapping(stockcollectionType, stockcollectionMapping, stockcollectionPrimaryKeyColumns)
	stockcollectionInsertCacheMut       sync.RWMutex
	stockcollectionInsertCache          = make(map[string]insertCache)
	stockcollectionUpdateCacheMut       sync.RWMutex
	stockcollectionUpdateCache          = make(map[string]updateCache)
	stockcollectionUpsertCacheMut       sync.RWMutex
	stockcollectionUpsertCache          = make(map[string]insertCache)
)

var (
	// Force time package dependency for automated UpdatedAt/CreatedAt.
	_ = time.Second
	// Force bytes in case of primary key column that uses []byte (for relationship compares)
	_ = bytes.MinRead
)

type (
	// PhenotypepropSlice is an alias for a slice of pointers to Phenotypeprop.
	// This should generally be used opposed to []Phenotypeprop.
	PhenotypepropSlice []*Phenotypeprop
	// PhenotypepropHook is the signature for custom Phenotypeprop hook methods
	PhenotypepropHook func(boil.Executor, *Phenotypeprop) error

	phenotypepropQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	phenotypepropType                 = reflect.TypeOf(&Phenotypeprop{})
	phenotypepropMapping              = queries.MakeStructMapping(phenotypepropType)
	phenotypepropPrimaryKeyMapping, _ = queries.BindMapping(phenotypepropType, phenotypepropMapping, phenotypepropPrimaryKeyColumns)
	phenotypepropInsertCacheMut       sync.RWMutex
	phenotypepropInsertCache          = make(map[string]insertCache)
	phenotypepropUpdateCacheMut       sync.RWMutex
	phenotypepropUpdateCache          = make(map[string]updateCache)
	phenotypepropUpsertCacheMut       sync.RWMutex
	phenotypepropUpsertCache          = make(map[string]insertCache)
)

var (
	// Force time package dependency for automated UpdatedAt/CreatedAt.
	_ = time.Second
	// Force bytes in case of primary key column that uses []byte (for relationship compares)
	_ = bytes.MinRead
)

type (
	// CvtermpropSlice is an alias for a slice of pointers to Cvtermprop.
	// This should generally be used opposed to []Cvtermprop.
	CvtermpropSlice []*Cvtermprop
	// CvtermpropHook is the signature for custom Cvtermprop hook methods
	CvtermpropHook func(boil.Executor, *Cvtermprop) error

	cvtermpropQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	cvtermpropType                 = reflect.TypeOf(&Cvtermprop{})
	cvtermpropMapping              = queries.MakeStructMapping(cvtermpropType)
	cvtermpropPrimaryKeyMapping, _ = queries.BindMapping(cvtermpropType, cvtermpropMapping, cvtermpropPrimaryKeyColumns)
	cvtermpropInsertCacheMut       sync.RWMutex
	cvtermpropInsertCache          = make(map[string]insertCache)
	cvtermpropUpdateCacheMut       sync.RWMutex
	cvtermpropUpdateCache          = make(map[string]updateCache)
	cvtermpropUpsertCacheMut       sync.RWMutex
	cvtermpropUpsertCache          = make(map[string]insertCache)
)

var (
	// Force time package dependency for automated UpdatedAt/CreatedAt.
	_ = time.Second
	// Force bytes in case of primary key column that uses []byte (for relationship compares)
	_ = bytes.MinRead
)

type (
	// PhendescSlice is an alias for a slice of pointers to Phendesc.
	// This should generally be used opposed to []Phendesc.
	PhendescSlice []*Phendesc
	// PhendescHook is the signature for custom Phendesc hook methods
	PhendescHook func(boil.Executor, *Phendesc) error

	phendescQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	phendescType                 = reflect.TypeOf(&Phendesc{})
	phendescMapping              = queries.MakeStructMapping(phendescType)
	phendescPrimaryKeyMapping, _ = queries.BindMapping(phendescType, phendescMapping, phendescPrimaryKeyColumns)
	phendescInsertCacheMut       sync.RWMutex
	phendescInsertCache          = make(map[string]insertCache)
	phendescUpdateCacheMut       sync.RWMutex
	phendescUpdateCache          = make(map[string]updateCache)
	phendescUpsertCacheMut       sync.RWMutex
	phendescUpsertCache          = make(map[string]insertCache)
)

var (
	// Force time package dependency for automated UpdatedAt/CreatedAt.
	_ = time.Second
	// Force bytes in case of primary key column that uses []byte (for relationship compares)
	_ = bytes.MinRead
)

type (
	// StockcollectionpropSlice is an alias for a slice of pointers to Stockcollectionprop.
	// This should generally be used opposed to []Stockcollectionprop.
	StockcollectionpropSlice []*Stockcollectionprop
	// StockcollectionpropHook is the signature for custom Stockcollectionprop hook methods
	StockcollectionpropHook func(boil.Executor, *Stockcollectionprop) error

	stockcollectionpropQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	stockcollectionpropType                 = reflect.TypeOf(&Stockcollectionprop{})
	stockcollectionpropMapping              = queries.MakeStructMapping(stockcollectionpropType)
	stockcollectionpropPrimaryKeyMapping, _ = queries.BindMapping(stockcollectionpropType, stockcollectionpropMapping, stockcollectionpropPrimaryKeyColumns)
	stockcollectionpropInsertCacheMut       sync.RWMutex
	stockcollectionpropInsertCache          = make(map[string]insertCache)
	stockcollectionpropUpdateCacheMut       sync.RWMutex
	stockcollectionpropUpdateCache          = make(map[string]updateCache)
	stockcollectionpropUpsertCacheMut       sync.RWMutex
	stockcollectionpropUpsertCache          = make(map[string]insertCache)
)

var (
	// Force time package dependency for automated UpdatedAt/CreatedAt.
	_ = time.Second
	// Force bytes in case of primary key column that uses []byte (for relationship compares)
	_ = bytes.MinRead
)

type (
	// JbrowseOrganismSlice is an alias for a slice of pointers to JbrowseOrganism.
	// This should generally be used opposed to []JbrowseOrganism.
	JbrowseOrganismSlice []*JbrowseOrganism
	// JbrowseOrganismHook is the signature for custom JbrowseOrganism hook methods
	JbrowseOrganismHook func(boil.Executor, *JbrowseOrganism) error

	jbrowseOrganismQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	jbrowseOrganismType                 = reflect.TypeOf(&JbrowseOrganism{})
	jbrowseOrganismMapping              = queries.MakeStructMapping(jbrowseOrganismType)
	jbrowseOrganismPrimaryKeyMapping, _ = queries.BindMapping(jbrowseOrganismType, jbrowseOrganismMapping, jbrowseOrganismPrimaryKeyColumns)
	jbrowseOrganismInsertCacheMut       sync.RWMutex
	jbrowseOrganismInsertCache          = make(map[string]insertCache)
	jbrowseOrganismUpdateCacheMut       sync.RWMutex
	jbrowseOrganismUpdateCache          = make(map[string]updateCache)
	jbrowseOrganismUpsertCacheMut       sync.RWMutex
	jbrowseOrganismUpsertCache          = make(map[string]insertCache)
)

var (
	// Force time package dependency for automated UpdatedAt/CreatedAt.
	_ = time.Second
	// Force bytes in case of primary key column that uses []byte (for relationship compares)
	_ = bytes.MinRead
)

type (
	// StockCvtermpropSlice is an alias for a slice of pointers to StockCvtermprop.
	// This should generally be used opposed to []StockCvtermprop.
	StockCvtermpropSlice []*StockCvtermprop
	// StockCvtermpropHook is the signature for custom StockCvtermprop hook methods
	StockCvtermpropHook func(boil.Executor, *StockCvtermprop) error

	stockCvtermpropQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	stockCvtermpropType                 = reflect.TypeOf(&StockCvtermprop{})
	stockCvtermpropMapping              = queries.MakeStructMapping(stockCvtermpropType)
	stockCvtermpropPrimaryKeyMapping, _ = queries.BindMapping(stockCvtermpropType, stockCvtermpropMapping, stockCvtermpropPrimaryKeyColumns)
	stockCvtermpropInsertCacheMut       sync.RWMutex
	stockCvtermpropInsertCache          = make(map[string]insertCache)
	stockCvtermpropUpdateCacheMut       sync.RWMutex
	stockCvtermpropUpdateCache          = make(map[string]updateCache)
	stockCvtermpropUpsertCacheMut       sync.RWMutex
	stockCvtermpropUpsertCache          = make(map[string]insertCache)
)

var (
	// Force time package dependency for automated UpdatedAt/CreatedAt.
	_ = time.Second
	// Force bytes in case of primary key column that uses []byte (for relationship compares)
	_ = bytes.MinRead
)

type (
	// StockDbxrefSlice is an alias for a slice of pointers to StockDbxref.
	// This should generally be used opposed to []StockDbxref.
	StockDbxrefSlice []*StockDbxref
	// StockDbxrefHook is the signature for custom StockDbxref hook methods
	StockDbxrefHook func(boil.Executor, *StockDbxref) error

	stockDbxrefQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	stockDbxrefType                 = reflect.TypeOf(&StockDbxref{})
	stockDbxrefMapping              = queries.MakeStructMapping(stockDbxrefType)
	stockDbxrefPrimaryKeyMapping, _ = queries.BindMapping(stockDbxrefType, stockDbxrefMapping, stockDbxrefPrimaryKeyColumns)
	stockDbxrefInsertCacheMut       sync.RWMutex
	stockDbxrefInsertCache          = make(map[string]insertCache)
	stockDbxrefUpdateCacheMut       sync.RWMutex
	stockDbxrefUpdateCache          = make(map[string]updateCache)
	stockDbxrefUpsertCacheMut       sync.RWMutex
	stockDbxrefUpsertCache          = make(map[string]insertCache)
)

var (
	// Force time package dependency for automated UpdatedAt/CreatedAt.
	_ = time.Second
	// Force bytes in case of primary key column that uses []byte (for relationship compares)
	_ = bytes.MinRead
)

type (
	// DbxrefpropSlice is an alias for a slice of pointers to Dbxrefprop.
	// This should generally be used opposed to []Dbxrefprop.
	DbxrefpropSlice []*Dbxrefprop
	// DbxrefpropHook is the signature for custom Dbxrefprop hook methods
	DbxrefpropHook func(boil.Executor, *Dbxrefprop) error

	dbxrefpropQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	dbxrefpropType                 = reflect.TypeOf(&Dbxrefprop{})
	dbxrefpropMapping              = queries.MakeStructMapping(dbxrefpropType)
	dbxrefpropPrimaryKeyMapping, _ = queries.BindMapping(dbxrefpropType, dbxrefpropMapping, dbxrefpropPrimaryKeyColumns)
	dbxrefpropInsertCacheMut       sync.RWMutex
	dbxrefpropInsertCache          = make(map[string]insertCache)
	dbxrefpropUpdateCacheMut       sync.RWMutex
	dbxrefpropUpdateCache          = make(map[string]updateCache)
	dbxrefpropUpsertCacheMut       sync.RWMutex
	dbxrefpropUpsertCache          = make(map[string]insertCache)
)

var (
	// Force time package dependency for automated UpdatedAt/CreatedAt.
	_ = time.Second
	// Force bytes in case of primary key column that uses []byte (for relationship compares)
	_ = bytes.MinRead
)

type (
	// EnvironmentCvtermSlice is an alias for a slice of pointers to EnvironmentCvterm.
	// This should generally be used opposed to []EnvironmentCvterm.
	EnvironmentCvtermSlice []*EnvironmentCvterm
	// EnvironmentCvtermHook is the signature for custom EnvironmentCvterm hook methods
	EnvironmentCvtermHook func(boil.Executor, *EnvironmentCvterm) error

	environmentCvtermQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	environmentCvtermType                 = reflect.TypeOf(&EnvironmentCvterm{})
	environmentCvtermMapping              = queries.MakeStructMapping(environmentCvtermType)
	environmentCvtermPrimaryKeyMapping, _ = queries.BindMapping(environmentCvtermType, environmentCvtermMapping, environmentCvtermPrimaryKeyColumns)
	environmentCvtermInsertCacheMut       sync.RWMutex
	environmentCvtermInsertCache          = make(map[string]insertCache)
	environmentCvtermUpdateCacheMut       sync.RWMutex
	environmentCvtermUpdateCache          = make(map[string]updateCache)
	environmentCvtermUpsertCacheMut       sync.RWMutex
	environmentCvtermUpsertCache          = make(map[string]insertCache)
)

var (
	// Force time package dependency for automated UpdatedAt/CreatedAt.
	_ = time.Second
	// Force bytes in case of primary key column that uses []byte (for relationship compares)
	_ = bytes.MinRead
)

type (
	// StockCvtermSlice is an alias for a slice of pointers to StockCvterm.
	// This should generally be used opposed to []StockCvterm.
	StockCvtermSlice []*StockCvterm
	// StockCvtermHook is the signature for custom StockCvterm hook methods
	StockCvtermHook func(boil.Executor, *StockCvterm) error

	stockCvtermQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	stockCvtermType                 = reflect.TypeOf(&StockCvterm{})
	stockCvtermMapping              = queries.MakeStructMapping(stockCvtermType)
	stockCvtermPrimaryKeyMapping, _ = queries.BindMapping(stockCvtermType, stockCvtermMapping, stockCvtermPrimaryKeyColumns)
	stockCvtermInsertCacheMut       sync.RWMutex
	stockCvtermInsertCache          = make(map[string]insertCache)
	stockCvtermUpdateCacheMut       sync.RWMutex
	stockCvtermUpdateCache          = make(map[string]updateCache)
	stockCvtermUpsertCacheMut       sync.RWMutex
	stockCvtermUpsertCache          = make(map[string]insertCache)
)

var (
	// Force time package dependency for automated UpdatedAt/CreatedAt.
	_ = time.Second
	// Force bytes in case of primary key column that uses []byte (for relationship compares)
	_ = bytes.MinRead
)

type (
	// AuthUserInfoSlice is an alias for a slice of pointers to AuthUserInfo.
	// This should generally be used opposed to []AuthUserInfo.
	AuthUserInfoSlice []*AuthUserInfo
	// AuthUserInfoHook is the signature for custom AuthUserInfo hook methods
	AuthUserInfoHook func(boil.Executor, *AuthUserInfo) error

	authUserInfoQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	authUserInfoType                 = reflect.TypeOf(&AuthUserInfo{})
	authUserInfoMapping              = queries.MakeStructMapping(authUserInfoType)
	authUserInfoPrimaryKeyMapping, _ = queries.BindMapping(authUserInfoType, authUserInfoMapping, authUserInfoPrimaryKeyColumns)
	authUserInfoInsertCacheMut       sync.RWMutex
	authUserInfoInsertCache          = make(map[string]insertCache)
	authUserInfoUpdateCacheMut       sync.RWMutex
	authUserInfoUpdateCache          = make(map[string]updateCache)
	authUserInfoUpsertCacheMut       sync.RWMutex
	authUserInfoUpsertCache          = make(map[string]insertCache)
)

var (
	// Force time package dependency for automated UpdatedAt/CreatedAt.
	_ = time.Second
	// Force bytes in case of primary key column that uses []byte (for relationship compares)
	_ = bytes.MinRead
)

type (
	// AuthRolePermissionSlice is an alias for a slice of pointers to AuthRolePermission.
	// This should generally be used opposed to []AuthRolePermission.
	AuthRolePermissionSlice []*AuthRolePermission
	// AuthRolePermissionHook is the signature for custom AuthRolePermission hook methods
	AuthRolePermissionHook func(boil.Executor, *AuthRolePermission) error

	authRolePermissionQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	authRolePermissionType                 = reflect.TypeOf(&AuthRolePermission{})
	authRolePermissionMapping              = queries.MakeStructMapping(authRolePermissionType)
	authRolePermissionPrimaryKeyMapping, _ = queries.BindMapping(authRolePermissionType, authRolePermissionMapping, authRolePermissionPrimaryKeyColumns)
	authRolePermissionInsertCacheMut       sync.RWMutex
	authRolePermissionInsertCache          = make(map[string]insertCache)
	authRolePermissionUpdateCacheMut       sync.RWMutex
	authRolePermissionUpdateCache          = make(map[string]updateCache)
	authRolePermissionUpsertCacheMut       sync.RWMutex
	authRolePermissionUpsertCache          = make(map[string]insertCache)
)

var (
	// Force time package dependency for automated UpdatedAt/CreatedAt.
	_ = time.Second
	// Force bytes in case of primary key column that uses []byte (for relationship compares)
	_ = bytes.MinRead
)

type (
	// PhenstatementSlice is an alias for a slice of pointers to Phenstatement.
	// This should generally be used opposed to []Phenstatement.
	PhenstatementSlice []*Phenstatement
	// PhenstatementHook is the signature for custom Phenstatement hook methods
	PhenstatementHook func(boil.Executor, *Phenstatement) error

	phenstatementQuery struct {
		*queries.Query
	}
)

// Cache for insert, update and upsert
var (
	phenstatementType                 = reflect.TypeOf(&Phenstatement{})
	phenstatementMapping              = queries.MakeStructMapping(phenstatementType)
	phenstatementPrimaryKeyMapping, _ = queries.BindMapping(phenstatementType, phenstatementMapping, phenstatementPrimaryKeyColumns)
	phenstatementInsertCacheMut       sync.RWMutex
	phenstatementInsertCache          = make(map[string]insertCache)
	phenstatementUpdateCacheMut       sync.RWMutex
	phenstatementUpdateCache          = make(map[string]updateCache)
	phenstatementUpsertCacheMut       sync.RWMutex
	phenstatementUpsertCache          = make(map[string]insertCache)
)

var (
	// Force time package dependency for automated UpdatedAt/CreatedAt.
	_ = time.Second
	// Force bytes in case of primary key column that uses []byte (for relationship compares)
	_ = bytes.MinRead
)