graphql_models

Documentation

Index

• Variables
• func NewExecutableSchema(cfg Config) graphql.ExecutableSchema
• type Additive
  • func (Additive) IsNode()
• type AdditiveConnection
• type AdditiveCreateInput
• type AdditiveDeletePayload
• type AdditiveEdge
• type AdditiveFilter
• type AdditiveInventoriesDeletePayload
• type AdditiveInventoriesUpdatePayload
• type AdditiveInventory
  • func (AdditiveInventory) IsNode()
• type AdditiveInventoryConnection
• type AdditiveInventoryCreateInput
• type AdditiveInventoryDeletePayload
• type AdditiveInventoryEdge
• type AdditiveInventoryFilter
• type AdditiveInventoryOrdering
• type AdditiveInventoryPayload
• type AdditiveInventorySort
  • func (e AdditiveInventorySort) IsValid() bool
  • func (e AdditiveInventorySort) MarshalGQL(w io.Writer)
  • func (e AdditiveInventorySort) String() string
  • func (e *AdditiveInventorySort) UnmarshalGQL(v interface{}) error
• type AdditiveInventoryUpdateInput
• type AdditiveInventoryWhere
• type AdditiveOrdering
• type AdditivePayload
• type AdditiveSort
  • func (e AdditiveSort) IsValid() bool
  • func (e AdditiveSort) MarshalGQL(w io.Writer)
  • func (e AdditiveSort) String() string
  • func (e *AdditiveSort) UnmarshalGQL(v interface{}) error
• type AdditiveUpdateInput
• type AdditiveWhere
• type AdditivesDeletePayload
• type AdditivesUpdatePayload
• type AuthGroup
  • func (AuthGroup) IsNode()
• type AuthGroupConnection
• type AuthGroupCreateInput
• type AuthGroupDeletePayload
• type AuthGroupEdge
• type AuthGroupFilter
• type AuthGroupOrdering
• type AuthGroupPayload
• type AuthGroupPermission
  • func (AuthGroupPermission) IsNode()
• type AuthGroupPermissionConnection
• type AuthGroupPermissionCreateInput
• type AuthGroupPermissionDeletePayload
• type AuthGroupPermissionEdge
• type AuthGroupPermissionFilter
• type AuthGroupPermissionOrdering
• type AuthGroupPermissionPayload
• type AuthGroupPermissionSort
  • func (e AuthGroupPermissionSort) IsValid() bool
  • func (e AuthGroupPermissionSort) MarshalGQL(w io.Writer)
  • func (e AuthGroupPermissionSort) String() string
  • func (e *AuthGroupPermissionSort) UnmarshalGQL(v interface{}) error
• type AuthGroupPermissionUpdateInput
• type AuthGroupPermissionWhere
• type AuthGroupPermissionsDeletePayload
• type AuthGroupPermissionsUpdatePayload
• type AuthGroupSort
  • func (e AuthGroupSort) IsValid() bool
  • func (e AuthGroupSort) MarshalGQL(w io.Writer)
  • func (e AuthGroupSort) String() string
  • func (e *AuthGroupSort) UnmarshalGQL(v interface{}) error
• type AuthGroupUpdateInput
• type AuthGroupWhere
• type AuthGroupsDeletePayload
• type AuthGroupsUpdatePayload
• type AuthPermission
  • func (AuthPermission) IsNode()
• type AuthPermissionConnection
• type AuthPermissionCreateInput
• type AuthPermissionDeletePayload
• type AuthPermissionEdge
• type AuthPermissionFilter
• type AuthPermissionOrdering
• type AuthPermissionPayload
• type AuthPermissionSort
  • func (e AuthPermissionSort) IsValid() bool
  • func (e AuthPermissionSort) MarshalGQL(w io.Writer)
  • func (e AuthPermissionSort) String() string
  • func (e *AuthPermissionSort) UnmarshalGQL(v interface{}) error
• type AuthPermissionUpdateInput
• type AuthPermissionWhere
• type AuthPermissionsDeletePayload
• type AuthPermissionsUpdatePayload
• type AuthUser
  • func (AuthUser) IsNode()
• type AuthUserConnection
• type AuthUserCreateInput
• type AuthUserDeletePayload
• type AuthUserEdge
• type AuthUserFilter
• type AuthUserGroup
  • func (AuthUserGroup) IsNode()
• type AuthUserGroupConnection
• type AuthUserGroupCreateInput
• type AuthUserGroupDeletePayload
• type AuthUserGroupEdge
• type AuthUserGroupFilter
• type AuthUserGroupOrdering
• type AuthUserGroupPayload
• type AuthUserGroupSort
  • func (e AuthUserGroupSort) IsValid() bool
  • func (e AuthUserGroupSort) MarshalGQL(w io.Writer)
  • func (e AuthUserGroupSort) String() string
  • func (e *AuthUserGroupSort) UnmarshalGQL(v interface{}) error
• type AuthUserGroupUpdateInput
• type AuthUserGroupWhere
• type AuthUserGroupsDeletePayload
• type AuthUserGroupsUpdatePayload
• type AuthUserOrdering
• type AuthUserPayload
• type AuthUserSort
  • func (e AuthUserSort) IsValid() bool
  • func (e AuthUserSort) MarshalGQL(w io.Writer)
  • func (e AuthUserSort) String() string
  • func (e *AuthUserSort) UnmarshalGQL(v interface{}) error
• type AuthUserUpdateInput
• type AuthUserUserPermission
  • func (AuthUserUserPermission) IsNode()
• type AuthUserUserPermissionConnection
• type AuthUserUserPermissionCreateInput
• type AuthUserUserPermissionDeletePayload
• type AuthUserUserPermissionEdge
• type AuthUserUserPermissionFilter
• type AuthUserUserPermissionOrdering
• type AuthUserUserPermissionPayload
• type AuthUserUserPermissionSort
  • func (e AuthUserUserPermissionSort) IsValid() bool
  • func (e AuthUserUserPermissionSort) MarshalGQL(w io.Writer)
  • func (e AuthUserUserPermissionSort) String() string
  • func (e *AuthUserUserPermissionSort) UnmarshalGQL(v interface{}) error
• type AuthUserUserPermissionUpdateInput
• type AuthUserUserPermissionWhere
• type AuthUserUserPermissionsDeletePayload
• type AuthUserUserPermissionsUpdatePayload
• type AuthUserWhere
• type AuthUsersDeletePayload
• type AuthUsersUpdatePayload
• type BooleanFilter
• type ComplexityRoot
• type Config
• type DirectiveRoot
• type FloatFilter
• type Fragrance
  • func (Fragrance) IsNode()
• type FragranceConnection
• type FragranceCreateInput
• type FragranceDeletePayload
• type FragranceEdge
• type FragranceFilter
• type FragranceInventoriesDeletePayload
• type FragranceInventoriesUpdatePayload
• type FragranceInventory
  • func (FragranceInventory) IsNode()
• type FragranceInventoryConnection
• type FragranceInventoryCreateInput
• type FragranceInventoryDeletePayload
• type FragranceInventoryEdge
• type FragranceInventoryFilter
• type FragranceInventoryOrdering
• type FragranceInventoryPayload
• type FragranceInventorySort
  • func (e FragranceInventorySort) IsValid() bool
  • func (e FragranceInventorySort) MarshalGQL(w io.Writer)
  • func (e FragranceInventorySort) String() string
  • func (e *FragranceInventorySort) UnmarshalGQL(v interface{}) error
• type FragranceInventoryUpdateInput
• type FragranceInventoryWhere
• type FragranceOrdering
• type FragrancePayload
• type FragranceSort
  • func (e FragranceSort) IsValid() bool
  • func (e FragranceSort) MarshalGQL(w io.Writer)
  • func (e FragranceSort) String() string
  • func (e *FragranceSort) UnmarshalGQL(v interface{}) error
• type FragranceUpdateInput
• type FragranceWhere
• type FragrancesDeletePayload
• type FragrancesUpdatePayload
• type IDFilter
• type IntFilter
• type Lipid
  • func (Lipid) IsNode()
• type LipidConnection
• type LipidCreateInput
• type LipidDeletePayload
• type LipidEdge
• type LipidFilter
• type LipidInventoriesDeletePayload
• type LipidInventoriesUpdatePayload
• type LipidInventory
  • func (LipidInventory) IsNode()
• type LipidInventoryConnection
• type LipidInventoryCreateInput
• type LipidInventoryDeletePayload
• type LipidInventoryEdge
• type LipidInventoryFilter
• type LipidInventoryOrdering
• type LipidInventoryPayload
• type LipidInventorySort
  • func (e LipidInventorySort) IsValid() bool
  • func (e LipidInventorySort) MarshalGQL(w io.Writer)
  • func (e LipidInventorySort) String() string
  • func (e *LipidInventorySort) UnmarshalGQL(v interface{}) error
• type LipidInventoryUpdateInput
• type LipidInventoryWhere
• type LipidOrdering
• type LipidPayload
• type LipidSort
  • func (e LipidSort) IsValid() bool
  • func (e LipidSort) MarshalGQL(w io.Writer)
  • func (e LipidSort) String() string
  • func (e *LipidSort) UnmarshalGQL(v interface{}) error
• type LipidUpdateInput
• type LipidWhere
• type LipidsDeletePayload
• type LipidsUpdatePayload
• type Lye
  • func (Lye) IsNode()
• type LyeConnection
• type LyeCreateInput
• type LyeDeletePayload
• type LyeEdge
• type LyeFilter
• type LyeInventoriesDeletePayload
• type LyeInventoriesUpdatePayload
• type LyeInventory
  • func (LyeInventory) IsNode()
• type LyeInventoryConnection
• type LyeInventoryCreateInput
• type LyeInventoryDeletePayload
• type LyeInventoryEdge
• type LyeInventoryFilter
• type LyeInventoryOrdering
• type LyeInventoryPayload
• type LyeInventorySort
  • func (e LyeInventorySort) IsValid() bool
  • func (e LyeInventorySort) MarshalGQL(w io.Writer)
  • func (e LyeInventorySort) String() string
  • func (e *LyeInventorySort) UnmarshalGQL(v interface{}) error
• type LyeInventoryUpdateInput
• type LyeInventoryWhere
• type LyeOrdering
• type LyePayload
• type LyeSort
  • func (e LyeSort) IsValid() bool
  • func (e LyeSort) MarshalGQL(w io.Writer)
  • func (e LyeSort) String() string
  • func (e *LyeSort) UnmarshalGQL(v interface{}) error
• type LyeUpdateInput
• type LyeWhere
• type LyesDeletePayload
• type LyesUpdatePayload
• type MutationResolver
• type Node
• type PageInfo
• type QueryResolver
• type Recipe
  • func (Recipe) IsNode()
• type RecipeAdditive
  • func (RecipeAdditive) IsNode()
• type RecipeAdditiveConnection
• type RecipeAdditiveCreateInput
• type RecipeAdditiveDeletePayload
• type RecipeAdditiveEdge
• type RecipeAdditiveFilter
• type RecipeAdditiveOrdering
• type RecipeAdditivePayload
• type RecipeAdditiveSort
  • func (e RecipeAdditiveSort) IsValid() bool
  • func (e RecipeAdditiveSort) MarshalGQL(w io.Writer)
  • func (e RecipeAdditiveSort) String() string
  • func (e *RecipeAdditiveSort) UnmarshalGQL(v interface{}) error
• type RecipeAdditiveUpdateInput
• type RecipeAdditiveWhere
• type RecipeAdditivesDeletePayload
• type RecipeAdditivesUpdatePayload
• type RecipeBatch
  • func (RecipeBatch) IsNode()
• type RecipeBatchAdditive
  • func (RecipeBatchAdditive) IsNode()
• type RecipeBatchAdditiveConnection
• type RecipeBatchAdditiveCreateInput
• type RecipeBatchAdditiveDeletePayload
• type RecipeBatchAdditiveEdge
• type RecipeBatchAdditiveFilter
• type RecipeBatchAdditiveOrdering
• type RecipeBatchAdditivePayload
• type RecipeBatchAdditiveSort
  • func (e RecipeBatchAdditiveSort) IsValid() bool
  • func (e RecipeBatchAdditiveSort) MarshalGQL(w io.Writer)
  • func (e RecipeBatchAdditiveSort) String() string
  • func (e *RecipeBatchAdditiveSort) UnmarshalGQL(v interface{}) error
• type RecipeBatchAdditiveUpdateInput
• type RecipeBatchAdditiveWhere
• type RecipeBatchAdditivesDeletePayload
• type RecipeBatchAdditivesUpdatePayload
• type RecipeBatchConnection
• type RecipeBatchCreateInput
• type RecipeBatchDeletePayload
• type RecipeBatchEdge
• type RecipeBatchFilter
• type RecipeBatchFragrance
  • func (RecipeBatchFragrance) IsNode()
• type RecipeBatchFragranceConnection
• type RecipeBatchFragranceCreateInput
• type RecipeBatchFragranceDeletePayload
• type RecipeBatchFragranceEdge
• type RecipeBatchFragranceFilter
• type RecipeBatchFragranceOrdering
• type RecipeBatchFragrancePayload
• type RecipeBatchFragranceSort
  • func (e RecipeBatchFragranceSort) IsValid() bool
  • func (e RecipeBatchFragranceSort) MarshalGQL(w io.Writer)
  • func (e RecipeBatchFragranceSort) String() string
  • func (e *RecipeBatchFragranceSort) UnmarshalGQL(v interface{}) error
• type RecipeBatchFragranceUpdateInput
• type RecipeBatchFragranceWhere
• type RecipeBatchFragrancesDeletePayload
• type RecipeBatchFragrancesUpdatePayload
• type RecipeBatchLipid
  • func (RecipeBatchLipid) IsNode()
• type RecipeBatchLipidConnection
• type RecipeBatchLipidCreateInput
• type RecipeBatchLipidDeletePayload
• type RecipeBatchLipidEdge
• type RecipeBatchLipidFilter
• type RecipeBatchLipidOrdering
• type RecipeBatchLipidPayload
• type RecipeBatchLipidSort
  • func (e RecipeBatchLipidSort) IsValid() bool
  • func (e RecipeBatchLipidSort) MarshalGQL(w io.Writer)
  • func (e RecipeBatchLipidSort) String() string
  • func (e *RecipeBatchLipidSort) UnmarshalGQL(v interface{}) error
• type RecipeBatchLipidUpdateInput
• type RecipeBatchLipidWhere
• type RecipeBatchLipidsDeletePayload
• type RecipeBatchLipidsUpdatePayload
• type RecipeBatchLye
  • func (RecipeBatchLye) IsNode()
• type RecipeBatchLyeConnection
• type RecipeBatchLyeCreateInput
• type RecipeBatchLyeDeletePayload
• type RecipeBatchLyeEdge
• type RecipeBatchLyeFilter
• type RecipeBatchLyeOrdering
• type RecipeBatchLyePayload
• type RecipeBatchLyeSort
  • func (e RecipeBatchLyeSort) IsValid() bool
  • func (e RecipeBatchLyeSort) MarshalGQL(w io.Writer)
  • func (e RecipeBatchLyeSort) String() string
  • func (e *RecipeBatchLyeSort) UnmarshalGQL(v interface{}) error
• type RecipeBatchLyeUpdateInput
• type RecipeBatchLyeWhere
• type RecipeBatchLyesDeletePayload
• type RecipeBatchLyesUpdatePayload
• type RecipeBatchNote
  • func (RecipeBatchNote) IsNode()
• type RecipeBatchNoteConnection
• type RecipeBatchNoteCreateInput
• type RecipeBatchNoteDeletePayload
• type RecipeBatchNoteEdge
• type RecipeBatchNoteFilter
• type RecipeBatchNoteOrdering
• type RecipeBatchNotePayload
• type RecipeBatchNoteSort
  • func (e RecipeBatchNoteSort) IsValid() bool
  • func (e RecipeBatchNoteSort) MarshalGQL(w io.Writer)
  • func (e RecipeBatchNoteSort) String() string
  • func (e *RecipeBatchNoteSort) UnmarshalGQL(v interface{}) error
• type RecipeBatchNoteUpdateInput
• type RecipeBatchNoteWhere
• type RecipeBatchNotesDeletePayload
• type RecipeBatchNotesUpdatePayload
• type RecipeBatchOrdering
• type RecipeBatchPayload
• type RecipeBatchSort
  • func (e RecipeBatchSort) IsValid() bool
  • func (e RecipeBatchSort) MarshalGQL(w io.Writer)
  • func (e RecipeBatchSort) String() string
  • func (e *RecipeBatchSort) UnmarshalGQL(v interface{}) error
• type RecipeBatchUpdateInput
• type RecipeBatchWhere
• type RecipeBatchesDeletePayload
• type RecipeBatchesUpdatePayload
• type RecipeConnection
• type RecipeCreateInput
• type RecipeDeletePayload
• type RecipeEdge
• type RecipeFilter
• type RecipeFragrance
  • func (RecipeFragrance) IsNode()
• type RecipeFragranceConnection
• type RecipeFragranceCreateInput
• type RecipeFragranceDeletePayload
• type RecipeFragranceEdge
• type RecipeFragranceFilter
• type RecipeFragranceOrdering
• type RecipeFragrancePayload
• type RecipeFragranceSort
  • func (e RecipeFragranceSort) IsValid() bool
  • func (e RecipeFragranceSort) MarshalGQL(w io.Writer)
  • func (e RecipeFragranceSort) String() string
  • func (e *RecipeFragranceSort) UnmarshalGQL(v interface{}) error
• type RecipeFragranceUpdateInput
• type RecipeFragranceWhere
• type RecipeFragrancesDeletePayload
• type RecipeFragrancesUpdatePayload
• type RecipeLipid
  • func (RecipeLipid) IsNode()
• type RecipeLipidConnection
• type RecipeLipidCreateInput
• type RecipeLipidDeletePayload
• type RecipeLipidEdge
• type RecipeLipidFilter
• type RecipeLipidOrdering
• type RecipeLipidPayload
• type RecipeLipidSort
  • func (e RecipeLipidSort) IsValid() bool
  • func (e RecipeLipidSort) MarshalGQL(w io.Writer)
  • func (e RecipeLipidSort) String() string
  • func (e *RecipeLipidSort) UnmarshalGQL(v interface{}) error
• type RecipeLipidUpdateInput
• type RecipeLipidWhere
• type RecipeLipidsDeletePayload
• type RecipeLipidsUpdatePayload
• type RecipeOrdering
• type RecipePayload
• type RecipeSort
  • func (e RecipeSort) IsValid() bool
  • func (e RecipeSort) MarshalGQL(w io.Writer)
  • func (e RecipeSort) String() string
  • func (e *RecipeSort) UnmarshalGQL(v interface{}) error
• type RecipeStep
  • func (RecipeStep) IsNode()
• type RecipeStepConnection
• type RecipeStepCreateInput
• type RecipeStepDeletePayload
• type RecipeStepEdge
• type RecipeStepFilter
• type RecipeStepOrdering
• type RecipeStepPayload
• type RecipeStepSort
  • func (e RecipeStepSort) IsValid() bool
  • func (e RecipeStepSort) MarshalGQL(w io.Writer)
  • func (e RecipeStepSort) String() string
  • func (e *RecipeStepSort) UnmarshalGQL(v interface{}) error
• type RecipeStepUpdateInput
• type RecipeStepWhere
• type RecipeStepsDeletePayload
• type RecipeStepsUpdatePayload
• type RecipeUpdateInput
• type RecipeWhere
• type RecipesDeletePayload
• type RecipesUpdatePayload
• type ResolverRoot
• type StringFilter
• type Supplier
  • func (Supplier) IsNode()
• type SupplierConnection
• type SupplierCreateInput
• type SupplierDeletePayload
• type SupplierEdge
• type SupplierFilter
• type SupplierOrdering
• type SupplierPayload
• type SupplierSort
  • func (e SupplierSort) IsValid() bool
  • func (e SupplierSort) MarshalGQL(w io.Writer)
  • func (e SupplierSort) String() string
  • func (e *SupplierSort) UnmarshalGQL(v interface{}) error
• type SupplierUpdateInput
• type SupplierWhere
• type SuppliersDeletePayload
• type SuppliersUpdatePayload

Variables

var AllAdditiveInventorySort = []AdditiveInventorySort{
	AdditiveInventorySortID,
	AdditiveInventorySortPurchaseDate,
	AdditiveInventorySortExpiryDate,
	AdditiveInventorySortCost,
	AdditiveInventorySortWeight,
	AdditiveInventorySortCreatedAt,
	AdditiveInventorySortUpdatedAt,
	AdditiveInventorySortDeletedAt,
}

var AllAdditiveSort = []AdditiveSort{
	AdditiveSortID,
	AdditiveSortName,
	AdditiveSortNote,
	AdditiveSortCreatedAt,
	AdditiveSortUpdatedAt,
	AdditiveSortDeletedAt,
}

var AllAuthGroupPermissionSort = []AuthGroupPermissionSort{
	AuthGroupPermissionSortID,
}

var AllAuthGroupSort = []AuthGroupSort{
	AuthGroupSortID,
	AuthGroupSortName,
}

var AllAuthPermissionSort = []AuthPermissionSort{
	AuthPermissionSortID,
	AuthPermissionSortName,
	AuthPermissionSortCodename,
}

var AllAuthUserGroupSort = []AuthUserGroupSort{
	AuthUserGroupSortID,
}

var AllAuthUserSort = []AuthUserSort{
	AuthUserSortID,
	AuthUserSortPassword,
	AuthUserSortLastLogin,
	AuthUserSortIsSuperuser,
	AuthUserSortUsername,
	AuthUserSortFirstName,
	AuthUserSortLastName,
	AuthUserSortEmail,
	AuthUserSortIsStaff,
	AuthUserSortIsActive,
	AuthUserSortDateJoined,
}

var AllAuthUserUserPermissionSort = []AuthUserUserPermissionSort{
	AuthUserUserPermissionSortID,
}

var AllFragranceInventorySort = []FragranceInventorySort{
	FragranceInventorySortID,
	FragranceInventorySortPurchaseDate,
	FragranceInventorySortExpiryDate,
	FragranceInventorySortCost,
	FragranceInventorySortWeight,
	FragranceInventorySortCreatedAt,
	FragranceInventorySortUpdatedAt,
	FragranceInventorySortDeletedAt,
}

var AllFragranceSort = []FragranceSort{
	FragranceSortID,
	FragranceSortName,
	FragranceSortNote,
	FragranceSortCreatedAt,
	FragranceSortUpdatedAt,
	FragranceSortDeletedAt,
}

var AllLipidInventorySort = []LipidInventorySort{
	LipidInventorySortID,
	LipidInventorySortPurchaseDate,
	LipidInventorySortExpiryDate,
	LipidInventorySortCost,
	LipidInventorySortWeight,
	LipidInventorySortSap,
	LipidInventorySortNaoh,
	LipidInventorySortKoh,
	LipidInventorySortGramsPerLiter,
	LipidInventorySortCreatedAt,
	LipidInventorySortUpdatedAt,
	LipidInventorySortDeletedAt,
}

var AllLipidSort = []LipidSort{
	LipidSortID,
	LipidSortName,
	LipidSortLauric,
	LipidSortMyristic,
	LipidSortPalmitic,
	LipidSortStearic,
	LipidSortRicinoleic,
	LipidSortOleic,
	LipidSortLinoleic,
	LipidSortLinolenic,
	LipidSortHardness,
	LipidSortCleansing,
	LipidSortConditioning,
	LipidSortBubbly,
	LipidSortCreamy,
	LipidSortIodine,
	LipidSortIns,
	LipidSortInciName,
	LipidSortFamily,
	LipidSortNaoh,
	LipidSortCreatedAt,
	LipidSortUpdatedAt,
	LipidSortDeletedAt,
}

var AllLyeInventorySort = []LyeInventorySort{
	LyeInventorySortID,
	LyeInventorySortPurchaseDate,
	LyeInventorySortExpiryDate,
	LyeInventorySortCost,
	LyeInventorySortWeight,
	LyeInventorySortConcentration,
	LyeInventorySortCreatedAt,
	LyeInventorySortUpdatedAt,
	LyeInventorySortDeletedAt,
}

var AllLyeSort = []LyeSort{
	LyeSortID,
	LyeSortKind,
	LyeSortName,
	LyeSortNote,
	LyeSortCreatedAt,
	LyeSortUpdatedAt,
	LyeSortDeletedAt,
}

var AllRecipeAdditiveSort = []RecipeAdditiveSort{
	RecipeAdditiveSortID,
	RecipeAdditiveSortPercentage,
	RecipeAdditiveSortCreatedAt,
	RecipeAdditiveSortUpdatedAt,
	RecipeAdditiveSortDeletedAt,
}

var AllRecipeBatchAdditiveSort = []RecipeBatchAdditiveSort{
	RecipeBatchAdditiveSortID,
	RecipeBatchAdditiveSortWeight,
	RecipeBatchAdditiveSortCost,
	RecipeBatchAdditiveSortCreatedAt,
	RecipeBatchAdditiveSortUpdatedAt,
	RecipeBatchAdditiveSortDeletedAt,
}

var AllRecipeBatchFragranceSort = []RecipeBatchFragranceSort{
	RecipeBatchFragranceSortID,
	RecipeBatchFragranceSortWeight,
	RecipeBatchFragranceSortCost,
	RecipeBatchFragranceSortCreatedAt,
	RecipeBatchFragranceSortUpdatedAt,
	RecipeBatchFragranceSortDeletedAt,
}

var AllRecipeBatchLipidSort = []RecipeBatchLipidSort{
	RecipeBatchLipidSortID,
	RecipeBatchLipidSortWeight,
	RecipeBatchLipidSortCost,
	RecipeBatchLipidSortCreatedAt,
	RecipeBatchLipidSortUpdatedAt,
	RecipeBatchLipidSortDeletedAt,
}

var AllRecipeBatchLyeSort = []RecipeBatchLyeSort{
	RecipeBatchLyeSortID,
	RecipeBatchLyeSortWeight,
	RecipeBatchLyeSortDiscount,
	RecipeBatchLyeSortCost,
	RecipeBatchLyeSortCreatedAt,
	RecipeBatchLyeSortUpdatedAt,
	RecipeBatchLyeSortDeletedAt,
}

var AllRecipeBatchNoteSort = []RecipeBatchNoteSort{
	RecipeBatchNoteSortID,
	RecipeBatchNoteSortNote,
	RecipeBatchNoteSortLink,
	RecipeBatchNoteSortCreatedAt,
	RecipeBatchNoteSortUpdatedAt,
	RecipeBatchNoteSortDeletedAt,
}

var AllRecipeBatchSort = []RecipeBatchSort{
	RecipeBatchSortID,
	RecipeBatchSortTag,
	RecipeBatchSortProductionDate,
	RecipeBatchSortSellableDate,
	RecipeBatchSortNote,
	RecipeBatchSortLipidWeight,
	RecipeBatchSortProductionWeight,
	RecipeBatchSortCuredWeight,
	RecipeBatchSortCreatedAt,
	RecipeBatchSortUpdatedAt,
	RecipeBatchSortDeletedAt,
}

var AllRecipeFragranceSort = []RecipeFragranceSort{
	RecipeFragranceSortID,
	RecipeFragranceSortPercentage,
	RecipeFragranceSortCreatedAt,
	RecipeFragranceSortUpdatedAt,
	RecipeFragranceSortDeletedAt,
}

var AllRecipeLipidSort = []RecipeLipidSort{
	RecipeLipidSortID,
	RecipeLipidSortPercentage,
	RecipeLipidSortCreatedAt,
	RecipeLipidSortUpdatedAt,
	RecipeLipidSortDeletedAt,
}

var AllRecipeSort = []RecipeSort{
	RecipeSortID,
	RecipeSortName,
	RecipeSortNote,
	RecipeSortCreatedAt,
	RecipeSortUpdatedAt,
	RecipeSortDeletedAt,
}

var AllRecipeStepSort = []RecipeStepSort{
	RecipeStepSortID,
	RecipeStepSortNum,
	RecipeStepSortNote,
	RecipeStepSortCreatedAt,
	RecipeStepSortUpdatedAt,
	RecipeStepSortDeletedAt,
}

var AllSupplierSort = []SupplierSort{
	SupplierSortID,
	SupplierSortName,
	SupplierSortWebsite,
	SupplierSortNote,
	SupplierSortCreatedAt,
	SupplierSortUpdatedAt,
	SupplierSortDeletedAt,
}

Functions

func NewExecutableSchema

func NewExecutableSchema(cfg Config) graphql.ExecutableSchema

NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.

Types

type Additive

type Additive struct {
	ID                  string               `json:"id"`
	Name                string               `json:"name"`
	Note                string               `json:"note"`
	CreatedAt           int                  `json:"createdAt"`
	UpdatedAt           int                  `json:"updatedAt"`
	DeletedAt           *int                 `json:"deletedAt"`
	RecipeAdditive      *RecipeAdditive      `json:"recipeAdditive"`
	RecipeBatchAdditive *RecipeBatchAdditive `json:"recipeBatchAdditive"`
	AdditiveInventories []*AdditiveInventory `json:"additiveInventories"`
}

func (Additive) IsNode

func (Additive) IsNode()

type AdditiveConnection

type AdditiveConnection struct {
	Edges    []*AdditiveEdge `json:"edges"`
	PageInfo *PageInfo       `json:"pageInfo"`
}

type AdditiveCreateInput

type AdditiveCreateInput struct {
	Name      string `json:"name"`
	Note      string `json:"note"`
	CreatedAt int    `json:"createdAt"`
	UpdatedAt int    `json:"updatedAt"`
	DeletedAt *int   `json:"deletedAt"`
}

type AdditiveDeletePayload

type AdditiveDeletePayload struct {
	ID string `json:"id"`
}

type AdditiveEdge

type AdditiveEdge struct {
	Cursor string    `json:"cursor"`
	Node   *Additive `json:"node"`
}

type AdditiveFilter

type AdditiveFilter struct {
	Search *string        `json:"search"`
	Where  *AdditiveWhere `json:"where"`
}

type AdditiveInventoriesDeletePayload

type AdditiveInventoriesDeletePayload struct {
	Ids []string `json:"ids"`
}

type AdditiveInventoriesUpdatePayload

type AdditiveInventoriesUpdatePayload struct {
	Ok bool `json:"ok"`
}

type AdditiveInventory

type AdditiveInventory struct {
	ID           string    `json:"id"`
	PurchaseDate int       `json:"purchaseDate"`
	ExpiryDate   int       `json:"expiryDate"`
	Cost         float64   `json:"cost"`
	Weight       float64   `json:"weight"`
	Additive     *Additive `json:"additive"`
	Supplier     *Supplier `json:"supplier"`
	CreatedAt    int       `json:"createdAt"`
	UpdatedAt    int       `json:"updatedAt"`
	DeletedAt    *int      `json:"deletedAt"`
}

func (AdditiveInventory) IsNode

func (AdditiveInventory) IsNode()

type AdditiveInventoryConnection

type AdditiveInventoryConnection struct {
	Edges    []*AdditiveInventoryEdge `json:"edges"`
	PageInfo *PageInfo                `json:"pageInfo"`
}

type AdditiveInventoryCreateInput

type AdditiveInventoryCreateInput struct {
	PurchaseDate int     `json:"purchaseDate"`
	ExpiryDate   int     `json:"expiryDate"`
	Cost         float64 `json:"cost"`
	Weight       float64 `json:"weight"`
	AdditiveID   string  `json:"additiveId"`
	SupplierID   string  `json:"supplierId"`
	CreatedAt    int     `json:"createdAt"`
	UpdatedAt    int     `json:"updatedAt"`
	DeletedAt    *int    `json:"deletedAt"`
}

type AdditiveInventoryDeletePayload

type AdditiveInventoryDeletePayload struct {
	ID string `json:"id"`
}

type AdditiveInventoryEdge

type AdditiveInventoryEdge struct {
	Cursor string             `json:"cursor"`
	Node   *AdditiveInventory `json:"node"`
}

type AdditiveInventoryFilter

type AdditiveInventoryFilter struct {
	Search *string                 `json:"search"`
	Where  *AdditiveInventoryWhere `json:"where"`
}

type AdditiveInventoryOrdering

type AdditiveInventoryOrdering struct {
	Sort      AdditiveInventorySort   `json:"sort"`
	Direction boilergql.SortDirection `json:"direction"`
}

type AdditiveInventoryPayload

type AdditiveInventoryPayload struct {
	AdditiveInventory *AdditiveInventory `json:"additiveInventory"`
}

type AdditiveInventorySort

type AdditiveInventorySort string

const (
	AdditiveInventorySortID           AdditiveInventorySort = "ID"
	AdditiveInventorySortPurchaseDate AdditiveInventorySort = "PURCHASE_DATE"
	AdditiveInventorySortExpiryDate   AdditiveInventorySort = "EXPIRY_DATE"
	AdditiveInventorySortCost         AdditiveInventorySort = "COST"
	AdditiveInventorySortWeight       AdditiveInventorySort = "WEIGHT"
	AdditiveInventorySortCreatedAt    AdditiveInventorySort = "CREATED_AT"
	AdditiveInventorySortUpdatedAt    AdditiveInventorySort = "UPDATED_AT"
	AdditiveInventorySortDeletedAt    AdditiveInventorySort = "DELETED_AT"
)

func (AdditiveInventorySort) IsValid

func (e AdditiveInventorySort) IsValid() bool

func (AdditiveInventorySort) MarshalGQL

func (e AdditiveInventorySort) MarshalGQL(w io.Writer)

func (AdditiveInventorySort) String

func (e AdditiveInventorySort) String() string

func (*AdditiveInventorySort) UnmarshalGQL

func (e *AdditiveInventorySort) UnmarshalGQL(v interface{}) error

type AdditiveInventoryUpdateInput

type AdditiveInventoryUpdateInput struct {
	PurchaseDate *int     `json:"purchaseDate"`
	ExpiryDate   *int     `json:"expiryDate"`
	Cost         *float64 `json:"cost"`
	Weight       *float64 `json:"weight"`
	AdditiveID   *string  `json:"additiveId"`
	SupplierID   *string  `json:"supplierId"`
	CreatedAt    *int     `json:"createdAt"`
	UpdatedAt    *int     `json:"updatedAt"`
	DeletedAt    *int     `json:"deletedAt"`
}

type AdditiveInventoryWhere

type AdditiveInventoryWhere struct {
	ID           *IDFilter               `json:"id"`
	PurchaseDate *IntFilter              `json:"purchaseDate"`
	ExpiryDate   *IntFilter              `json:"expiryDate"`
	Cost         *FloatFilter            `json:"cost"`
	Weight       *FloatFilter            `json:"weight"`
	Additive     *AdditiveWhere          `json:"additive"`
	Supplier     *SupplierWhere          `json:"supplier"`
	CreatedAt    *IntFilter              `json:"createdAt"`
	UpdatedAt    *IntFilter              `json:"updatedAt"`
	DeletedAt    *IntFilter              `json:"deletedAt"`
	Or           *AdditiveInventoryWhere `json:"or"`
	And          *AdditiveInventoryWhere `json:"and"`
}

type AdditiveOrdering

type AdditiveOrdering struct {
	Sort      AdditiveSort            `json:"sort"`
	Direction boilergql.SortDirection `json:"direction"`
}

type AdditivePayload

type AdditivePayload struct {
	Additive *Additive `json:"additive"`
}

type AdditiveSort

type AdditiveSort string

const (
	AdditiveSortID        AdditiveSort = "ID"
	AdditiveSortName      AdditiveSort = "NAME"
	AdditiveSortNote      AdditiveSort = "NOTE"
	AdditiveSortCreatedAt AdditiveSort = "CREATED_AT"
	AdditiveSortUpdatedAt AdditiveSort = "UPDATED_AT"
	AdditiveSortDeletedAt AdditiveSort = "DELETED_AT"
)

func (AdditiveSort) IsValid

func (e AdditiveSort) IsValid() bool

func (AdditiveSort) MarshalGQL

func (e AdditiveSort) MarshalGQL(w io.Writer)

func (AdditiveSort) String

func (e AdditiveSort) String() string

func (*AdditiveSort) UnmarshalGQL

func (e *AdditiveSort) UnmarshalGQL(v interface{}) error

type AdditiveUpdateInput

type AdditiveUpdateInput struct {
	Name      *string `json:"name"`
	Note      *string `json:"note"`
	CreatedAt *int    `json:"createdAt"`
	UpdatedAt *int    `json:"updatedAt"`
	DeletedAt *int    `json:"deletedAt"`
}

type AdditiveWhere

type AdditiveWhere struct {
	ID                  *IDFilter                 `json:"id"`
	Name                *StringFilter             `json:"name"`
	Note                *StringFilter             `json:"note"`
	CreatedAt           *IntFilter                `json:"createdAt"`
	UpdatedAt           *IntFilter                `json:"updatedAt"`
	DeletedAt           *IntFilter                `json:"deletedAt"`
	RecipeAdditive      *RecipeAdditiveWhere      `json:"recipeAdditive"`
	RecipeBatchAdditive *RecipeBatchAdditiveWhere `json:"recipeBatchAdditive"`
	AdditiveInventories *AdditiveInventoryWhere   `json:"additiveInventories"`
	Or                  *AdditiveWhere            `json:"or"`
	And                 *AdditiveWhere            `json:"and"`
}

type AdditivesDeletePayload

type AdditivesDeletePayload struct {
	Ids []string `json:"ids"`
}

type AdditivesUpdatePayload

type AdditivesUpdatePayload struct {
	Ok bool `json:"ok"`
}

type AuthGroup

type AuthGroup struct {
	ID                        string                 `json:"id"`
	Name                      string                 `json:"name"`
	GroupAuthGroupPermissions []*AuthGroupPermission `json:"groupAuthGroupPermissions"`
	GroupAuthUserGroups       []*AuthUserGroup       `json:"groupAuthUserGroups"`
}

func (AuthGroup) IsNode

func (AuthGroup) IsNode()

type AuthGroupConnection

type AuthGroupConnection struct {
	Edges    []*AuthGroupEdge `json:"edges"`
	PageInfo *PageInfo        `json:"pageInfo"`
}

type AuthGroupCreateInput

type AuthGroupCreateInput struct {
	Name string `json:"name"`
}

type AuthGroupDeletePayload

type AuthGroupDeletePayload struct {
	ID string `json:"id"`
}

type AuthGroupEdge

type AuthGroupEdge struct {
	Cursor string     `json:"cursor"`
	Node   *AuthGroup `json:"node"`
}

type AuthGroupFilter

type AuthGroupFilter struct {
	Search *string         `json:"search"`
	Where  *AuthGroupWhere `json:"where"`
}

type AuthGroupOrdering

type AuthGroupOrdering struct {
	Sort      AuthGroupSort           `json:"sort"`
	Direction boilergql.SortDirection `json:"direction"`
}

type AuthGroupPayload

type AuthGroupPayload struct {
	AuthGroup *AuthGroup `json:"authGroup"`
}

type AuthGroupPermission

type AuthGroupPermission struct {
	ID         string          `json:"id"`
	Group      *AuthGroup      `json:"group"`
	Permission *AuthPermission `json:"permission"`
}

func (AuthGroupPermission) IsNode

func (AuthGroupPermission) IsNode()

type AuthGroupPermissionConnection

type AuthGroupPermissionConnection struct {
	Edges    []*AuthGroupPermissionEdge `json:"edges"`
	PageInfo *PageInfo                  `json:"pageInfo"`
}

type AuthGroupPermissionCreateInput

type AuthGroupPermissionCreateInput struct {
	GroupID      string `json:"groupId"`
	PermissionID string `json:"permissionId"`
}

type AuthGroupPermissionDeletePayload

type AuthGroupPermissionDeletePayload struct {
	ID string `json:"id"`
}

type AuthGroupPermissionEdge

type AuthGroupPermissionEdge struct {
	Cursor string               `json:"cursor"`
	Node   *AuthGroupPermission `json:"node"`
}

type AuthGroupPermissionFilter

type AuthGroupPermissionFilter struct {
	Search *string                   `json:"search"`
	Where  *AuthGroupPermissionWhere `json:"where"`
}

type AuthGroupPermissionOrdering

type AuthGroupPermissionOrdering struct {
	Sort      AuthGroupPermissionSort `json:"sort"`
	Direction boilergql.SortDirection `json:"direction"`
}

type AuthGroupPermissionPayload

type AuthGroupPermissionPayload struct {
	AuthGroupPermission *AuthGroupPermission `json:"authGroupPermission"`
}

type AuthGroupPermissionSort

type AuthGroupPermissionSort string

const (
	AuthGroupPermissionSortID AuthGroupPermissionSort = "ID"
)

func (AuthGroupPermissionSort) IsValid

func (e AuthGroupPermissionSort) IsValid() bool

func (AuthGroupPermissionSort) MarshalGQL

func (e AuthGroupPermissionSort) MarshalGQL(w io.Writer)

func (AuthGroupPermissionSort) String

func (e AuthGroupPermissionSort) String() string

func (*AuthGroupPermissionSort) UnmarshalGQL

func (e *AuthGroupPermissionSort) UnmarshalGQL(v interface{}) error

type AuthGroupPermissionUpdateInput

type AuthGroupPermissionUpdateInput struct {
	GroupID      *string `json:"groupId"`
	PermissionID *string `json:"permissionId"`
}

type AuthGroupPermissionWhere

type AuthGroupPermissionWhere struct {
	ID         *IDFilter                 `json:"id"`
	Group      *AuthGroupWhere           `json:"group"`
	Permission *AuthPermissionWhere      `json:"permission"`
	Or         *AuthGroupPermissionWhere `json:"or"`
	And        *AuthGroupPermissionWhere `json:"and"`
}

type AuthGroupPermissionsDeletePayload

type AuthGroupPermissionsDeletePayload struct {
	Ids []string `json:"ids"`
}

type AuthGroupPermissionsUpdatePayload

type AuthGroupPermissionsUpdatePayload struct {
	Ok bool `json:"ok"`
}

type AuthGroupSort

type AuthGroupSort string

const (
	AuthGroupSortID   AuthGroupSort = "ID"
	AuthGroupSortName AuthGroupSort = "NAME"
)

func (AuthGroupSort) IsValid

func (e AuthGroupSort) IsValid() bool

func (AuthGroupSort) MarshalGQL

func (e AuthGroupSort) MarshalGQL(w io.Writer)

func (AuthGroupSort) String

func (e AuthGroupSort) String() string

func (*AuthGroupSort) UnmarshalGQL

func (e *AuthGroupSort) UnmarshalGQL(v interface{}) error

type AuthGroupUpdateInput

type AuthGroupUpdateInput struct {
	Name *string `json:"name"`
}

type AuthGroupWhere

type AuthGroupWhere struct {
	ID                        *IDFilter                 `json:"id"`
	Name                      *StringFilter             `json:"name"`
	GroupAuthGroupPermissions *AuthGroupPermissionWhere `json:"groupAuthGroupPermissions"`
	GroupAuthUserGroups       *AuthUserGroupWhere       `json:"groupAuthUserGroups"`
	Or                        *AuthGroupWhere           `json:"or"`
	And                       *AuthGroupWhere           `json:"and"`
}

type AuthGroupsDeletePayload

type AuthGroupsDeletePayload struct {
	Ids []string `json:"ids"`
}

type AuthGroupsUpdatePayload

type AuthGroupsUpdatePayload struct {
	Ok bool `json:"ok"`
}

type AuthPermission

type AuthPermission struct {
	ID                                string                    `json:"id"`
	Name                              string                    `json:"name"`
	ContentTypeID                     string                    `json:"contentTypeId"`
	Codename                          string                    `json:"codename"`
	PermissionAuthGroupPermissions    []*AuthGroupPermission    `json:"permissionAuthGroupPermissions"`
	PermissionAuthUserUserPermissions []*AuthUserUserPermission `json:"permissionAuthUserUserPermissions"`
}

func (AuthPermission) IsNode

func (AuthPermission) IsNode()

type AuthPermissionConnection

type AuthPermissionConnection struct {
	Edges    []*AuthPermissionEdge `json:"edges"`
	PageInfo *PageInfo             `json:"pageInfo"`
}

type AuthPermissionCreateInput

type AuthPermissionCreateInput struct {
	Name          string `json:"name"`
	ContentTypeID string `json:"contentTypeId"`
	Codename      string `json:"codename"`
}

type AuthPermissionDeletePayload

type AuthPermissionDeletePayload struct {
	ID string `json:"id"`
}

type AuthPermissionEdge

type AuthPermissionEdge struct {
	Cursor string          `json:"cursor"`
	Node   *AuthPermission `json:"node"`
}

type AuthPermissionFilter

type AuthPermissionFilter struct {
	Search *string              `json:"search"`
	Where  *AuthPermissionWhere `json:"where"`
}

type AuthPermissionOrdering

type AuthPermissionOrdering struct {
	Sort      AuthPermissionSort      `json:"sort"`
	Direction boilergql.SortDirection `json:"direction"`
}

type AuthPermissionPayload

type AuthPermissionPayload struct {
	AuthPermission *AuthPermission `json:"authPermission"`
}

type AuthPermissionSort

type AuthPermissionSort string

const (
	AuthPermissionSortID       AuthPermissionSort = "ID"
	AuthPermissionSortName     AuthPermissionSort = "NAME"
	AuthPermissionSortCodename AuthPermissionSort = "CODENAME"
)

func (AuthPermissionSort) IsValid

func (e AuthPermissionSort) IsValid() bool

func (AuthPermissionSort) MarshalGQL

func (e AuthPermissionSort) MarshalGQL(w io.Writer)

func (AuthPermissionSort) String

func (e AuthPermissionSort) String() string

func (*AuthPermissionSort) UnmarshalGQL

func (e *AuthPermissionSort) UnmarshalGQL(v interface{}) error

type AuthPermissionUpdateInput

type AuthPermissionUpdateInput struct {
	Name          *string `json:"name"`
	ContentTypeID *string `json:"contentTypeId"`
	Codename      *string `json:"codename"`
}

type AuthPermissionWhere

type AuthPermissionWhere struct {
	ID                                *IDFilter                    `json:"id"`
	Name                              *StringFilter                `json:"name"`
	ContentTypeID                     *IDFilter                    `json:"contentTypeId"`
	Codename                          *StringFilter                `json:"codename"`
	PermissionAuthGroupPermissions    *AuthGroupPermissionWhere    `json:"permissionAuthGroupPermissions"`
	PermissionAuthUserUserPermissions *AuthUserUserPermissionWhere `json:"permissionAuthUserUserPermissions"`
	Or                                *AuthPermissionWhere         `json:"or"`
	And                               *AuthPermissionWhere         `json:"and"`
}

type AuthPermissionsDeletePayload

type AuthPermissionsDeletePayload struct {
	Ids []string `json:"ids"`
}

type AuthPermissionsUpdatePayload

type AuthPermissionsUpdatePayload struct {
	Ok bool `json:"ok"`
}

type AuthUser

type AuthUser struct {
	ID                          string                    `json:"id"`
	Password                    string                    `json:"password"`
	LastLogin                   *int                      `json:"lastLogin"`
	IsSuperuser                 bool                      `json:"isSuperuser"`
	Username                    string                    `json:"username"`
	FirstName                   string                    `json:"firstName"`
	LastName                    string                    `json:"lastName"`
	Email                       string                    `json:"email"`
	IsStaff                     bool                      `json:"isStaff"`
	IsActive                    bool                      `json:"isActive"`
	DateJoined                  int                       `json:"dateJoined"`
	UserAuthUserGroups          []*AuthUserGroup          `json:"userAuthUserGroups"`
	UserAuthUserUserPermissions []*AuthUserUserPermission `json:"userAuthUserUserPermissions"`
}

func (AuthUser) IsNode

func (AuthUser) IsNode()

type AuthUserConnection

type AuthUserConnection struct {
	Edges    []*AuthUserEdge `json:"edges"`
	PageInfo *PageInfo       `json:"pageInfo"`
}

type AuthUserCreateInput

type AuthUserCreateInput struct {
	Password    string `json:"password"`
	LastLogin   *int   `json:"lastLogin"`
	IsSuperuser bool   `json:"isSuperuser"`
	Username    string `json:"username"`
	FirstName   string `json:"firstName"`
	LastName    string `json:"lastName"`
	Email       string `json:"email"`
	IsStaff     bool   `json:"isStaff"`
	IsActive    bool   `json:"isActive"`
	DateJoined  int    `json:"dateJoined"`
}

type AuthUserDeletePayload

type AuthUserDeletePayload struct {
	ID string `json:"id"`
}

type AuthUserEdge

type AuthUserEdge struct {
	Cursor string    `json:"cursor"`
	Node   *AuthUser `json:"node"`
}

type AuthUserFilter

type AuthUserFilter struct {
	Search *string        `json:"search"`
	Where  *AuthUserWhere `json:"where"`
}

type AuthUserGroup

type AuthUserGroup struct {
	ID    string     `json:"id"`
	User  *AuthUser  `json:"user"`
	Group *AuthGroup `json:"group"`
}

func (AuthUserGroup) IsNode

func (AuthUserGroup) IsNode()

type AuthUserGroupConnection

type AuthUserGroupConnection struct {
	Edges    []*AuthUserGroupEdge `json:"edges"`
	PageInfo *PageInfo            `json:"pageInfo"`
}

type AuthUserGroupCreateInput

type AuthUserGroupCreateInput struct {
	UserID  string `json:"userId"`
	GroupID string `json:"groupId"`
}

type AuthUserGroupDeletePayload

type AuthUserGroupDeletePayload struct {
	ID string `json:"id"`
}

type AuthUserGroupEdge

type AuthUserGroupEdge struct {
	Cursor string         `json:"cursor"`
	Node   *AuthUserGroup `json:"node"`
}

type AuthUserGroupFilter

type AuthUserGroupFilter struct {
	Search *string             `json:"search"`
	Where  *AuthUserGroupWhere `json:"where"`
}

type AuthUserGroupOrdering

type AuthUserGroupOrdering struct {
	Sort      AuthUserGroupSort       `json:"sort"`
	Direction boilergql.SortDirection `json:"direction"`
}

type AuthUserGroupPayload

type AuthUserGroupPayload struct {
	AuthUserGroup *AuthUserGroup `json:"authUserGroup"`
}

type AuthUserGroupSort

type AuthUserGroupSort string

const (
	AuthUserGroupSortID AuthUserGroupSort = "ID"
)

func (AuthUserGroupSort) IsValid

func (e AuthUserGroupSort) IsValid() bool

func (AuthUserGroupSort) MarshalGQL

func (e AuthUserGroupSort) MarshalGQL(w io.Writer)

func (AuthUserGroupSort) String

func (e AuthUserGroupSort) String() string

func (*AuthUserGroupSort) UnmarshalGQL

func (e *AuthUserGroupSort) UnmarshalGQL(v interface{}) error

type AuthUserGroupUpdateInput

type AuthUserGroupUpdateInput struct {
	UserID  *string `json:"userId"`
	GroupID *string `json:"groupId"`
}

type AuthUserGroupWhere

type AuthUserGroupWhere struct {
	ID    *IDFilter           `json:"id"`
	User  *AuthUserWhere      `json:"user"`
	Group *AuthGroupWhere     `json:"group"`
	Or    *AuthUserGroupWhere `json:"or"`
	And   *AuthUserGroupWhere `json:"and"`
}

type AuthUserGroupsDeletePayload

type AuthUserGroupsDeletePayload struct {
	Ids []string `json:"ids"`
}

type AuthUserGroupsUpdatePayload

type AuthUserGroupsUpdatePayload struct {
	Ok bool `json:"ok"`
}

type AuthUserOrdering

type AuthUserOrdering struct {
	Sort      AuthUserSort            `json:"sort"`
	Direction boilergql.SortDirection `json:"direction"`
}

type AuthUserPayload

type AuthUserPayload struct {
	AuthUser *AuthUser `json:"authUser"`
}

type AuthUserSort

type AuthUserSort string

const (
	AuthUserSortID          AuthUserSort = "ID"
	AuthUserSortPassword    AuthUserSort = "PASSWORD"
	AuthUserSortLastLogin   AuthUserSort = "LAST_LOGIN"
	AuthUserSortIsSuperuser AuthUserSort = "IS_SUPERUSER"
	AuthUserSortUsername    AuthUserSort = "USERNAME"
	AuthUserSortFirstName   AuthUserSort = "FIRST_NAME"
	AuthUserSortLastName    AuthUserSort = "LAST_NAME"
	AuthUserSortEmail       AuthUserSort = "EMAIL"
	AuthUserSortIsStaff     AuthUserSort = "IS_STAFF"
	AuthUserSortIsActive    AuthUserSort = "IS_ACTIVE"
	AuthUserSortDateJoined  AuthUserSort = "DATE_JOINED"
)

func (AuthUserSort) IsValid

func (e AuthUserSort) IsValid() bool

func (AuthUserSort) MarshalGQL

func (e AuthUserSort) MarshalGQL(w io.Writer)

func (AuthUserSort) String

func (e AuthUserSort) String() string

func (*AuthUserSort) UnmarshalGQL

func (e *AuthUserSort) UnmarshalGQL(v interface{}) error

type AuthUserUpdateInput

type AuthUserUpdateInput struct {
	Password    *string `json:"password"`
	LastLogin   *int    `json:"lastLogin"`
	IsSuperuser *bool   `json:"isSuperuser"`
	Username    *string `json:"username"`
	FirstName   *string `json:"firstName"`
	LastName    *string `json:"lastName"`
	Email       *string `json:"email"`
	IsStaff     *bool   `json:"isStaff"`
	IsActive    *bool   `json:"isActive"`
	DateJoined  *int    `json:"dateJoined"`
}

type AuthUserUserPermission

type AuthUserUserPermission struct {
	ID         string          `json:"id"`
	User       *AuthUser       `json:"user"`
	Permission *AuthPermission `json:"permission"`
}

func (AuthUserUserPermission) IsNode

func (AuthUserUserPermission) IsNode()

type AuthUserUserPermissionConnection

type AuthUserUserPermissionConnection struct {
	Edges    []*AuthUserUserPermissionEdge `json:"edges"`
	PageInfo *PageInfo                     `json:"pageInfo"`
}

type AuthUserUserPermissionCreateInput

type AuthUserUserPermissionCreateInput struct {
	UserID       string `json:"userId"`
	PermissionID string `json:"permissionId"`
}

type AuthUserUserPermissionDeletePayload

type AuthUserUserPermissionDeletePayload struct {
	ID string `json:"id"`
}

type AuthUserUserPermissionEdge

type AuthUserUserPermissionEdge struct {
	Cursor string                  `json:"cursor"`
	Node   *AuthUserUserPermission `json:"node"`
}

type AuthUserUserPermissionFilter

type AuthUserUserPermissionFilter struct {
	Search *string                      `json:"search"`
	Where  *AuthUserUserPermissionWhere `json:"where"`
}

type AuthUserUserPermissionOrdering

type AuthUserUserPermissionOrdering struct {
	Sort      AuthUserUserPermissionSort `json:"sort"`
	Direction boilergql.SortDirection    `json:"direction"`
}

type AuthUserUserPermissionPayload

type AuthUserUserPermissionPayload struct {
	AuthUserUserPermission *AuthUserUserPermission `json:"authUserUserPermission"`
}

type AuthUserUserPermissionSort

type AuthUserUserPermissionSort string

const (
	AuthUserUserPermissionSortID AuthUserUserPermissionSort = "ID"
)

func (AuthUserUserPermissionSort) IsValid

func (e AuthUserUserPermissionSort) IsValid() bool

func (AuthUserUserPermissionSort) MarshalGQL

func (e AuthUserUserPermissionSort) MarshalGQL(w io.Writer)

func (AuthUserUserPermissionSort) String

func (e AuthUserUserPermissionSort) String() string

func (*AuthUserUserPermissionSort) UnmarshalGQL

func (e *AuthUserUserPermissionSort) UnmarshalGQL(v interface{}) error

type AuthUserUserPermissionUpdateInput

type AuthUserUserPermissionUpdateInput struct {
	UserID       *string `json:"userId"`
	PermissionID *string `json:"permissionId"`
}

type AuthUserUserPermissionWhere

type AuthUserUserPermissionWhere struct {
	ID         *IDFilter                    `json:"id"`
	User       *AuthUserWhere               `json:"user"`
	Permission *AuthPermissionWhere         `json:"permission"`
	Or         *AuthUserUserPermissionWhere `json:"or"`
	And        *AuthUserUserPermissionWhere `json:"and"`
}

type AuthUserUserPermissionsDeletePayload

type AuthUserUserPermissionsDeletePayload struct {
	Ids []string `json:"ids"`
}

type AuthUserUserPermissionsUpdatePayload

type AuthUserUserPermissionsUpdatePayload struct {
	Ok bool `json:"ok"`
}

type AuthUserWhere

type AuthUserWhere struct {
	ID                          *IDFilter                    `json:"id"`
	Password                    *StringFilter                `json:"password"`
	LastLogin                   *IntFilter                   `json:"lastLogin"`
	IsSuperuser                 *BooleanFilter               `json:"isSuperuser"`
	Username                    *StringFilter                `json:"username"`
	FirstName                   *StringFilter                `json:"firstName"`
	LastName                    *StringFilter                `json:"lastName"`
	Email                       *StringFilter                `json:"email"`
	IsStaff                     *BooleanFilter               `json:"isStaff"`
	IsActive                    *BooleanFilter               `json:"isActive"`
	DateJoined                  *IntFilter                   `json:"dateJoined"`
	UserAuthUserGroups          *AuthUserGroupWhere          `json:"userAuthUserGroups"`
	UserAuthUserUserPermissions *AuthUserUserPermissionWhere `json:"userAuthUserUserPermissions"`
	Or                          *AuthUserWhere               `json:"or"`
	And                         *AuthUserWhere               `json:"and"`
}

type AuthUsersDeletePayload

type AuthUsersDeletePayload struct {
	Ids []string `json:"ids"`
}

type AuthUsersUpdatePayload

type AuthUsersUpdatePayload struct {
	Ok bool `json:"ok"`
}

type BooleanFilter

type BooleanFilter struct {
	EqualTo    *bool `json:"equalTo"`
	NotEqualTo *bool `json:"notEqualTo"`
}

type ComplexityRoot

type ComplexityRoot struct {
	Additive struct {
		AdditiveInventories func(childComplexity int) int
		CreatedAt           func(childComplexity int) int
		DeletedAt           func(childComplexity int) int
		ID                  func(childComplexity int) int
		Name                func(childComplexity int) int
		Note                func(childComplexity int) int
		RecipeAdditive      func(childComplexity int) int
		RecipeBatchAdditive func(childComplexity int) int
		UpdatedAt           func(childComplexity int) int
	}

	AdditiveConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	AdditiveDeletePayload struct {
		ID func(childComplexity int) int
	}

	AdditiveEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	AdditiveInventoriesDeletePayload struct {
		Ids func(childComplexity int) int
	}

	AdditiveInventoriesUpdatePayload struct {
		Ok func(childComplexity int) int
	}

	AdditiveInventory struct {
		Additive     func(childComplexity int) int
		Cost         func(childComplexity int) int
		CreatedAt    func(childComplexity int) int
		DeletedAt    func(childComplexity int) int
		ExpiryDate   func(childComplexity int) int
		ID           func(childComplexity int) int
		PurchaseDate func(childComplexity int) int
		Supplier     func(childComplexity int) int
		UpdatedAt    func(childComplexity int) int
		Weight       func(childComplexity int) int
	}

	AdditiveInventoryConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	AdditiveInventoryDeletePayload struct {
		ID func(childComplexity int) int
	}

	AdditiveInventoryEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	AdditiveInventoryPayload struct {
		AdditiveInventory func(childComplexity int) int
	}

	AdditivePayload struct {
		Additive func(childComplexity int) int
	}

	AdditivesDeletePayload struct {
		Ids func(childComplexity int) int
	}

	AdditivesUpdatePayload struct {
		Ok func(childComplexity int) int
	}

	AuthGroup struct {
		GroupAuthGroupPermissions func(childComplexity int) int
		GroupAuthUserGroups       func(childComplexity int) int
		ID                        func(childComplexity int) int
		Name                      func(childComplexity int) int
	}

	AuthGroupConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	AuthGroupDeletePayload struct {
		ID func(childComplexity int) int
	}

	AuthGroupEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	AuthGroupPayload struct {
		AuthGroup func(childComplexity int) int
	}

	AuthGroupPermission struct {
		Group      func(childComplexity int) int
		ID         func(childComplexity int) int
		Permission func(childComplexity int) int
	}

	AuthGroupPermissionConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	AuthGroupPermissionDeletePayload struct {
		ID func(childComplexity int) int
	}

	AuthGroupPermissionEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	AuthGroupPermissionPayload struct {
		AuthGroupPermission func(childComplexity int) int
	}

	AuthGroupPermissionsDeletePayload struct {
		Ids func(childComplexity int) int
	}

	AuthGroupPermissionsUpdatePayload struct {
		Ok func(childComplexity int) int
	}

	AuthGroupsDeletePayload struct {
		Ids func(childComplexity int) int
	}

	AuthGroupsUpdatePayload struct {
		Ok func(childComplexity int) int
	}

	AuthPermission struct {
		Codename                          func(childComplexity int) int
		ContentTypeID                     func(childComplexity int) int
		ID                                func(childComplexity int) int
		Name                              func(childComplexity int) int
		PermissionAuthGroupPermissions    func(childComplexity int) int
		PermissionAuthUserUserPermissions func(childComplexity int) int
	}

	AuthPermissionConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	AuthPermissionDeletePayload struct {
		ID func(childComplexity int) int
	}

	AuthPermissionEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	AuthPermissionPayload struct {
		AuthPermission func(childComplexity int) int
	}

	AuthPermissionsDeletePayload struct {
		Ids func(childComplexity int) int
	}

	AuthPermissionsUpdatePayload struct {
		Ok func(childComplexity int) int
	}

	AuthUser struct {
		DateJoined                  func(childComplexity int) int
		Email                       func(childComplexity int) int
		FirstName                   func(childComplexity int) int
		ID                          func(childComplexity int) int
		IsActive                    func(childComplexity int) int
		IsStaff                     func(childComplexity int) int
		IsSuperuser                 func(childComplexity int) int
		LastLogin                   func(childComplexity int) int
		LastName                    func(childComplexity int) int
		Password                    func(childComplexity int) int
		UserAuthUserGroups          func(childComplexity int) int
		UserAuthUserUserPermissions func(childComplexity int) int
		Username                    func(childComplexity int) int
	}

	AuthUserConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	AuthUserDeletePayload struct {
		ID func(childComplexity int) int
	}

	AuthUserEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	AuthUserGroup struct {
		Group func(childComplexity int) int
		ID    func(childComplexity int) int
		User  func(childComplexity int) int
	}

	AuthUserGroupConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	AuthUserGroupDeletePayload struct {
		ID func(childComplexity int) int
	}

	AuthUserGroupEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	AuthUserGroupPayload struct {
		AuthUserGroup func(childComplexity int) int
	}

	AuthUserGroupsDeletePayload struct {
		Ids func(childComplexity int) int
	}

	AuthUserGroupsUpdatePayload struct {
		Ok func(childComplexity int) int
	}

	AuthUserPayload struct {
		AuthUser func(childComplexity int) int
	}

	AuthUserUserPermission struct {
		ID         func(childComplexity int) int
		Permission func(childComplexity int) int
		User       func(childComplexity int) int
	}

	AuthUserUserPermissionConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	AuthUserUserPermissionDeletePayload struct {
		ID func(childComplexity int) int
	}

	AuthUserUserPermissionEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	AuthUserUserPermissionPayload struct {
		AuthUserUserPermission func(childComplexity int) int
	}

	AuthUserUserPermissionsDeletePayload struct {
		Ids func(childComplexity int) int
	}

	AuthUserUserPermissionsUpdatePayload struct {
		Ok func(childComplexity int) int
	}

	AuthUsersDeletePayload struct {
		Ids func(childComplexity int) int
	}

	AuthUsersUpdatePayload struct {
		Ok func(childComplexity int) int
	}

	Fragrance struct {
		CreatedAt            func(childComplexity int) int
		DeletedAt            func(childComplexity int) int
		FragranceInventories func(childComplexity int) int
		ID                   func(childComplexity int) int
		Name                 func(childComplexity int) int
		Note                 func(childComplexity int) int
		RecipeBatchFragrance func(childComplexity int) int
		RecipeFragrance      func(childComplexity int) int
		UpdatedAt            func(childComplexity int) int
	}

	FragranceConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	FragranceDeletePayload struct {
		ID func(childComplexity int) int
	}

	FragranceEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	FragranceInventoriesDeletePayload struct {
		Ids func(childComplexity int) int
	}

	FragranceInventoriesUpdatePayload struct {
		Ok func(childComplexity int) int
	}

	FragranceInventory struct {
		Cost         func(childComplexity int) int
		CreatedAt    func(childComplexity int) int
		DeletedAt    func(childComplexity int) int
		ExpiryDate   func(childComplexity int) int
		Fragrance    func(childComplexity int) int
		ID           func(childComplexity int) int
		PurchaseDate func(childComplexity int) int
		Supplier     func(childComplexity int) int
		UpdatedAt    func(childComplexity int) int
		Weight       func(childComplexity int) int
	}

	FragranceInventoryConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	FragranceInventoryDeletePayload struct {
		ID func(childComplexity int) int
	}

	FragranceInventoryEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	FragranceInventoryPayload struct {
		FragranceInventory func(childComplexity int) int
	}

	FragrancePayload struct {
		Fragrance func(childComplexity int) int
	}

	FragrancesDeletePayload struct {
		Ids func(childComplexity int) int
	}

	FragrancesUpdatePayload struct {
		Ok func(childComplexity int) int
	}

	Lipid struct {
		Bubbly           func(childComplexity int) int
		Cleansing        func(childComplexity int) int
		Conditioning     func(childComplexity int) int
		Creamy           func(childComplexity int) int
		CreatedAt        func(childComplexity int) int
		DeletedAt        func(childComplexity int) int
		Family           func(childComplexity int) int
		Hardness         func(childComplexity int) int
		ID               func(childComplexity int) int
		InciName         func(childComplexity int) int
		Ins              func(childComplexity int) int
		Iodine           func(childComplexity int) int
		Lauric           func(childComplexity int) int
		Linoleic         func(childComplexity int) int
		Linolenic        func(childComplexity int) int
		LipidInventories func(childComplexity int) int
		Myristic         func(childComplexity int) int
		Name             func(childComplexity int) int
		Naoh             func(childComplexity int) int
		Oleic            func(childComplexity int) int
		Palmitic         func(childComplexity int) int
		RecipeBatchLipid func(childComplexity int) int
		RecipeLipid      func(childComplexity int) int
		Ricinoleic       func(childComplexity int) int
		Stearic          func(childComplexity int) int
		UpdatedAt        func(childComplexity int) int
	}

	LipidConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	LipidDeletePayload struct {
		ID func(childComplexity int) int
	}

	LipidEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	LipidInventoriesDeletePayload struct {
		Ids func(childComplexity int) int
	}

	LipidInventoriesUpdatePayload struct {
		Ok func(childComplexity int) int
	}

	LipidInventory struct {
		Cost          func(childComplexity int) int
		CreatedAt     func(childComplexity int) int
		DeletedAt     func(childComplexity int) int
		ExpiryDate    func(childComplexity int) int
		GramsPerLiter func(childComplexity int) int
		ID            func(childComplexity int) int
		Koh           func(childComplexity int) int
		Lipid         func(childComplexity int) int
		Naoh          func(childComplexity int) int
		PurchaseDate  func(childComplexity int) int
		Sap           func(childComplexity int) int
		Supplier      func(childComplexity int) int
		UpdatedAt     func(childComplexity int) int
		Weight        func(childComplexity int) int
	}

	LipidInventoryConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	LipidInventoryDeletePayload struct {
		ID func(childComplexity int) int
	}

	LipidInventoryEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	LipidInventoryPayload struct {
		LipidInventory func(childComplexity int) int
	}

	LipidPayload struct {
		Lipid func(childComplexity int) int
	}

	LipidsDeletePayload struct {
		Ids func(childComplexity int) int
	}

	LipidsUpdatePayload struct {
		Ok func(childComplexity int) int
	}

	Lye struct {
		CreatedAt      func(childComplexity int) int
		DeletedAt      func(childComplexity int) int
		ID             func(childComplexity int) int
		Kind           func(childComplexity int) int
		LyeInventories func(childComplexity int) int
		Name           func(childComplexity int) int
		Note           func(childComplexity int) int
		RecipeBatchLye func(childComplexity int) int
		UpdatedAt      func(childComplexity int) int
	}

	LyeConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	LyeDeletePayload struct {
		ID func(childComplexity int) int
	}

	LyeEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	LyeInventoriesDeletePayload struct {
		Ids func(childComplexity int) int
	}

	LyeInventoriesUpdatePayload struct {
		Ok func(childComplexity int) int
	}

	LyeInventory struct {
		Concentration func(childComplexity int) int
		Cost          func(childComplexity int) int
		CreatedAt     func(childComplexity int) int
		DeletedAt     func(childComplexity int) int
		ExpiryDate    func(childComplexity int) int
		ID            func(childComplexity int) int
		Lye           func(childComplexity int) int
		PurchaseDate  func(childComplexity int) int
		Supplier      func(childComplexity int) int
		UpdatedAt     func(childComplexity int) int
		Weight        func(childComplexity int) int
	}

	LyeInventoryConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	LyeInventoryDeletePayload struct {
		ID func(childComplexity int) int
	}

	LyeInventoryEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	LyeInventoryPayload struct {
		LyeInventory func(childComplexity int) int
	}

	LyePayload struct {
		Lye func(childComplexity int) int
	}

	LyesDeletePayload struct {
		Ids func(childComplexity int) int
	}

	LyesUpdatePayload struct {
		Ok func(childComplexity int) int
	}

	Mutation struct {
		CreateAdditive                func(childComplexity int, input AdditiveCreateInput) int
		CreateAdditiveInventory       func(childComplexity int, input AdditiveInventoryCreateInput) int
		CreateAuthGroup               func(childComplexity int, input AuthGroupCreateInput) int
		CreateAuthGroupPermission     func(childComplexity int, input AuthGroupPermissionCreateInput) int
		CreateAuthPermission          func(childComplexity int, input AuthPermissionCreateInput) int
		CreateAuthUser                func(childComplexity int, input AuthUserCreateInput) int
		CreateAuthUserGroup           func(childComplexity int, input AuthUserGroupCreateInput) int
		CreateAuthUserUserPermission  func(childComplexity int, input AuthUserUserPermissionCreateInput) int
		CreateFragrance               func(childComplexity int, input FragranceCreateInput) int
		CreateFragranceInventory      func(childComplexity int, input FragranceInventoryCreateInput) int
		CreateLipid                   func(childComplexity int, input LipidCreateInput) int
		CreateLipidInventory          func(childComplexity int, input LipidInventoryCreateInput) int
		CreateLye                     func(childComplexity int, input LyeCreateInput) int
		CreateLyeInventory            func(childComplexity int, input LyeInventoryCreateInput) int
		CreateRecipe                  func(childComplexity int, input RecipeCreateInput) int
		CreateRecipeAdditive          func(childComplexity int, input RecipeAdditiveCreateInput) int
		CreateRecipeBatch             func(childComplexity int, input RecipeBatchCreateInput) int
		CreateRecipeBatchAdditive     func(childComplexity int, input RecipeBatchAdditiveCreateInput) int
		CreateRecipeBatchFragrance    func(childComplexity int, input RecipeBatchFragranceCreateInput) int
		CreateRecipeBatchLipid        func(childComplexity int, input RecipeBatchLipidCreateInput) int
		CreateRecipeBatchLye          func(childComplexity int, input RecipeBatchLyeCreateInput) int
		CreateRecipeBatchNote         func(childComplexity int, input RecipeBatchNoteCreateInput) int
		CreateRecipeFragrance         func(childComplexity int, input RecipeFragranceCreateInput) int
		CreateRecipeLipid             func(childComplexity int, input RecipeLipidCreateInput) int
		CreateRecipeStep              func(childComplexity int, input RecipeStepCreateInput) int
		CreateSupplier                func(childComplexity int, input SupplierCreateInput) int
		DeleteAdditive                func(childComplexity int, id string) int
		DeleteAdditiveInventories     func(childComplexity int, filter *AdditiveInventoryFilter) int
		DeleteAdditiveInventory       func(childComplexity int, id string) int
		DeleteAdditives               func(childComplexity int, filter *AdditiveFilter) int
		DeleteAuthGroup               func(childComplexity int, id string) int
		DeleteAuthGroupPermission     func(childComplexity int, id string) int
		DeleteAuthGroupPermissions    func(childComplexity int, filter *AuthGroupPermissionFilter) int
		DeleteAuthGroups              func(childComplexity int, filter *AuthGroupFilter) int
		DeleteAuthPermission          func(childComplexity int, id string) int
		DeleteAuthPermissions         func(childComplexity int, filter *AuthPermissionFilter) int
		DeleteAuthUser                func(childComplexity int, id string) int
		DeleteAuthUserGroup           func(childComplexity int, id string) int
		DeleteAuthUserGroups          func(childComplexity int, filter *AuthUserGroupFilter) int
		DeleteAuthUserUserPermission  func(childComplexity int, id string) int
		DeleteAuthUserUserPermissions func(childComplexity int, filter *AuthUserUserPermissionFilter) int
		DeleteAuthUsers               func(childComplexity int, filter *AuthUserFilter) int
		DeleteFragrance               func(childComplexity int, id string) int
		DeleteFragranceInventories    func(childComplexity int, filter *FragranceInventoryFilter) int
		DeleteFragranceInventory      func(childComplexity int, id string) int
		DeleteFragrances              func(childComplexity int, filter *FragranceFilter) int
		DeleteLipid                   func(childComplexity int, id string) int
		DeleteLipidInventories        func(childComplexity int, filter *LipidInventoryFilter) int
		DeleteLipidInventory          func(childComplexity int, id string) int
		DeleteLipids                  func(childComplexity int, filter *LipidFilter) int
		DeleteLye                     func(childComplexity int, id string) int
		DeleteLyeInventories          func(childComplexity int, filter *LyeInventoryFilter) int
		DeleteLyeInventory            func(childComplexity int, id string) int
		DeleteLyes                    func(childComplexity int, filter *LyeFilter) int
		DeleteRecipe                  func(childComplexity int, id string) int
		DeleteRecipeAdditive          func(childComplexity int, id string) int
		DeleteRecipeAdditives         func(childComplexity int, filter *RecipeAdditiveFilter) int
		DeleteRecipeBatch             func(childComplexity int, id string) int
		DeleteRecipeBatchAdditive     func(childComplexity int, id string) int
		DeleteRecipeBatchAdditives    func(childComplexity int, filter *RecipeBatchAdditiveFilter) int
		DeleteRecipeBatchFragrance    func(childComplexity int, id string) int
		DeleteRecipeBatchFragrances   func(childComplexity int, filter *RecipeBatchFragranceFilter) int
		DeleteRecipeBatchLipid        func(childComplexity int, id string) int
		DeleteRecipeBatchLipids       func(childComplexity int, filter *RecipeBatchLipidFilter) int
		DeleteRecipeBatchLye          func(childComplexity int, id string) int
		DeleteRecipeBatchLyes         func(childComplexity int, filter *RecipeBatchLyeFilter) int
		DeleteRecipeBatchNote         func(childComplexity int, id string) int
		DeleteRecipeBatchNotes        func(childComplexity int, filter *RecipeBatchNoteFilter) int
		DeleteRecipeBatches           func(childComplexity int, filter *RecipeBatchFilter) int
		DeleteRecipeFragrance         func(childComplexity int, id string) int
		DeleteRecipeFragrances        func(childComplexity int, filter *RecipeFragranceFilter) int
		DeleteRecipeLipid             func(childComplexity int, id string) int
		DeleteRecipeLipids            func(childComplexity int, filter *RecipeLipidFilter) int
		DeleteRecipeStep              func(childComplexity int, id string) int
		DeleteRecipeSteps             func(childComplexity int, filter *RecipeStepFilter) int
		DeleteRecipes                 func(childComplexity int, filter *RecipeFilter) int
		DeleteSupplier                func(childComplexity int, id string) int
		DeleteSuppliers               func(childComplexity int, filter *SupplierFilter) int
		UpdateAdditive                func(childComplexity int, id string, input AdditiveUpdateInput) int
		UpdateAdditiveInventories     func(childComplexity int, filter *AdditiveInventoryFilter, input AdditiveInventoryUpdateInput) int
		UpdateAdditiveInventory       func(childComplexity int, id string, input AdditiveInventoryUpdateInput) int
		UpdateAdditives               func(childComplexity int, filter *AdditiveFilter, input AdditiveUpdateInput) int
		UpdateAuthGroup               func(childComplexity int, id string, input AuthGroupUpdateInput) int
		UpdateAuthGroupPermission     func(childComplexity int, id string, input AuthGroupPermissionUpdateInput) int
		UpdateAuthGroupPermissions    func(childComplexity int, filter *AuthGroupPermissionFilter, input AuthGroupPermissionUpdateInput) int
		UpdateAuthGroups              func(childComplexity int, filter *AuthGroupFilter, input AuthGroupUpdateInput) int
		UpdateAuthPermission          func(childComplexity int, id string, input AuthPermissionUpdateInput) int
		UpdateAuthPermissions         func(childComplexity int, filter *AuthPermissionFilter, input AuthPermissionUpdateInput) int
		UpdateAuthUser                func(childComplexity int, id string, input AuthUserUpdateInput) int
		UpdateAuthUserGroup           func(childComplexity int, id string, input AuthUserGroupUpdateInput) int
		UpdateAuthUserGroups          func(childComplexity int, filter *AuthUserGroupFilter, input AuthUserGroupUpdateInput) int
		UpdateAuthUserUserPermission  func(childComplexity int, id string, input AuthUserUserPermissionUpdateInput) int
		UpdateAuthUserUserPermissions func(childComplexity int, filter *AuthUserUserPermissionFilter, input AuthUserUserPermissionUpdateInput) int
		UpdateAuthUsers               func(childComplexity int, filter *AuthUserFilter, input AuthUserUpdateInput) int
		UpdateFragrance               func(childComplexity int, id string, input FragranceUpdateInput) int
		UpdateFragranceInventories    func(childComplexity int, filter *FragranceInventoryFilter, input FragranceInventoryUpdateInput) int
		UpdateFragranceInventory      func(childComplexity int, id string, input FragranceInventoryUpdateInput) int
		UpdateFragrances              func(childComplexity int, filter *FragranceFilter, input FragranceUpdateInput) int
		UpdateLipid                   func(childComplexity int, id string, input LipidUpdateInput) int
		UpdateLipidInventories        func(childComplexity int, filter *LipidInventoryFilter, input LipidInventoryUpdateInput) int
		UpdateLipidInventory          func(childComplexity int, id string, input LipidInventoryUpdateInput) int
		UpdateLipids                  func(childComplexity int, filter *LipidFilter, input LipidUpdateInput) int
		UpdateLye                     func(childComplexity int, id string, input LyeUpdateInput) int
		UpdateLyeInventories          func(childComplexity int, filter *LyeInventoryFilter, input LyeInventoryUpdateInput) int
		UpdateLyeInventory            func(childComplexity int, id string, input LyeInventoryUpdateInput) int
		UpdateLyes                    func(childComplexity int, filter *LyeFilter, input LyeUpdateInput) int
		UpdateRecipe                  func(childComplexity int, id string, input RecipeUpdateInput) int
		UpdateRecipeAdditive          func(childComplexity int, id string, input RecipeAdditiveUpdateInput) int
		UpdateRecipeAdditives         func(childComplexity int, filter *RecipeAdditiveFilter, input RecipeAdditiveUpdateInput) int
		UpdateRecipeBatch             func(childComplexity int, id string, input RecipeBatchUpdateInput) int
		UpdateRecipeBatchAdditive     func(childComplexity int, id string, input RecipeBatchAdditiveUpdateInput) int
		UpdateRecipeBatchAdditives    func(childComplexity int, filter *RecipeBatchAdditiveFilter, input RecipeBatchAdditiveUpdateInput) int
		UpdateRecipeBatchFragrance    func(childComplexity int, id string, input RecipeBatchFragranceUpdateInput) int
		UpdateRecipeBatchFragrances   func(childComplexity int, filter *RecipeBatchFragranceFilter, input RecipeBatchFragranceUpdateInput) int
		UpdateRecipeBatchLipid        func(childComplexity int, id string, input RecipeBatchLipidUpdateInput) int
		UpdateRecipeBatchLipids       func(childComplexity int, filter *RecipeBatchLipidFilter, input RecipeBatchLipidUpdateInput) int
		UpdateRecipeBatchLye          func(childComplexity int, id string, input RecipeBatchLyeUpdateInput) int
		UpdateRecipeBatchLyes         func(childComplexity int, filter *RecipeBatchLyeFilter, input RecipeBatchLyeUpdateInput) int
		UpdateRecipeBatchNote         func(childComplexity int, id string, input RecipeBatchNoteUpdateInput) int
		UpdateRecipeBatchNotes        func(childComplexity int, filter *RecipeBatchNoteFilter, input RecipeBatchNoteUpdateInput) int
		UpdateRecipeBatches           func(childComplexity int, filter *RecipeBatchFilter, input RecipeBatchUpdateInput) int
		UpdateRecipeFragrance         func(childComplexity int, id string, input RecipeFragranceUpdateInput) int
		UpdateRecipeFragrances        func(childComplexity int, filter *RecipeFragranceFilter, input RecipeFragranceUpdateInput) int
		UpdateRecipeLipid             func(childComplexity int, id string, input RecipeLipidUpdateInput) int
		UpdateRecipeLipids            func(childComplexity int, filter *RecipeLipidFilter, input RecipeLipidUpdateInput) int
		UpdateRecipeStep              func(childComplexity int, id string, input RecipeStepUpdateInput) int
		UpdateRecipeSteps             func(childComplexity int, filter *RecipeStepFilter, input RecipeStepUpdateInput) int
		UpdateRecipes                 func(childComplexity int, filter *RecipeFilter, input RecipeUpdateInput) int
		UpdateSupplier                func(childComplexity int, id string, input SupplierUpdateInput) int
		UpdateSuppliers               func(childComplexity int, filter *SupplierFilter, input SupplierUpdateInput) int
	}

	PageInfo struct {
		EndCursor       func(childComplexity int) int
		HasNextPage     func(childComplexity int) int
		HasPreviousPage func(childComplexity int) int
		StartCursor     func(childComplexity int) int
	}

	Query struct {
		Additive                func(childComplexity int, id string) int
		AdditiveInventories     func(childComplexity int, first int, after *string, ordering []*AdditiveInventoryOrdering, filter *AdditiveInventoryFilter) int
		AdditiveInventory       func(childComplexity int, id string) int
		Additives               func(childComplexity int, first int, after *string, ordering []*AdditiveOrdering, filter *AdditiveFilter) int
		AuthGroup               func(childComplexity int, id string) int
		AuthGroupPermission     func(childComplexity int, id string) int
		AuthGroupPermissions    func(childComplexity int, first int, after *string, ordering []*AuthGroupPermissionOrdering, filter *AuthGroupPermissionFilter) int
		AuthGroups              func(childComplexity int, first int, after *string, ordering []*AuthGroupOrdering, filter *AuthGroupFilter) int
		AuthPermission          func(childComplexity int, id string) int
		AuthPermissions         func(childComplexity int, first int, after *string, ordering []*AuthPermissionOrdering, filter *AuthPermissionFilter) int
		AuthUser                func(childComplexity int, id string) int
		AuthUserGroup           func(childComplexity int, id string) int
		AuthUserGroups          func(childComplexity int, first int, after *string, ordering []*AuthUserGroupOrdering, filter *AuthUserGroupFilter) int
		AuthUserUserPermission  func(childComplexity int, id string) int
		AuthUserUserPermissions func(childComplexity int, first int, after *string, ordering []*AuthUserUserPermissionOrdering, filter *AuthUserUserPermissionFilter) int
		AuthUsers               func(childComplexity int, first int, after *string, ordering []*AuthUserOrdering, filter *AuthUserFilter) int
		Fragrance               func(childComplexity int, id string) int
		FragranceInventories    func(childComplexity int, first int, after *string, ordering []*FragranceInventoryOrdering, filter *FragranceInventoryFilter) int
		FragranceInventory      func(childComplexity int, id string) int
		Fragrances              func(childComplexity int, first int, after *string, ordering []*FragranceOrdering, filter *FragranceFilter) int
		Lipid                   func(childComplexity int, id string) int
		LipidInventories        func(childComplexity int, first int, after *string, ordering []*LipidInventoryOrdering, filter *LipidInventoryFilter) int
		LipidInventory          func(childComplexity int, id string) int
		Lipids                  func(childComplexity int, first int, after *string, ordering []*LipidOrdering, filter *LipidFilter) int
		Lye                     func(childComplexity int, id string) int
		LyeInventories          func(childComplexity int, first int, after *string, ordering []*LyeInventoryOrdering, filter *LyeInventoryFilter) int
		LyeInventory            func(childComplexity int, id string) int
		Lyes                    func(childComplexity int, first int, after *string, ordering []*LyeOrdering, filter *LyeFilter) int
		Node                    func(childComplexity int, id string) int
		Recipe                  func(childComplexity int, id string) int
		RecipeAdditive          func(childComplexity int, id string) int
		RecipeAdditives         func(childComplexity int, first int, after *string, ordering []*RecipeAdditiveOrdering, filter *RecipeAdditiveFilter) int
		RecipeBatch             func(childComplexity int, id string) int
		RecipeBatchAdditive     func(childComplexity int, id string) int
		RecipeBatchAdditives    func(childComplexity int, first int, after *string, ordering []*RecipeBatchAdditiveOrdering, filter *RecipeBatchAdditiveFilter) int
		RecipeBatchFragrance    func(childComplexity int, id string) int
		RecipeBatchFragrances   func(childComplexity int, first int, after *string, ordering []*RecipeBatchFragranceOrdering, filter *RecipeBatchFragranceFilter) int
		RecipeBatchLipid        func(childComplexity int, id string) int
		RecipeBatchLipids       func(childComplexity int, first int, after *string, ordering []*RecipeBatchLipidOrdering, filter *RecipeBatchLipidFilter) int
		RecipeBatchLye          func(childComplexity int, id string) int
		RecipeBatchLyes         func(childComplexity int, first int, after *string, ordering []*RecipeBatchLyeOrdering, filter *RecipeBatchLyeFilter) int
		RecipeBatchNote         func(childComplexity int, id string) int
		RecipeBatchNotes        func(childComplexity int, first int, after *string, ordering []*RecipeBatchNoteOrdering, filter *RecipeBatchNoteFilter) int
		RecipeBatches           func(childComplexity int, first int, after *string, ordering []*RecipeBatchOrdering, filter *RecipeBatchFilter) int
		RecipeFragrance         func(childComplexity int, id string) int
		RecipeFragrances        func(childComplexity int, first int, after *string, ordering []*RecipeFragranceOrdering, filter *RecipeFragranceFilter) int
		RecipeLipid             func(childComplexity int, id string) int
		RecipeLipids            func(childComplexity int, first int, after *string, ordering []*RecipeLipidOrdering, filter *RecipeLipidFilter) int
		RecipeStep              func(childComplexity int, id string) int
		RecipeSteps             func(childComplexity int, first int, after *string, ordering []*RecipeStepOrdering, filter *RecipeStepFilter) int
		Recipes                 func(childComplexity int, first int, after *string, ordering []*RecipeOrdering, filter *RecipeFilter) int
		Supplier                func(childComplexity int, id string) int
		Suppliers               func(childComplexity int, first int, after *string, ordering []*SupplierOrdering, filter *SupplierFilter) int
	}

	Recipe struct {
		CreatedAt        func(childComplexity int) int
		DeletedAt        func(childComplexity int) int
		ID               func(childComplexity int) int
		Name             func(childComplexity int) int
		Note             func(childComplexity int) int
		RecipeAdditives  func(childComplexity int) int
		RecipeBatches    func(childComplexity int) int
		RecipeFragrances func(childComplexity int) int
		RecipeLipids     func(childComplexity int) int
		RecipeSteps      func(childComplexity int) int
		UpdatedAt        func(childComplexity int) int
	}

	RecipeAdditive struct {
		Additive   func(childComplexity int) int
		CreatedAt  func(childComplexity int) int
		DeletedAt  func(childComplexity int) int
		ID         func(childComplexity int) int
		Percentage func(childComplexity int) int
		Recipe     func(childComplexity int) int
		UpdatedAt  func(childComplexity int) int
	}

	RecipeAdditiveConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	RecipeAdditiveDeletePayload struct {
		ID func(childComplexity int) int
	}

	RecipeAdditiveEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	RecipeAdditivePayload struct {
		RecipeAdditive func(childComplexity int) int
	}

	RecipeAdditivesDeletePayload struct {
		Ids func(childComplexity int) int
	}

	RecipeAdditivesUpdatePayload struct {
		Ok func(childComplexity int) int
	}

	RecipeBatch struct {
		BatchRecipeBatchAdditives  func(childComplexity int) int
		BatchRecipeBatchFragrances func(childComplexity int) int
		BatchRecipeBatchLipids     func(childComplexity int) int
		BatchRecipeBatchLyes       func(childComplexity int) int
		BatchRecipeBatchNotes      func(childComplexity int) int
		CreatedAt                  func(childComplexity int) int
		CuredWeight                func(childComplexity int) int
		DeletedAt                  func(childComplexity int) int
		ID                         func(childComplexity int) int
		LipidWeight                func(childComplexity int) int
		Note                       func(childComplexity int) int
		ProductionDate             func(childComplexity int) int
		ProductionWeight           func(childComplexity int) int
		Recipe                     func(childComplexity int) int
		SellableDate               func(childComplexity int) int
		Tag                        func(childComplexity int) int
		UpdatedAt                  func(childComplexity int) int
	}

	RecipeBatchAdditive struct {
		Additive  func(childComplexity int) int
		Batch     func(childComplexity int) int
		Cost      func(childComplexity int) int
		CreatedAt func(childComplexity int) int
		DeletedAt func(childComplexity int) int
		ID        func(childComplexity int) int
		UpdatedAt func(childComplexity int) int
		Weight    func(childComplexity int) int
	}

	RecipeBatchAdditiveConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	RecipeBatchAdditiveDeletePayload struct {
		ID func(childComplexity int) int
	}

	RecipeBatchAdditiveEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	RecipeBatchAdditivePayload struct {
		RecipeBatchAdditive func(childComplexity int) int
	}

	RecipeBatchAdditivesDeletePayload struct {
		Ids func(childComplexity int) int
	}

	RecipeBatchAdditivesUpdatePayload struct {
		Ok func(childComplexity int) int
	}

	RecipeBatchConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	RecipeBatchDeletePayload struct {
		ID func(childComplexity int) int
	}

	RecipeBatchEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	RecipeBatchFragrance struct {
		Batch     func(childComplexity int) int
		Cost      func(childComplexity int) int
		CreatedAt func(childComplexity int) int
		DeletedAt func(childComplexity int) int
		Fragrance func(childComplexity int) int
		ID        func(childComplexity int) int
		UpdatedAt func(childComplexity int) int
		Weight    func(childComplexity int) int
	}

	RecipeBatchFragranceConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	RecipeBatchFragranceDeletePayload struct {
		ID func(childComplexity int) int
	}

	RecipeBatchFragranceEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	RecipeBatchFragrancePayload struct {
		RecipeBatchFragrance func(childComplexity int) int
	}

	RecipeBatchFragrancesDeletePayload struct {
		Ids func(childComplexity int) int
	}

	RecipeBatchFragrancesUpdatePayload struct {
		Ok func(childComplexity int) int
	}

	RecipeBatchLipid struct {
		Batch     func(childComplexity int) int
		Cost      func(childComplexity int) int
		CreatedAt func(childComplexity int) int
		DeletedAt func(childComplexity int) int
		ID        func(childComplexity int) int
		Lipid     func(childComplexity int) int
		UpdatedAt func(childComplexity int) int
		Weight    func(childComplexity int) int
	}

	RecipeBatchLipidConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	RecipeBatchLipidDeletePayload struct {
		ID func(childComplexity int) int
	}

	RecipeBatchLipidEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	RecipeBatchLipidPayload struct {
		RecipeBatchLipid func(childComplexity int) int
	}

	RecipeBatchLipidsDeletePayload struct {
		Ids func(childComplexity int) int
	}

	RecipeBatchLipidsUpdatePayload struct {
		Ok func(childComplexity int) int
	}

	RecipeBatchLye struct {
		Batch     func(childComplexity int) int
		Cost      func(childComplexity int) int
		CreatedAt func(childComplexity int) int
		DeletedAt func(childComplexity int) int
		Discount  func(childComplexity int) int
		ID        func(childComplexity int) int
		Lye       func(childComplexity int) int
		UpdatedAt func(childComplexity int) int
		Weight    func(childComplexity int) int
	}

	RecipeBatchLyeConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	RecipeBatchLyeDeletePayload struct {
		ID func(childComplexity int) int
	}

	RecipeBatchLyeEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	RecipeBatchLyePayload struct {
		RecipeBatchLye func(childComplexity int) int
	}

	RecipeBatchLyesDeletePayload struct {
		Ids func(childComplexity int) int
	}

	RecipeBatchLyesUpdatePayload struct {
		Ok func(childComplexity int) int
	}

	RecipeBatchNote struct {
		Batch     func(childComplexity int) int
		CreatedAt func(childComplexity int) int
		DeletedAt func(childComplexity int) int
		ID        func(childComplexity int) int
		Link      func(childComplexity int) int
		Note      func(childComplexity int) int
		UpdatedAt func(childComplexity int) int
	}

	RecipeBatchNoteConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	RecipeBatchNoteDeletePayload struct {
		ID func(childComplexity int) int
	}

	RecipeBatchNoteEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	RecipeBatchNotePayload struct {
		RecipeBatchNote func(childComplexity int) int
	}

	RecipeBatchNotesDeletePayload struct {
		Ids func(childComplexity int) int
	}

	RecipeBatchNotesUpdatePayload struct {
		Ok func(childComplexity int) int
	}

	RecipeBatchPayload struct {
		RecipeBatch func(childComplexity int) int
	}

	RecipeBatchesDeletePayload struct {
		Ids func(childComplexity int) int
	}

	RecipeBatchesUpdatePayload struct {
		Ok func(childComplexity int) int
	}

	RecipeConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	RecipeDeletePayload struct {
		ID func(childComplexity int) int
	}

	RecipeEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	RecipeFragrance struct {
		CreatedAt  func(childComplexity int) int
		DeletedAt  func(childComplexity int) int
		Fragrance  func(childComplexity int) int
		ID         func(childComplexity int) int
		Percentage func(childComplexity int) int
		Recipe     func(childComplexity int) int
		UpdatedAt  func(childComplexity int) int
	}

	RecipeFragranceConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	RecipeFragranceDeletePayload struct {
		ID func(childComplexity int) int
	}

	RecipeFragranceEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	RecipeFragrancePayload struct {
		RecipeFragrance func(childComplexity int) int
	}

	RecipeFragrancesDeletePayload struct {
		Ids func(childComplexity int) int
	}

	RecipeFragrancesUpdatePayload struct {
		Ok func(childComplexity int) int
	}

	RecipeLipid struct {
		CreatedAt  func(childComplexity int) int
		DeletedAt  func(childComplexity int) int
		ID         func(childComplexity int) int
		Lipid      func(childComplexity int) int
		Percentage func(childComplexity int) int
		Recipe     func(childComplexity int) int
		UpdatedAt  func(childComplexity int) int
	}

	RecipeLipidConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	RecipeLipidDeletePayload struct {
		ID func(childComplexity int) int
	}

	RecipeLipidEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	RecipeLipidPayload struct {
		RecipeLipid func(childComplexity int) int
	}

	RecipeLipidsDeletePayload struct {
		Ids func(childComplexity int) int
	}

	RecipeLipidsUpdatePayload struct {
		Ok func(childComplexity int) int
	}

	RecipePayload struct {
		Recipe func(childComplexity int) int
	}

	RecipeStep struct {
		CreatedAt func(childComplexity int) int
		DeletedAt func(childComplexity int) int
		ID        func(childComplexity int) int
		Note      func(childComplexity int) int
		Num       func(childComplexity int) int
		Recipe    func(childComplexity int) int
		UpdatedAt func(childComplexity int) int
	}

	RecipeStepConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	RecipeStepDeletePayload struct {
		ID func(childComplexity int) int
	}

	RecipeStepEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	RecipeStepPayload struct {
		RecipeStep func(childComplexity int) int
	}

	RecipeStepsDeletePayload struct {
		Ids func(childComplexity int) int
	}

	RecipeStepsUpdatePayload struct {
		Ok func(childComplexity int) int
	}

	RecipesDeletePayload struct {
		Ids func(childComplexity int) int
	}

	RecipesUpdatePayload struct {
		Ok func(childComplexity int) int
	}

	Supplier struct {
		AdditiveInventories  func(childComplexity int) int
		CreatedAt            func(childComplexity int) int
		DeletedAt            func(childComplexity int) int
		FragranceInventories func(childComplexity int) int
		ID                   func(childComplexity int) int
		LipidInventories     func(childComplexity int) int
		LyeInventories       func(childComplexity int) int
		Name                 func(childComplexity int) int
		Note                 func(childComplexity int) int
		UpdatedAt            func(childComplexity int) int
		Website              func(childComplexity int) int
	}

	SupplierConnection struct {
		Edges    func(childComplexity int) int
		PageInfo func(childComplexity int) int
	}

	SupplierDeletePayload struct {
		ID func(childComplexity int) int
	}

	SupplierEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	SupplierPayload struct {
		Supplier func(childComplexity int) int
	}

	SuppliersDeletePayload struct {
		Ids func(childComplexity int) int
	}

	SuppliersUpdatePayload struct {
		Ok func(childComplexity int) int
	}
}

type Config

type Config struct {
	Resolvers  ResolverRoot
	Directives DirectiveRoot
	Complexity ComplexityRoot
}

type DirectiveRoot

type DirectiveRoot struct {
	IsAuthenticated func(ctx context.Context, obj interface{}, next graphql.Resolver) (res interface{}, err error)
}

type FloatFilter

type FloatFilter struct {
	EqualTo           *float64  `json:"equalTo"`
	NotEqualTo        *float64  `json:"notEqualTo"`
	LessThan          *float64  `json:"lessThan"`
	LessThanOrEqualTo *float64  `json:"lessThanOrEqualTo"`
	MoreThan          *float64  `json:"moreThan"`
	MoreThanOrEqualTo *float64  `json:"moreThanOrEqualTo"`
	In                []float64 `json:"in"`
	NotIn             []float64 `json:"notIn"`
}

type Fragrance

type Fragrance struct {
	ID                   string                `json:"id"`
	Name                 string                `json:"name"`
	Note                 string                `json:"note"`
	CreatedAt            int                   `json:"createdAt"`
	UpdatedAt            int                   `json:"updatedAt"`
	DeletedAt            *int                  `json:"deletedAt"`
	RecipeBatchFragrance *RecipeBatchFragrance `json:"recipeBatchFragrance"`
	RecipeFragrance      *RecipeFragrance      `json:"recipeFragrance"`
	FragranceInventories []*FragranceInventory `json:"fragranceInventories"`
}

func (Fragrance) IsNode

func (Fragrance) IsNode()

type FragranceConnection

type FragranceConnection struct {
	Edges    []*FragranceEdge `json:"edges"`
	PageInfo *PageInfo        `json:"pageInfo"`
}

type FragranceCreateInput

type FragranceCreateInput struct {
	Name      string `json:"name"`
	Note      string `json:"note"`
	CreatedAt int    `json:"createdAt"`
	UpdatedAt int    `json:"updatedAt"`
	DeletedAt *int   `json:"deletedAt"`
}

type FragranceDeletePayload

type FragranceDeletePayload struct {
	ID string `json:"id"`
}

type FragranceEdge

type FragranceEdge struct {
	Cursor string     `json:"cursor"`
	Node   *Fragrance `json:"node"`
}

type FragranceFilter

type FragranceFilter struct {
	Search *string         `json:"search"`
	Where  *FragranceWhere `json:"where"`
}

type FragranceInventoriesDeletePayload

type FragranceInventoriesDeletePayload struct {
	Ids []string `json:"ids"`
}

type FragranceInventoriesUpdatePayload

type FragranceInventoriesUpdatePayload struct {
	Ok bool `json:"ok"`
}

type FragranceInventory

type FragranceInventory struct {
	ID           string     `json:"id"`
	PurchaseDate int        `json:"purchaseDate"`
	ExpiryDate   int        `json:"expiryDate"`
	Cost         float64    `json:"cost"`
	Weight       float64    `json:"weight"`
	Fragrance    *Fragrance `json:"fragrance"`
	Supplier     *Supplier  `json:"supplier"`
	CreatedAt    int        `json:"createdAt"`
	UpdatedAt    int        `json:"updatedAt"`
	DeletedAt    *int       `json:"deletedAt"`
}

func (FragranceInventory) IsNode

func (FragranceInventory) IsNode()

type FragranceInventoryConnection

type FragranceInventoryConnection struct {
	Edges    []*FragranceInventoryEdge `json:"edges"`
	PageInfo *PageInfo                 `json:"pageInfo"`
}

type FragranceInventoryCreateInput

type FragranceInventoryCreateInput struct {
	PurchaseDate int     `json:"purchaseDate"`
	ExpiryDate   int     `json:"expiryDate"`
	Cost         float64 `json:"cost"`
	Weight       float64 `json:"weight"`
	FragranceID  string  `json:"fragranceId"`
	SupplierID   string  `json:"supplierId"`
	CreatedAt    int     `json:"createdAt"`
	UpdatedAt    int     `json:"updatedAt"`
	DeletedAt    *int    `json:"deletedAt"`
}

type FragranceInventoryDeletePayload

type FragranceInventoryDeletePayload struct {
	ID string `json:"id"`
}

type FragranceInventoryEdge

type FragranceInventoryEdge struct {
	Cursor string              `json:"cursor"`
	Node   *FragranceInventory `json:"node"`
}

type FragranceInventoryFilter

type FragranceInventoryFilter struct {
	Search *string                  `json:"search"`
	Where  *FragranceInventoryWhere `json:"where"`
}

type FragranceInventoryOrdering

type FragranceInventoryOrdering struct {
	Sort      FragranceInventorySort  `json:"sort"`
	Direction boilergql.SortDirection `json:"direction"`
}

type FragranceInventoryPayload

type FragranceInventoryPayload struct {
	FragranceInventory *FragranceInventory `json:"fragranceInventory"`
}

type FragranceInventorySort

type FragranceInventorySort string

const (
	FragranceInventorySortID           FragranceInventorySort = "ID"
	FragranceInventorySortPurchaseDate FragranceInventorySort = "PURCHASE_DATE"
	FragranceInventorySortExpiryDate   FragranceInventorySort = "EXPIRY_DATE"
	FragranceInventorySortCost         FragranceInventorySort = "COST"
	FragranceInventorySortWeight       FragranceInventorySort = "WEIGHT"
	FragranceInventorySortCreatedAt    FragranceInventorySort = "CREATED_AT"
	FragranceInventorySortUpdatedAt    FragranceInventorySort = "UPDATED_AT"
	FragranceInventorySortDeletedAt    FragranceInventorySort = "DELETED_AT"
)

func (FragranceInventorySort) IsValid

func (e FragranceInventorySort) IsValid() bool

func (FragranceInventorySort) MarshalGQL

func (e FragranceInventorySort) MarshalGQL(w io.Writer)

func (FragranceInventorySort) String

func (e FragranceInventorySort) String() string

func (*FragranceInventorySort) UnmarshalGQL

func (e *FragranceInventorySort) UnmarshalGQL(v interface{}) error

type FragranceInventoryUpdateInput

type FragranceInventoryUpdateInput struct {
	PurchaseDate *int     `json:"purchaseDate"`
	ExpiryDate   *int     `json:"expiryDate"`
	Cost         *float64 `json:"cost"`
	Weight       *float64 `json:"weight"`
	FragranceID  *string  `json:"fragranceId"`
	SupplierID   *string  `json:"supplierId"`
	CreatedAt    *int     `json:"createdAt"`
	UpdatedAt    *int     `json:"updatedAt"`
	DeletedAt    *int     `json:"deletedAt"`
}

type FragranceInventoryWhere

type FragranceInventoryWhere struct {
	ID           *IDFilter                `json:"id"`
	PurchaseDate *IntFilter               `json:"purchaseDate"`
	ExpiryDate   *IntFilter               `json:"expiryDate"`
	Cost         *FloatFilter             `json:"cost"`
	Weight       *FloatFilter             `json:"weight"`
	Fragrance    *FragranceWhere          `json:"fragrance"`
	Supplier     *SupplierWhere           `json:"supplier"`
	CreatedAt    *IntFilter               `json:"createdAt"`
	UpdatedAt    *IntFilter               `json:"updatedAt"`
	DeletedAt    *IntFilter               `json:"deletedAt"`
	Or           *FragranceInventoryWhere `json:"or"`
	And          *FragranceInventoryWhere `json:"and"`
}

type FragranceOrdering

type FragranceOrdering struct {
	Sort      FragranceSort           `json:"sort"`
	Direction boilergql.SortDirection `json:"direction"`
}

type FragrancePayload

type FragrancePayload struct {
	Fragrance *Fragrance `json:"fragrance"`
}

type FragranceSort

type FragranceSort string

const (
	FragranceSortID        FragranceSort = "ID"
	FragranceSortName      FragranceSort = "NAME"
	FragranceSortNote      FragranceSort = "NOTE"
	FragranceSortCreatedAt FragranceSort = "CREATED_AT"
	FragranceSortUpdatedAt FragranceSort = "UPDATED_AT"
	FragranceSortDeletedAt FragranceSort = "DELETED_AT"
)

func (FragranceSort) IsValid

func (e FragranceSort) IsValid() bool

func (FragranceSort) MarshalGQL

func (e FragranceSort) MarshalGQL(w io.Writer)

func (FragranceSort) String

func (e FragranceSort) String() string

func (*FragranceSort) UnmarshalGQL

func (e *FragranceSort) UnmarshalGQL(v interface{}) error

type FragranceUpdateInput

type FragranceUpdateInput struct {
	Name      *string `json:"name"`
	Note      *string `json:"note"`
	CreatedAt *int    `json:"createdAt"`
	UpdatedAt *int    `json:"updatedAt"`
	DeletedAt *int    `json:"deletedAt"`
}

type FragranceWhere

type FragranceWhere struct {
	ID                   *IDFilter                  `json:"id"`
	Name                 *StringFilter              `json:"name"`
	Note                 *StringFilter              `json:"note"`
	CreatedAt            *IntFilter                 `json:"createdAt"`
	UpdatedAt            *IntFilter                 `json:"updatedAt"`
	DeletedAt            *IntFilter                 `json:"deletedAt"`
	RecipeBatchFragrance *RecipeBatchFragranceWhere `json:"recipeBatchFragrance"`
	RecipeFragrance      *RecipeFragranceWhere      `json:"recipeFragrance"`
	FragranceInventories *FragranceInventoryWhere   `json:"fragranceInventories"`
	Or                   *FragranceWhere            `json:"or"`
	And                  *FragranceWhere            `json:"and"`
}

type FragrancesDeletePayload

type FragrancesDeletePayload struct {
	Ids []string `json:"ids"`
}

type FragrancesUpdatePayload

type FragrancesUpdatePayload struct {
	Ok bool `json:"ok"`
}

type IDFilter

type IDFilter struct {
	EqualTo    *string  `json:"equalTo"`
	NotEqualTo *string  `json:"notEqualTo"`
	In         []string `json:"in"`
	NotIn      []string `json:"notIn"`
}

type IntFilter

type IntFilter struct {
	EqualTo           *int  `json:"equalTo"`
	NotEqualTo        *int  `json:"notEqualTo"`
	LessThan          *int  `json:"lessThan"`
	LessThanOrEqualTo *int  `json:"lessThanOrEqualTo"`
	MoreThan          *int  `json:"moreThan"`
	MoreThanOrEqualTo *int  `json:"moreThanOrEqualTo"`
	In                []int `json:"in"`
	NotIn             []int `json:"notIn"`
}

type Lipid

type Lipid struct {
	ID               string            `json:"id"`
	Name             string            `json:"name"`
	Lauric           int               `json:"lauric"`
	Myristic         int               `json:"myristic"`
	Palmitic         int               `json:"palmitic"`
	Stearic          int               `json:"stearic"`
	Ricinoleic       int               `json:"ricinoleic"`
	Oleic            int               `json:"oleic"`
	Linoleic         int               `json:"linoleic"`
	Linolenic        int               `json:"linolenic"`
	Hardness         int               `json:"hardness"`
	Cleansing        int               `json:"cleansing"`
	Conditioning     int               `json:"conditioning"`
	Bubbly           int               `json:"bubbly"`
	Creamy           int               `json:"creamy"`
	Iodine           int               `json:"iodine"`
	Ins              int               `json:"ins"`
	InciName         string            `json:"inciName"`
	Family           string            `json:"family"`
	Naoh             float64           `json:"naoh"`
	CreatedAt        int               `json:"createdAt"`
	UpdatedAt        int               `json:"updatedAt"`
	DeletedAt        *int              `json:"deletedAt"`
	RecipeBatchLipid *RecipeBatchLipid `json:"recipeBatchLipid"`
	RecipeLipid      *RecipeLipid      `json:"recipeLipid"`
	LipidInventories []*LipidInventory `json:"lipidInventories"`
}

func (Lipid) IsNode

func (Lipid) IsNode()

type LipidConnection

type LipidConnection struct {
	Edges    []*LipidEdge `json:"edges"`
	PageInfo *PageInfo    `json:"pageInfo"`
}

type LipidCreateInput

type LipidCreateInput struct {
	Name         string  `json:"name"`
	Lauric       int     `json:"lauric"`
	Myristic     int     `json:"myristic"`
	Palmitic     int     `json:"palmitic"`
	Stearic      int     `json:"stearic"`
	Ricinoleic   int     `json:"ricinoleic"`
	Oleic        int     `json:"oleic"`
	Linoleic     int     `json:"linoleic"`
	Linolenic    int     `json:"linolenic"`
	Hardness     int     `json:"hardness"`
	Cleansing    int     `json:"cleansing"`
	Conditioning int     `json:"conditioning"`
	Bubbly       int     `json:"bubbly"`
	Creamy       int     `json:"creamy"`
	Iodine       int     `json:"iodine"`
	Ins          int     `json:"ins"`
	InciName     string  `json:"inciName"`
	Family       string  `json:"family"`
	Naoh         float64 `json:"naoh"`
	CreatedAt    int     `json:"createdAt"`
	UpdatedAt    int     `json:"updatedAt"`
	DeletedAt    *int    `json:"deletedAt"`
}

type LipidDeletePayload

type LipidDeletePayload struct {
	ID string `json:"id"`
}

type LipidEdge

type LipidEdge struct {
	Cursor string `json:"cursor"`
	Node   *Lipid `json:"node"`
}

type LipidFilter

type LipidFilter struct {
	Search *string     `json:"search"`
	Where  *LipidWhere `json:"where"`
}

type LipidInventoriesDeletePayload

type LipidInventoriesDeletePayload struct {
	Ids []string `json:"ids"`
}

type LipidInventoriesUpdatePayload

type LipidInventoriesUpdatePayload struct {
	Ok bool `json:"ok"`
}

type LipidInventory

type LipidInventory struct {
	ID            string    `json:"id"`
	PurchaseDate  int       `json:"purchaseDate"`
	ExpiryDate    int       `json:"expiryDate"`
	Cost          float64   `json:"cost"`
	Weight        float64   `json:"weight"`
	Sap           float64   `json:"sap"`
	Naoh          float64   `json:"naoh"`
	Koh           float64   `json:"koh"`
	GramsPerLiter float64   `json:"gramsPerLiter"`
	Lipid         *Lipid    `json:"lipid"`
	Supplier      *Supplier `json:"supplier"`
	CreatedAt     int       `json:"createdAt"`
	UpdatedAt     int       `json:"updatedAt"`
	DeletedAt     *int      `json:"deletedAt"`
}

func (LipidInventory) IsNode

func (LipidInventory) IsNode()

type LipidInventoryConnection

type LipidInventoryConnection struct {
	Edges    []*LipidInventoryEdge `json:"edges"`
	PageInfo *PageInfo             `json:"pageInfo"`
}

type LipidInventoryCreateInput

type LipidInventoryCreateInput struct {
	PurchaseDate  int     `json:"purchaseDate"`
	ExpiryDate    int     `json:"expiryDate"`
	Cost          float64 `json:"cost"`
	Weight        float64 `json:"weight"`
	Sap           float64 `json:"sap"`
	Naoh          float64 `json:"naoh"`
	Koh           float64 `json:"koh"`
	GramsPerLiter float64 `json:"gramsPerLiter"`
	LipidID       string  `json:"lipidId"`
	SupplierID    string  `json:"supplierId"`
	CreatedAt     int     `json:"createdAt"`
	UpdatedAt     int     `json:"updatedAt"`
	DeletedAt     *int    `json:"deletedAt"`
}

type LipidInventoryDeletePayload

type LipidInventoryDeletePayload struct {
	ID string `json:"id"`
}

type LipidInventoryEdge

type LipidInventoryEdge struct {
	Cursor string          `json:"cursor"`
	Node   *LipidInventory `json:"node"`
}

type LipidInventoryFilter

type LipidInventoryFilter struct {
	Search *string              `json:"search"`
	Where  *LipidInventoryWhere `json:"where"`
}

type LipidInventoryOrdering

type LipidInventoryOrdering struct {
	Sort      LipidInventorySort      `json:"sort"`
	Direction boilergql.SortDirection `json:"direction"`
}

type LipidInventoryPayload

type LipidInventoryPayload struct {
	LipidInventory *LipidInventory `json:"lipidInventory"`
}

type LipidInventorySort

type LipidInventorySort string

const (
	LipidInventorySortID            LipidInventorySort = "ID"
	LipidInventorySortPurchaseDate  LipidInventorySort = "PURCHASE_DATE"
	LipidInventorySortExpiryDate    LipidInventorySort = "EXPIRY_DATE"
	LipidInventorySortCost          LipidInventorySort = "COST"
	LipidInventorySortWeight        LipidInventorySort = "WEIGHT"
	LipidInventorySortSap           LipidInventorySort = "SAP"
	LipidInventorySortNaoh          LipidInventorySort = "NAOH"
	LipidInventorySortKoh           LipidInventorySort = "KOH"
	LipidInventorySortGramsPerLiter LipidInventorySort = "GRAMS_PER_LITER"
	LipidInventorySortCreatedAt     LipidInventorySort = "CREATED_AT"
	LipidInventorySortUpdatedAt     LipidInventorySort = "UPDATED_AT"
	LipidInventorySortDeletedAt     LipidInventorySort = "DELETED_AT"
)

func (LipidInventorySort) IsValid

func (e LipidInventorySort) IsValid() bool

func (LipidInventorySort) MarshalGQL

func (e LipidInventorySort) MarshalGQL(w io.Writer)

func (LipidInventorySort) String

func (e LipidInventorySort) String() string

func (*LipidInventorySort) UnmarshalGQL

func (e *LipidInventorySort) UnmarshalGQL(v interface{}) error

type LipidInventoryUpdateInput

type LipidInventoryUpdateInput struct {
	PurchaseDate  *int     `json:"purchaseDate"`
	ExpiryDate    *int     `json:"expiryDate"`
	Cost          *float64 `json:"cost"`
	Weight        *float64 `json:"weight"`
	Sap           *float64 `json:"sap"`
	Naoh          *float64 `json:"naoh"`
	Koh           *float64 `json:"koh"`
	GramsPerLiter *float64 `json:"gramsPerLiter"`
	LipidID       *string  `json:"lipidId"`
	SupplierID    *string  `json:"supplierId"`
	CreatedAt     *int     `json:"createdAt"`
	UpdatedAt     *int     `json:"updatedAt"`
	DeletedAt     *int     `json:"deletedAt"`
}

type LipidInventoryWhere

type LipidInventoryWhere struct {
	ID            *IDFilter            `json:"id"`
	PurchaseDate  *IntFilter           `json:"purchaseDate"`
	ExpiryDate    *IntFilter           `json:"expiryDate"`
	Cost          *FloatFilter         `json:"cost"`
	Weight        *FloatFilter         `json:"weight"`
	Sap           *FloatFilter         `json:"sap"`
	Naoh          *FloatFilter         `json:"naoh"`
	Koh           *FloatFilter         `json:"koh"`
	GramsPerLiter *FloatFilter         `json:"gramsPerLiter"`
	Lipid         *LipidWhere          `json:"lipid"`
	Supplier      *SupplierWhere       `json:"supplier"`
	CreatedAt     *IntFilter           `json:"createdAt"`
	UpdatedAt     *IntFilter           `json:"updatedAt"`
	DeletedAt     *IntFilter           `json:"deletedAt"`
	Or            *LipidInventoryWhere `json:"or"`
	And           *LipidInventoryWhere `json:"and"`
}

type LipidOrdering

type LipidOrdering struct {
	Sort      LipidSort               `json:"sort"`
	Direction boilergql.SortDirection `json:"direction"`
}

type LipidPayload

type LipidPayload struct {
	Lipid *Lipid `json:"lipid"`
}

type LipidSort

type LipidSort string

const (
	LipidSortID           LipidSort = "ID"
	LipidSortName         LipidSort = "NAME"
	LipidSortLauric       LipidSort = "LAURIC"
	LipidSortMyristic     LipidSort = "MYRISTIC"
	LipidSortPalmitic     LipidSort = "PALMITIC"
	LipidSortStearic      LipidSort = "STEARIC"
	LipidSortRicinoleic   LipidSort = "RICINOLEIC"
	LipidSortOleic        LipidSort = "OLEIC"
	LipidSortLinoleic     LipidSort = "LINOLEIC"
	LipidSortLinolenic    LipidSort = "LINOLENIC"
	LipidSortHardness     LipidSort = "HARDNESS"
	LipidSortCleansing    LipidSort = "CLEANSING"
	LipidSortConditioning LipidSort = "CONDITIONING"
	LipidSortBubbly       LipidSort = "BUBBLY"
	LipidSortCreamy       LipidSort = "CREAMY"
	LipidSortIodine       LipidSort = "IODINE"
	LipidSortIns          LipidSort = "INS"
	LipidSortInciName     LipidSort = "INCI_NAME"
	LipidSortFamily       LipidSort = "FAMILY"
	LipidSortNaoh         LipidSort = "NAOH"
	LipidSortCreatedAt    LipidSort = "CREATED_AT"
	LipidSortUpdatedAt    LipidSort = "UPDATED_AT"
	LipidSortDeletedAt    LipidSort = "DELETED_AT"
)

func (LipidSort) IsValid

func (e LipidSort) IsValid() bool

func (LipidSort) MarshalGQL

func (e LipidSort) MarshalGQL(w io.Writer)

func (LipidSort) String

func (e LipidSort) String() string

func (*LipidSort) UnmarshalGQL

func (e *LipidSort) UnmarshalGQL(v interface{}) error

type LipidUpdateInput

type LipidUpdateInput struct {
	Name         *string  `json:"name"`
	Lauric       *int     `json:"lauric"`
	Myristic     *int     `json:"myristic"`
	Palmitic     *int     `json:"palmitic"`
	Stearic      *int     `json:"stearic"`
	Ricinoleic   *int     `json:"ricinoleic"`
	Oleic        *int     `json:"oleic"`
	Linoleic     *int     `json:"linoleic"`
	Linolenic    *int     `json:"linolenic"`
	Hardness     *int     `json:"hardness"`
	Cleansing    *int     `json:"cleansing"`
	Conditioning *int     `json:"conditioning"`
	Bubbly       *int     `json:"bubbly"`
	Creamy       *int     `json:"creamy"`
	Iodine       *int     `json:"iodine"`
	Ins          *int     `json:"ins"`
	InciName     *string  `json:"inciName"`
	Family       *string  `json:"family"`
	Naoh         *float64 `json:"naoh"`
	CreatedAt    *int     `json:"createdAt"`
	UpdatedAt    *int     `json:"updatedAt"`
	DeletedAt    *int     `json:"deletedAt"`
}

type LipidWhere

type LipidWhere struct {
	ID               *IDFilter              `json:"id"`
	Name             *StringFilter          `json:"name"`
	Lauric           *IntFilter             `json:"lauric"`
	Myristic         *IntFilter             `json:"myristic"`
	Palmitic         *IntFilter             `json:"palmitic"`
	Stearic          *IntFilter             `json:"stearic"`
	Ricinoleic       *IntFilter             `json:"ricinoleic"`
	Oleic            *IntFilter             `json:"oleic"`
	Linoleic         *IntFilter             `json:"linoleic"`
	Linolenic        *IntFilter             `json:"linolenic"`
	Hardness         *IntFilter             `json:"hardness"`
	Cleansing        *IntFilter             `json:"cleansing"`
	Conditioning     *IntFilter             `json:"conditioning"`
	Bubbly           *IntFilter             `json:"bubbly"`
	Creamy           *IntFilter             `json:"creamy"`
	Iodine           *IntFilter             `json:"iodine"`
	Ins              *IntFilter             `json:"ins"`
	InciName         *StringFilter          `json:"inciName"`
	Family           *StringFilter          `json:"family"`
	Naoh             *FloatFilter           `json:"naoh"`
	CreatedAt        *IntFilter             `json:"createdAt"`
	UpdatedAt        *IntFilter             `json:"updatedAt"`
	DeletedAt        *IntFilter             `json:"deletedAt"`
	RecipeBatchLipid *RecipeBatchLipidWhere `json:"recipeBatchLipid"`
	RecipeLipid      *RecipeLipidWhere      `json:"recipeLipid"`
	LipidInventories *LipidInventoryWhere   `json:"lipidInventories"`
	Or               *LipidWhere            `json:"or"`
	And              *LipidWhere            `json:"and"`
}

type LipidsDeletePayload

type LipidsDeletePayload struct {
	Ids []string `json:"ids"`
}

type LipidsUpdatePayload

type LipidsUpdatePayload struct {
	Ok bool `json:"ok"`
}

type Lye

type Lye struct {
	ID             string          `json:"id"`
	Kind           string          `json:"kind"`
	Name           string          `json:"name"`
	Note           string          `json:"note"`
	CreatedAt      int             `json:"createdAt"`
	UpdatedAt      int             `json:"updatedAt"`
	DeletedAt      *int            `json:"deletedAt"`
	RecipeBatchLye *RecipeBatchLye `json:"recipeBatchLye"`
	LyeInventories []*LyeInventory `json:"lyeInventories"`
}

func (Lye) IsNode

func (Lye) IsNode()

type LyeConnection

type LyeConnection struct {
	Edges    []*LyeEdge `json:"edges"`
	PageInfo *PageInfo  `json:"pageInfo"`
}

type LyeCreateInput

type LyeCreateInput struct {
	Kind      string `json:"kind"`
	Name      string `json:"name"`
	Note      string `json:"note"`
	CreatedAt int    `json:"createdAt"`
	UpdatedAt int    `json:"updatedAt"`
	DeletedAt *int   `json:"deletedAt"`
}

type LyeDeletePayload

type LyeDeletePayload struct {
	ID string `json:"id"`
}

type LyeEdge

type LyeEdge struct {
	Cursor string `json:"cursor"`
	Node   *Lye   `json:"node"`
}

type LyeFilter

type LyeFilter struct {
	Search *string   `json:"search"`
	Where  *LyeWhere `json:"where"`
}

type LyeInventoriesDeletePayload

type LyeInventoriesDeletePayload struct {
	Ids []string `json:"ids"`
}

type LyeInventoriesUpdatePayload

type LyeInventoriesUpdatePayload struct {
	Ok bool `json:"ok"`
}

type LyeInventory

type LyeInventory struct {
	ID            string    `json:"id"`
	PurchaseDate  int       `json:"purchaseDate"`
	ExpiryDate    int       `json:"expiryDate"`
	Cost          float64   `json:"cost"`
	Weight        float64   `json:"weight"`
	Concentration float64   `json:"concentration"`
	Lye           *Lye      `json:"lye"`
	Supplier      *Supplier `json:"supplier"`
	CreatedAt     int       `json:"createdAt"`
	UpdatedAt     int       `json:"updatedAt"`
	DeletedAt     *int      `json:"deletedAt"`
}

func (LyeInventory) IsNode

func (LyeInventory) IsNode()

type LyeInventoryConnection

type LyeInventoryConnection struct {
	Edges    []*LyeInventoryEdge `json:"edges"`
	PageInfo *PageInfo           `json:"pageInfo"`
}

type LyeInventoryCreateInput

type LyeInventoryCreateInput struct {
	PurchaseDate  int     `json:"purchaseDate"`
	ExpiryDate    int     `json:"expiryDate"`
	Cost          float64 `json:"cost"`
	Weight        float64 `json:"weight"`
	Concentration float64 `json:"concentration"`
	LyeID         string  `json:"lyeId"`
	SupplierID    string  `json:"supplierId"`
	CreatedAt     int     `json:"createdAt"`
	UpdatedAt     int     `json:"updatedAt"`
	DeletedAt     *int    `json:"deletedAt"`
}

type LyeInventoryDeletePayload

type LyeInventoryDeletePayload struct {
	ID string `json:"id"`
}

type LyeInventoryEdge

type LyeInventoryEdge struct {
	Cursor string        `json:"cursor"`
	Node   *LyeInventory `json:"node"`
}

type LyeInventoryFilter

type LyeInventoryFilter struct {
	Search *string            `json:"search"`
	Where  *LyeInventoryWhere `json:"where"`
}

type LyeInventoryOrdering

type LyeInventoryOrdering struct {
	Sort      LyeInventorySort        `json:"sort"`
	Direction boilergql.SortDirection `json:"direction"`
}

type LyeInventoryPayload

type LyeInventoryPayload struct {
	LyeInventory *LyeInventory `json:"lyeInventory"`
}

type LyeInventorySort

type LyeInventorySort string

const (
	LyeInventorySortID            LyeInventorySort = "ID"
	LyeInventorySortPurchaseDate  LyeInventorySort = "PURCHASE_DATE"
	LyeInventorySortExpiryDate    LyeInventorySort = "EXPIRY_DATE"
	LyeInventorySortCost          LyeInventorySort = "COST"
	LyeInventorySortWeight        LyeInventorySort = "WEIGHT"
	LyeInventorySortConcentration LyeInventorySort = "CONCENTRATION"
	LyeInventorySortCreatedAt     LyeInventorySort = "CREATED_AT"
	LyeInventorySortUpdatedAt     LyeInventorySort = "UPDATED_AT"
	LyeInventorySortDeletedAt     LyeInventorySort = "DELETED_AT"
)

func (LyeInventorySort) IsValid

func (e LyeInventorySort) IsValid() bool

func (LyeInventorySort) MarshalGQL

func (e LyeInventorySort) MarshalGQL(w io.Writer)

func (LyeInventorySort) String

func (e LyeInventorySort) String() string

func (*LyeInventorySort) UnmarshalGQL

func (e *LyeInventorySort) UnmarshalGQL(v interface{}) error

type LyeInventoryUpdateInput

type LyeInventoryUpdateInput struct {
	PurchaseDate  *int     `json:"purchaseDate"`
	ExpiryDate    *int     `json:"expiryDate"`
	Cost          *float64 `json:"cost"`
	Weight        *float64 `json:"weight"`
	Concentration *float64 `json:"concentration"`
	LyeID         *string  `json:"lyeId"`
	SupplierID    *string  `json:"supplierId"`
	CreatedAt     *int     `json:"createdAt"`
	UpdatedAt     *int     `json:"updatedAt"`
	DeletedAt     *int     `json:"deletedAt"`
}

type LyeInventoryWhere

type LyeInventoryWhere struct {
	ID            *IDFilter          `json:"id"`
	PurchaseDate  *IntFilter         `json:"purchaseDate"`
	ExpiryDate    *IntFilter         `json:"expiryDate"`
	Cost          *FloatFilter       `json:"cost"`
	Weight        *FloatFilter       `json:"weight"`
	Concentration *FloatFilter       `json:"concentration"`
	Lye           *LyeWhere          `json:"lye"`
	Supplier      *SupplierWhere     `json:"supplier"`
	CreatedAt     *IntFilter         `json:"createdAt"`
	UpdatedAt     *IntFilter         `json:"updatedAt"`
	DeletedAt     *IntFilter         `json:"deletedAt"`
	Or            *LyeInventoryWhere `json:"or"`
	And           *LyeInventoryWhere `json:"and"`
}

type LyeOrdering

type LyeOrdering struct {
	Sort      LyeSort                 `json:"sort"`
	Direction boilergql.SortDirection `json:"direction"`
}

type LyePayload

type LyePayload struct {
	Lye *Lye `json:"lye"`
}

type LyeSort

type LyeSort string

const (
	LyeSortID        LyeSort = "ID"
	LyeSortKind      LyeSort = "KIND"
	LyeSortName      LyeSort = "NAME"
	LyeSortNote      LyeSort = "NOTE"
	LyeSortCreatedAt LyeSort = "CREATED_AT"
	LyeSortUpdatedAt LyeSort = "UPDATED_AT"
	LyeSortDeletedAt LyeSort = "DELETED_AT"
)

func (LyeSort) IsValid

func (e LyeSort) IsValid() bool

func (LyeSort) MarshalGQL

func (e LyeSort) MarshalGQL(w io.Writer)

func (LyeSort) String

func (e LyeSort) String() string

func (*LyeSort) UnmarshalGQL

func (e *LyeSort) UnmarshalGQL(v interface{}) error

type LyeUpdateInput

type LyeUpdateInput struct {
	Kind      *string `json:"kind"`
	Name      *string `json:"name"`
	Note      *string `json:"note"`
	CreatedAt *int    `json:"createdAt"`
	UpdatedAt *int    `json:"updatedAt"`
	DeletedAt *int    `json:"deletedAt"`
}

type LyeWhere

type LyeWhere struct {
	ID             *IDFilter            `json:"id"`
	Kind           *StringFilter        `json:"kind"`
	Name           *StringFilter        `json:"name"`
	Note           *StringFilter        `json:"note"`
	CreatedAt      *IntFilter           `json:"createdAt"`
	UpdatedAt      *IntFilter           `json:"updatedAt"`
	DeletedAt      *IntFilter           `json:"deletedAt"`
	RecipeBatchLye *RecipeBatchLyeWhere `json:"recipeBatchLye"`
	LyeInventories *LyeInventoryWhere   `json:"lyeInventories"`
	Or             *LyeWhere            `json:"or"`
	And            *LyeWhere            `json:"and"`
}

type LyesDeletePayload

type LyesDeletePayload struct {
	Ids []string `json:"ids"`
}

type LyesUpdatePayload

type LyesUpdatePayload struct {
	Ok bool `json:"ok"`
}

type MutationResolver

type MutationResolver interface {
	CreateAdditive(ctx context.Context, input AdditiveCreateInput) (*AdditivePayload, error)
	UpdateAdditive(ctx context.Context, id string, input AdditiveUpdateInput) (*AdditivePayload, error)
	UpdateAdditives(ctx context.Context, filter *AdditiveFilter, input AdditiveUpdateInput) (*AdditivesUpdatePayload, error)
	DeleteAdditive(ctx context.Context, id string) (*AdditiveDeletePayload, error)
	DeleteAdditives(ctx context.Context, filter *AdditiveFilter) (*AdditivesDeletePayload, error)
	CreateAdditiveInventory(ctx context.Context, input AdditiveInventoryCreateInput) (*AdditiveInventoryPayload, error)
	UpdateAdditiveInventory(ctx context.Context, id string, input AdditiveInventoryUpdateInput) (*AdditiveInventoryPayload, error)
	UpdateAdditiveInventories(ctx context.Context, filter *AdditiveInventoryFilter, input AdditiveInventoryUpdateInput) (*AdditiveInventoriesUpdatePayload, error)
	DeleteAdditiveInventory(ctx context.Context, id string) (*AdditiveInventoryDeletePayload, error)
	DeleteAdditiveInventories(ctx context.Context, filter *AdditiveInventoryFilter) (*AdditiveInventoriesDeletePayload, error)
	CreateAuthGroup(ctx context.Context, input AuthGroupCreateInput) (*AuthGroupPayload, error)
	UpdateAuthGroup(ctx context.Context, id string, input AuthGroupUpdateInput) (*AuthGroupPayload, error)
	UpdateAuthGroups(ctx context.Context, filter *AuthGroupFilter, input AuthGroupUpdateInput) (*AuthGroupsUpdatePayload, error)
	DeleteAuthGroup(ctx context.Context, id string) (*AuthGroupDeletePayload, error)
	DeleteAuthGroups(ctx context.Context, filter *AuthGroupFilter) (*AuthGroupsDeletePayload, error)
	CreateAuthGroupPermission(ctx context.Context, input AuthGroupPermissionCreateInput) (*AuthGroupPermissionPayload, error)
	UpdateAuthGroupPermission(ctx context.Context, id string, input AuthGroupPermissionUpdateInput) (*AuthGroupPermissionPayload, error)
	UpdateAuthGroupPermissions(ctx context.Context, filter *AuthGroupPermissionFilter, input AuthGroupPermissionUpdateInput) (*AuthGroupPermissionsUpdatePayload, error)
	DeleteAuthGroupPermission(ctx context.Context, id string) (*AuthGroupPermissionDeletePayload, error)
	DeleteAuthGroupPermissions(ctx context.Context, filter *AuthGroupPermissionFilter) (*AuthGroupPermissionsDeletePayload, error)
	CreateAuthPermission(ctx context.Context, input AuthPermissionCreateInput) (*AuthPermissionPayload, error)
	UpdateAuthPermission(ctx context.Context, id string, input AuthPermissionUpdateInput) (*AuthPermissionPayload, error)
	UpdateAuthPermissions(ctx context.Context, filter *AuthPermissionFilter, input AuthPermissionUpdateInput) (*AuthPermissionsUpdatePayload, error)
	DeleteAuthPermission(ctx context.Context, id string) (*AuthPermissionDeletePayload, error)
	DeleteAuthPermissions(ctx context.Context, filter *AuthPermissionFilter) (*AuthPermissionsDeletePayload, error)
	CreateAuthUser(ctx context.Context, input AuthUserCreateInput) (*AuthUserPayload, error)
	UpdateAuthUser(ctx context.Context, id string, input AuthUserUpdateInput) (*AuthUserPayload, error)
	UpdateAuthUsers(ctx context.Context, filter *AuthUserFilter, input AuthUserUpdateInput) (*AuthUsersUpdatePayload, error)
	DeleteAuthUser(ctx context.Context, id string) (*AuthUserDeletePayload, error)
	DeleteAuthUsers(ctx context.Context, filter *AuthUserFilter) (*AuthUsersDeletePayload, error)
	CreateAuthUserGroup(ctx context.Context, input AuthUserGroupCreateInput) (*AuthUserGroupPayload, error)
	UpdateAuthUserGroup(ctx context.Context, id string, input AuthUserGroupUpdateInput) (*AuthUserGroupPayload, error)
	UpdateAuthUserGroups(ctx context.Context, filter *AuthUserGroupFilter, input AuthUserGroupUpdateInput) (*AuthUserGroupsUpdatePayload, error)
	DeleteAuthUserGroup(ctx context.Context, id string) (*AuthUserGroupDeletePayload, error)
	DeleteAuthUserGroups(ctx context.Context, filter *AuthUserGroupFilter) (*AuthUserGroupsDeletePayload, error)
	CreateAuthUserUserPermission(ctx context.Context, input AuthUserUserPermissionCreateInput) (*AuthUserUserPermissionPayload, error)
	UpdateAuthUserUserPermission(ctx context.Context, id string, input AuthUserUserPermissionUpdateInput) (*AuthUserUserPermissionPayload, error)
	UpdateAuthUserUserPermissions(ctx context.Context, filter *AuthUserUserPermissionFilter, input AuthUserUserPermissionUpdateInput) (*AuthUserUserPermissionsUpdatePayload, error)
	DeleteAuthUserUserPermission(ctx context.Context, id string) (*AuthUserUserPermissionDeletePayload, error)
	DeleteAuthUserUserPermissions(ctx context.Context, filter *AuthUserUserPermissionFilter) (*AuthUserUserPermissionsDeletePayload, error)
	CreateFragrance(ctx context.Context, input FragranceCreateInput) (*FragrancePayload, error)
	UpdateFragrance(ctx context.Context, id string, input FragranceUpdateInput) (*FragrancePayload, error)
	UpdateFragrances(ctx context.Context, filter *FragranceFilter, input FragranceUpdateInput) (*FragrancesUpdatePayload, error)
	DeleteFragrance(ctx context.Context, id string) (*FragranceDeletePayload, error)
	DeleteFragrances(ctx context.Context, filter *FragranceFilter) (*FragrancesDeletePayload, error)
	CreateFragranceInventory(ctx context.Context, input FragranceInventoryCreateInput) (*FragranceInventoryPayload, error)
	UpdateFragranceInventory(ctx context.Context, id string, input FragranceInventoryUpdateInput) (*FragranceInventoryPayload, error)
	UpdateFragranceInventories(ctx context.Context, filter *FragranceInventoryFilter, input FragranceInventoryUpdateInput) (*FragranceInventoriesUpdatePayload, error)
	DeleteFragranceInventory(ctx context.Context, id string) (*FragranceInventoryDeletePayload, error)
	DeleteFragranceInventories(ctx context.Context, filter *FragranceInventoryFilter) (*FragranceInventoriesDeletePayload, error)
	CreateLipid(ctx context.Context, input LipidCreateInput) (*LipidPayload, error)
	UpdateLipid(ctx context.Context, id string, input LipidUpdateInput) (*LipidPayload, error)
	UpdateLipids(ctx context.Context, filter *LipidFilter, input LipidUpdateInput) (*LipidsUpdatePayload, error)
	DeleteLipid(ctx context.Context, id string) (*LipidDeletePayload, error)
	DeleteLipids(ctx context.Context, filter *LipidFilter) (*LipidsDeletePayload, error)
	CreateLipidInventory(ctx context.Context, input LipidInventoryCreateInput) (*LipidInventoryPayload, error)
	UpdateLipidInventory(ctx context.Context, id string, input LipidInventoryUpdateInput) (*LipidInventoryPayload, error)
	UpdateLipidInventories(ctx context.Context, filter *LipidInventoryFilter, input LipidInventoryUpdateInput) (*LipidInventoriesUpdatePayload, error)
	DeleteLipidInventory(ctx context.Context, id string) (*LipidInventoryDeletePayload, error)
	DeleteLipidInventories(ctx context.Context, filter *LipidInventoryFilter) (*LipidInventoriesDeletePayload, error)
	CreateLye(ctx context.Context, input LyeCreateInput) (*LyePayload, error)
	UpdateLye(ctx context.Context, id string, input LyeUpdateInput) (*LyePayload, error)
	UpdateLyes(ctx context.Context, filter *LyeFilter, input LyeUpdateInput) (*LyesUpdatePayload, error)
	DeleteLye(ctx context.Context, id string) (*LyeDeletePayload, error)
	DeleteLyes(ctx context.Context, filter *LyeFilter) (*LyesDeletePayload, error)
	CreateLyeInventory(ctx context.Context, input LyeInventoryCreateInput) (*LyeInventoryPayload, error)
	UpdateLyeInventory(ctx context.Context, id string, input LyeInventoryUpdateInput) (*LyeInventoryPayload, error)
	UpdateLyeInventories(ctx context.Context, filter *LyeInventoryFilter, input LyeInventoryUpdateInput) (*LyeInventoriesUpdatePayload, error)
	DeleteLyeInventory(ctx context.Context, id string) (*LyeInventoryDeletePayload, error)
	DeleteLyeInventories(ctx context.Context, filter *LyeInventoryFilter) (*LyeInventoriesDeletePayload, error)
	CreateRecipe(ctx context.Context, input RecipeCreateInput) (*RecipePayload, error)
	UpdateRecipe(ctx context.Context, id string, input RecipeUpdateInput) (*RecipePayload, error)
	UpdateRecipes(ctx context.Context, filter *RecipeFilter, input RecipeUpdateInput) (*RecipesUpdatePayload, error)
	DeleteRecipe(ctx context.Context, id string) (*RecipeDeletePayload, error)
	DeleteRecipes(ctx context.Context, filter *RecipeFilter) (*RecipesDeletePayload, error)
	CreateRecipeAdditive(ctx context.Context, input RecipeAdditiveCreateInput) (*RecipeAdditivePayload, error)
	UpdateRecipeAdditive(ctx context.Context, id string, input RecipeAdditiveUpdateInput) (*RecipeAdditivePayload, error)
	UpdateRecipeAdditives(ctx context.Context, filter *RecipeAdditiveFilter, input RecipeAdditiveUpdateInput) (*RecipeAdditivesUpdatePayload, error)
	DeleteRecipeAdditive(ctx context.Context, id string) (*RecipeAdditiveDeletePayload, error)
	DeleteRecipeAdditives(ctx context.Context, filter *RecipeAdditiveFilter) (*RecipeAdditivesDeletePayload, error)
	CreateRecipeBatch(ctx context.Context, input RecipeBatchCreateInput) (*RecipeBatchPayload, error)
	UpdateRecipeBatch(ctx context.Context, id string, input RecipeBatchUpdateInput) (*RecipeBatchPayload, error)
	UpdateRecipeBatches(ctx context.Context, filter *RecipeBatchFilter, input RecipeBatchUpdateInput) (*RecipeBatchesUpdatePayload, error)
	DeleteRecipeBatch(ctx context.Context, id string) (*RecipeBatchDeletePayload, error)
	DeleteRecipeBatches(ctx context.Context, filter *RecipeBatchFilter) (*RecipeBatchesDeletePayload, error)
	CreateRecipeBatchAdditive(ctx context.Context, input RecipeBatchAdditiveCreateInput) (*RecipeBatchAdditivePayload, error)
	UpdateRecipeBatchAdditive(ctx context.Context, id string, input RecipeBatchAdditiveUpdateInput) (*RecipeBatchAdditivePayload, error)
	UpdateRecipeBatchAdditives(ctx context.Context, filter *RecipeBatchAdditiveFilter, input RecipeBatchAdditiveUpdateInput) (*RecipeBatchAdditivesUpdatePayload, error)
	DeleteRecipeBatchAdditive(ctx context.Context, id string) (*RecipeBatchAdditiveDeletePayload, error)
	DeleteRecipeBatchAdditives(ctx context.Context, filter *RecipeBatchAdditiveFilter) (*RecipeBatchAdditivesDeletePayload, error)
	CreateRecipeBatchFragrance(ctx context.Context, input RecipeBatchFragranceCreateInput) (*RecipeBatchFragrancePayload, error)
	UpdateRecipeBatchFragrance(ctx context.Context, id string, input RecipeBatchFragranceUpdateInput) (*RecipeBatchFragrancePayload, error)
	UpdateRecipeBatchFragrances(ctx context.Context, filter *RecipeBatchFragranceFilter, input RecipeBatchFragranceUpdateInput) (*RecipeBatchFragrancesUpdatePayload, error)
	DeleteRecipeBatchFragrance(ctx context.Context, id string) (*RecipeBatchFragranceDeletePayload, error)
	DeleteRecipeBatchFragrances(ctx context.Context, filter *RecipeBatchFragranceFilter) (*RecipeBatchFragrancesDeletePayload, error)
	CreateRecipeBatchLipid(ctx context.Context, input RecipeBatchLipidCreateInput) (*RecipeBatchLipidPayload, error)
	UpdateRecipeBatchLipid(ctx context.Context, id string, input RecipeBatchLipidUpdateInput) (*RecipeBatchLipidPayload, error)
	UpdateRecipeBatchLipids(ctx context.Context, filter *RecipeBatchLipidFilter, input RecipeBatchLipidUpdateInput) (*RecipeBatchLipidsUpdatePayload, error)
	DeleteRecipeBatchLipid(ctx context.Context, id string) (*RecipeBatchLipidDeletePayload, error)
	DeleteRecipeBatchLipids(ctx context.Context, filter *RecipeBatchLipidFilter) (*RecipeBatchLipidsDeletePayload, error)
	CreateRecipeBatchLye(ctx context.Context, input RecipeBatchLyeCreateInput) (*RecipeBatchLyePayload, error)
	UpdateRecipeBatchLye(ctx context.Context, id string, input RecipeBatchLyeUpdateInput) (*RecipeBatchLyePayload, error)
	UpdateRecipeBatchLyes(ctx context.Context, filter *RecipeBatchLyeFilter, input RecipeBatchLyeUpdateInput) (*RecipeBatchLyesUpdatePayload, error)
	DeleteRecipeBatchLye(ctx context.Context, id string) (*RecipeBatchLyeDeletePayload, error)
	DeleteRecipeBatchLyes(ctx context.Context, filter *RecipeBatchLyeFilter) (*RecipeBatchLyesDeletePayload, error)
	CreateRecipeBatchNote(ctx context.Context, input RecipeBatchNoteCreateInput) (*RecipeBatchNotePayload, error)
	UpdateRecipeBatchNote(ctx context.Context, id string, input RecipeBatchNoteUpdateInput) (*RecipeBatchNotePayload, error)
	UpdateRecipeBatchNotes(ctx context.Context, filter *RecipeBatchNoteFilter, input RecipeBatchNoteUpdateInput) (*RecipeBatchNotesUpdatePayload, error)
	DeleteRecipeBatchNote(ctx context.Context, id string) (*RecipeBatchNoteDeletePayload, error)
	DeleteRecipeBatchNotes(ctx context.Context, filter *RecipeBatchNoteFilter) (*RecipeBatchNotesDeletePayload, error)
	CreateRecipeFragrance(ctx context.Context, input RecipeFragranceCreateInput) (*RecipeFragrancePayload, error)
	UpdateRecipeFragrance(ctx context.Context, id string, input RecipeFragranceUpdateInput) (*RecipeFragrancePayload, error)
	UpdateRecipeFragrances(ctx context.Context, filter *RecipeFragranceFilter, input RecipeFragranceUpdateInput) (*RecipeFragrancesUpdatePayload, error)
	DeleteRecipeFragrance(ctx context.Context, id string) (*RecipeFragranceDeletePayload, error)
	DeleteRecipeFragrances(ctx context.Context, filter *RecipeFragranceFilter) (*RecipeFragrancesDeletePayload, error)
	CreateRecipeLipid(ctx context.Context, input RecipeLipidCreateInput) (*RecipeLipidPayload, error)
	UpdateRecipeLipid(ctx context.Context, id string, input RecipeLipidUpdateInput) (*RecipeLipidPayload, error)
	UpdateRecipeLipids(ctx context.Context, filter *RecipeLipidFilter, input RecipeLipidUpdateInput) (*RecipeLipidsUpdatePayload, error)
	DeleteRecipeLipid(ctx context.Context, id string) (*RecipeLipidDeletePayload, error)
	DeleteRecipeLipids(ctx context.Context, filter *RecipeLipidFilter) (*RecipeLipidsDeletePayload, error)
	CreateRecipeStep(ctx context.Context, input RecipeStepCreateInput) (*RecipeStepPayload, error)
	UpdateRecipeStep(ctx context.Context, id string, input RecipeStepUpdateInput) (*RecipeStepPayload, error)
	UpdateRecipeSteps(ctx context.Context, filter *RecipeStepFilter, input RecipeStepUpdateInput) (*RecipeStepsUpdatePayload, error)
	DeleteRecipeStep(ctx context.Context, id string) (*RecipeStepDeletePayload, error)
	DeleteRecipeSteps(ctx context.Context, filter *RecipeStepFilter) (*RecipeStepsDeletePayload, error)
	CreateSupplier(ctx context.Context, input SupplierCreateInput) (*SupplierPayload, error)
	UpdateSupplier(ctx context.Context, id string, input SupplierUpdateInput) (*SupplierPayload, error)
	UpdateSuppliers(ctx context.Context, filter *SupplierFilter, input SupplierUpdateInput) (*SuppliersUpdatePayload, error)
	DeleteSupplier(ctx context.Context, id string) (*SupplierDeletePayload, error)
	DeleteSuppliers(ctx context.Context, filter *SupplierFilter) (*SuppliersDeletePayload, error)
}

type Node

type Node interface {
	IsNode()
}

type PageInfo

type PageInfo struct {
	HasNextPage     bool    `json:"hasNextPage"`
	HasPreviousPage bool    `json:"hasPreviousPage"`
	StartCursor     *string `json:"startCursor"`
	EndCursor       *string `json:"endCursor"`
}

type QueryResolver

type QueryResolver interface {
	Node(ctx context.Context, id string) (Node, error)
	Additive(ctx context.Context, id string) (*Additive, error)
	Additives(ctx context.Context, first int, after *string, ordering []*AdditiveOrdering, filter *AdditiveFilter) (*AdditiveConnection, error)
	AdditiveInventory(ctx context.Context, id string) (*AdditiveInventory, error)
	AdditiveInventories(ctx context.Context, first int, after *string, ordering []*AdditiveInventoryOrdering, filter *AdditiveInventoryFilter) (*AdditiveInventoryConnection, error)
	AuthGroup(ctx context.Context, id string) (*AuthGroup, error)
	AuthGroups(ctx context.Context, first int, after *string, ordering []*AuthGroupOrdering, filter *AuthGroupFilter) (*AuthGroupConnection, error)
	AuthGroupPermission(ctx context.Context, id string) (*AuthGroupPermission, error)
	AuthGroupPermissions(ctx context.Context, first int, after *string, ordering []*AuthGroupPermissionOrdering, filter *AuthGroupPermissionFilter) (*AuthGroupPermissionConnection, error)
	AuthPermission(ctx context.Context, id string) (*AuthPermission, error)
	AuthPermissions(ctx context.Context, first int, after *string, ordering []*AuthPermissionOrdering, filter *AuthPermissionFilter) (*AuthPermissionConnection, error)
	AuthUser(ctx context.Context, id string) (*AuthUser, error)
	AuthUsers(ctx context.Context, first int, after *string, ordering []*AuthUserOrdering, filter *AuthUserFilter) (*AuthUserConnection, error)
	AuthUserGroup(ctx context.Context, id string) (*AuthUserGroup, error)
	AuthUserGroups(ctx context.Context, first int, after *string, ordering []*AuthUserGroupOrdering, filter *AuthUserGroupFilter) (*AuthUserGroupConnection, error)
	AuthUserUserPermission(ctx context.Context, id string) (*AuthUserUserPermission, error)
	AuthUserUserPermissions(ctx context.Context, first int, after *string, ordering []*AuthUserUserPermissionOrdering, filter *AuthUserUserPermissionFilter) (*AuthUserUserPermissionConnection, error)
	Fragrance(ctx context.Context, id string) (*Fragrance, error)
	Fragrances(ctx context.Context, first int, after *string, ordering []*FragranceOrdering, filter *FragranceFilter) (*FragranceConnection, error)
	FragranceInventory(ctx context.Context, id string) (*FragranceInventory, error)
	FragranceInventories(ctx context.Context, first int, after *string, ordering []*FragranceInventoryOrdering, filter *FragranceInventoryFilter) (*FragranceInventoryConnection, error)
	Lipid(ctx context.Context, id string) (*Lipid, error)
	Lipids(ctx context.Context, first int, after *string, ordering []*LipidOrdering, filter *LipidFilter) (*LipidConnection, error)
	LipidInventory(ctx context.Context, id string) (*LipidInventory, error)
	LipidInventories(ctx context.Context, first int, after *string, ordering []*LipidInventoryOrdering, filter *LipidInventoryFilter) (*LipidInventoryConnection, error)
	Lye(ctx context.Context, id string) (*Lye, error)
	Lyes(ctx context.Context, first int, after *string, ordering []*LyeOrdering, filter *LyeFilter) (*LyeConnection, error)
	LyeInventory(ctx context.Context, id string) (*LyeInventory, error)
	LyeInventories(ctx context.Context, first int, after *string, ordering []*LyeInventoryOrdering, filter *LyeInventoryFilter) (*LyeInventoryConnection, error)
	Recipe(ctx context.Context, id string) (*Recipe, error)
	Recipes(ctx context.Context, first int, after *string, ordering []*RecipeOrdering, filter *RecipeFilter) (*RecipeConnection, error)
	RecipeAdditive(ctx context.Context, id string) (*RecipeAdditive, error)
	RecipeAdditives(ctx context.Context, first int, after *string, ordering []*RecipeAdditiveOrdering, filter *RecipeAdditiveFilter) (*RecipeAdditiveConnection, error)
	RecipeBatch(ctx context.Context, id string) (*RecipeBatch, error)
	RecipeBatches(ctx context.Context, first int, after *string, ordering []*RecipeBatchOrdering, filter *RecipeBatchFilter) (*RecipeBatchConnection, error)
	RecipeBatchAdditive(ctx context.Context, id string) (*RecipeBatchAdditive, error)
	RecipeBatchAdditives(ctx context.Context, first int, after *string, ordering []*RecipeBatchAdditiveOrdering, filter *RecipeBatchAdditiveFilter) (*RecipeBatchAdditiveConnection, error)
	RecipeBatchFragrance(ctx context.Context, id string) (*RecipeBatchFragrance, error)
	RecipeBatchFragrances(ctx context.Context, first int, after *string, ordering []*RecipeBatchFragranceOrdering, filter *RecipeBatchFragranceFilter) (*RecipeBatchFragranceConnection, error)
	RecipeBatchLipid(ctx context.Context, id string) (*RecipeBatchLipid, error)
	RecipeBatchLipids(ctx context.Context, first int, after *string, ordering []*RecipeBatchLipidOrdering, filter *RecipeBatchLipidFilter) (*RecipeBatchLipidConnection, error)
	RecipeBatchLye(ctx context.Context, id string) (*RecipeBatchLye, error)
	RecipeBatchLyes(ctx context.Context, first int, after *string, ordering []*RecipeBatchLyeOrdering, filter *RecipeBatchLyeFilter) (*RecipeBatchLyeConnection, error)
	RecipeBatchNote(ctx context.Context, id string) (*RecipeBatchNote, error)
	RecipeBatchNotes(ctx context.Context, first int, after *string, ordering []*RecipeBatchNoteOrdering, filter *RecipeBatchNoteFilter) (*RecipeBatchNoteConnection, error)
	RecipeFragrance(ctx context.Context, id string) (*RecipeFragrance, error)
	RecipeFragrances(ctx context.Context, first int, after *string, ordering []*RecipeFragranceOrdering, filter *RecipeFragranceFilter) (*RecipeFragranceConnection, error)
	RecipeLipid(ctx context.Context, id string) (*RecipeLipid, error)
	RecipeLipids(ctx context.Context, first int, after *string, ordering []*RecipeLipidOrdering, filter *RecipeLipidFilter) (*RecipeLipidConnection, error)
	RecipeStep(ctx context.Context, id string) (*RecipeStep, error)
	RecipeSteps(ctx context.Context, first int, after *string, ordering []*RecipeStepOrdering, filter *RecipeStepFilter) (*RecipeStepConnection, error)
	Supplier(ctx context.Context, id string) (*Supplier, error)
	Suppliers(ctx context.Context, first int, after *string, ordering []*SupplierOrdering, filter *SupplierFilter) (*SupplierConnection, error)
}

type Recipe

type Recipe struct {
	ID               string             `json:"id"`
	Name             string             `json:"name"`
	Note             string             `json:"note"`
	CreatedAt        int                `json:"createdAt"`
	UpdatedAt        int                `json:"updatedAt"`
	DeletedAt        *int               `json:"deletedAt"`
	RecipeAdditives  []*RecipeAdditive  `json:"recipeAdditives"`
	RecipeBatches    []*RecipeBatch     `json:"recipeBatches"`
	RecipeFragrances []*RecipeFragrance `json:"recipeFragrances"`
	RecipeLipids     []*RecipeLipid     `json:"recipeLipids"`
	RecipeSteps      []*RecipeStep      `json:"recipeSteps"`
}

func (Recipe) IsNode

func (Recipe) IsNode()

type RecipeAdditive

type RecipeAdditive struct {
	ID         string    `json:"id"`
	Percentage float64   `json:"percentage"`
	Additive   *Additive `json:"additive"`
	Recipe     *Recipe   `json:"recipe"`
	CreatedAt  int       `json:"createdAt"`
	UpdatedAt  int       `json:"updatedAt"`
	DeletedAt  *int      `json:"deletedAt"`
}

func (RecipeAdditive) IsNode

func (RecipeAdditive) IsNode()

type RecipeAdditiveConnection

type RecipeAdditiveConnection struct {
	Edges    []*RecipeAdditiveEdge `json:"edges"`
	PageInfo *PageInfo             `json:"pageInfo"`
}

type RecipeAdditiveCreateInput

type RecipeAdditiveCreateInput struct {
	Percentage float64 `json:"percentage"`
	AdditiveID string  `json:"additiveId"`
	RecipeID   string  `json:"recipeId"`
	CreatedAt  int     `json:"createdAt"`
	UpdatedAt  int     `json:"updatedAt"`
	DeletedAt  *int    `json:"deletedAt"`
}

type RecipeAdditiveDeletePayload

type RecipeAdditiveDeletePayload struct {
	ID string `json:"id"`
}

type RecipeAdditiveEdge

type RecipeAdditiveEdge struct {
	Cursor string          `json:"cursor"`
	Node   *RecipeAdditive `json:"node"`
}

type RecipeAdditiveFilter

type RecipeAdditiveFilter struct {
	Search *string              `json:"search"`
	Where  *RecipeAdditiveWhere `json:"where"`
}

type RecipeAdditiveOrdering

type RecipeAdditiveOrdering struct {
	Sort      RecipeAdditiveSort      `json:"sort"`
	Direction boilergql.SortDirection `json:"direction"`
}

type RecipeAdditivePayload

type RecipeAdditivePayload struct {
	RecipeAdditive *RecipeAdditive `json:"recipeAdditive"`
}

type RecipeAdditiveSort

type RecipeAdditiveSort string

const (
	RecipeAdditiveSortID         RecipeAdditiveSort = "ID"
	RecipeAdditiveSortPercentage RecipeAdditiveSort = "PERCENTAGE"
	RecipeAdditiveSortCreatedAt  RecipeAdditiveSort = "CREATED_AT"
	RecipeAdditiveSortUpdatedAt  RecipeAdditiveSort = "UPDATED_AT"
	RecipeAdditiveSortDeletedAt  RecipeAdditiveSort = "DELETED_AT"
)

func (RecipeAdditiveSort) IsValid

func (e RecipeAdditiveSort) IsValid() bool

func (RecipeAdditiveSort) MarshalGQL

func (e RecipeAdditiveSort) MarshalGQL(w io.Writer)

func (RecipeAdditiveSort) String

func (e RecipeAdditiveSort) String() string

func (*RecipeAdditiveSort) UnmarshalGQL

func (e *RecipeAdditiveSort) UnmarshalGQL(v interface{}) error

type RecipeAdditiveUpdateInput

type RecipeAdditiveUpdateInput struct {
	Percentage *float64 `json:"percentage"`
	AdditiveID *string  `json:"additiveId"`
	RecipeID   *string  `json:"recipeId"`
	CreatedAt  *int     `json:"createdAt"`
	UpdatedAt  *int     `json:"updatedAt"`
	DeletedAt  *int     `json:"deletedAt"`
}

type RecipeAdditiveWhere

type RecipeAdditiveWhere struct {
	ID         *IDFilter            `json:"id"`
	Percentage *FloatFilter         `json:"percentage"`
	Additive   *AdditiveWhere       `json:"additive"`
	Recipe     *RecipeWhere         `json:"recipe"`
	CreatedAt  *IntFilter           `json:"createdAt"`
	UpdatedAt  *IntFilter           `json:"updatedAt"`
	DeletedAt  *IntFilter           `json:"deletedAt"`
	Or         *RecipeAdditiveWhere `json:"or"`
	And        *RecipeAdditiveWhere `json:"and"`
}

type RecipeAdditivesDeletePayload

type RecipeAdditivesDeletePayload struct {
	Ids []string `json:"ids"`
}

type RecipeAdditivesUpdatePayload

type RecipeAdditivesUpdatePayload struct {
	Ok bool `json:"ok"`
}

type RecipeBatch

type RecipeBatch struct {
	ID                         string                  `json:"id"`
	Tag                        string                  `json:"tag"`
	ProductionDate             int                     `json:"productionDate"`
	SellableDate               int                     `json:"sellableDate"`
	Note                       string                  `json:"note"`
	LipidWeight                float64                 `json:"lipidWeight"`
	ProductionWeight           float64                 `json:"productionWeight"`
	CuredWeight                float64                 `json:"curedWeight"`
	Recipe                     *Recipe                 `json:"recipe"`
	CreatedAt                  int                     `json:"createdAt"`
	UpdatedAt                  int                     `json:"updatedAt"`
	DeletedAt                  *int                    `json:"deletedAt"`
	BatchRecipeBatchAdditives  []*RecipeBatchAdditive  `json:"batchRecipeBatchAdditives"`
	BatchRecipeBatchFragrances []*RecipeBatchFragrance `json:"batchRecipeBatchFragrances"`
	BatchRecipeBatchLipids     []*RecipeBatchLipid     `json:"batchRecipeBatchLipids"`
	BatchRecipeBatchLyes       []*RecipeBatchLye       `json:"batchRecipeBatchLyes"`
	BatchRecipeBatchNotes      []*RecipeBatchNote      `json:"batchRecipeBatchNotes"`
}

func (RecipeBatch) IsNode

func (RecipeBatch) IsNode()

type RecipeBatchAdditive

type RecipeBatchAdditive struct {
	ID        string       `json:"id"`
	Weight    float64      `json:"weight"`
	Cost      float64      `json:"cost"`
	Additive  *Additive    `json:"additive"`
	Batch     *RecipeBatch `json:"batch"`
	CreatedAt int          `json:"createdAt"`
	UpdatedAt int          `json:"updatedAt"`
	DeletedAt *int         `json:"deletedAt"`
}

func (RecipeBatchAdditive) IsNode

func (RecipeBatchAdditive) IsNode()

type RecipeBatchAdditiveConnection

type RecipeBatchAdditiveConnection struct {
	Edges    []*RecipeBatchAdditiveEdge `json:"edges"`
	PageInfo *PageInfo                  `json:"pageInfo"`
}

type RecipeBatchAdditiveCreateInput

type RecipeBatchAdditiveCreateInput struct {
	Weight     float64 `json:"weight"`
	Cost       float64 `json:"cost"`
	AdditiveID string  `json:"additiveId"`
	BatchID    string  `json:"batchId"`
	CreatedAt  int     `json:"createdAt"`
	UpdatedAt  int     `json:"updatedAt"`
	DeletedAt  *int    `json:"deletedAt"`
}

type RecipeBatchAdditiveDeletePayload

type RecipeBatchAdditiveDeletePayload struct {
	ID string `json:"id"`
}

type RecipeBatchAdditiveEdge

type RecipeBatchAdditiveEdge struct {
	Cursor string               `json:"cursor"`
	Node   *RecipeBatchAdditive `json:"node"`
}

type RecipeBatchAdditiveFilter

type RecipeBatchAdditiveFilter struct {
	Search *string                   `json:"search"`
	Where  *RecipeBatchAdditiveWhere `json:"where"`
}

type RecipeBatchAdditiveOrdering

type RecipeBatchAdditiveOrdering struct {
	Sort      RecipeBatchAdditiveSort `json:"sort"`
	Direction boilergql.SortDirection `json:"direction"`
}

type RecipeBatchAdditivePayload

type RecipeBatchAdditivePayload struct {
	RecipeBatchAdditive *RecipeBatchAdditive `json:"recipeBatchAdditive"`
}

type RecipeBatchAdditiveSort

type RecipeBatchAdditiveSort string

const (
	RecipeBatchAdditiveSortID        RecipeBatchAdditiveSort = "ID"
	RecipeBatchAdditiveSortWeight    RecipeBatchAdditiveSort = "WEIGHT"
	RecipeBatchAdditiveSortCost      RecipeBatchAdditiveSort = "COST"
	RecipeBatchAdditiveSortCreatedAt RecipeBatchAdditiveSort = "CREATED_AT"
	RecipeBatchAdditiveSortUpdatedAt RecipeBatchAdditiveSort = "UPDATED_AT"
	RecipeBatchAdditiveSortDeletedAt RecipeBatchAdditiveSort = "DELETED_AT"
)

func (RecipeBatchAdditiveSort) IsValid

func (e RecipeBatchAdditiveSort) IsValid() bool

func (RecipeBatchAdditiveSort) MarshalGQL

func (e RecipeBatchAdditiveSort) MarshalGQL(w io.Writer)

func (RecipeBatchAdditiveSort) String

func (e RecipeBatchAdditiveSort) String() string

func (*RecipeBatchAdditiveSort) UnmarshalGQL

func (e *RecipeBatchAdditiveSort) UnmarshalGQL(v interface{}) error

type RecipeBatchAdditiveUpdateInput

type RecipeBatchAdditiveUpdateInput struct {
	Weight     *float64 `json:"weight"`
	Cost       *float64 `json:"cost"`
	AdditiveID *string  `json:"additiveId"`
	BatchID    *string  `json:"batchId"`
	CreatedAt  *int     `json:"createdAt"`
	UpdatedAt  *int     `json:"updatedAt"`
	DeletedAt  *int     `json:"deletedAt"`
}

type RecipeBatchAdditiveWhere

type RecipeBatchAdditiveWhere struct {
	ID        *IDFilter                 `json:"id"`
	Weight    *FloatFilter              `json:"weight"`
	Cost      *FloatFilter              `json:"cost"`
	Additive  *AdditiveWhere            `json:"additive"`
	Batch     *RecipeBatchWhere         `json:"batch"`
	CreatedAt *IntFilter                `json:"createdAt"`
	UpdatedAt *IntFilter                `json:"updatedAt"`
	DeletedAt *IntFilter                `json:"deletedAt"`
	Or        *RecipeBatchAdditiveWhere `json:"or"`
	And       *RecipeBatchAdditiveWhere `json:"and"`
}

type RecipeBatchAdditivesDeletePayload

type RecipeBatchAdditivesDeletePayload struct {
	Ids []string `json:"ids"`
}

type RecipeBatchAdditivesUpdatePayload

type RecipeBatchAdditivesUpdatePayload struct {
	Ok bool `json:"ok"`
}

type RecipeBatchConnection

type RecipeBatchConnection struct {
	Edges    []*RecipeBatchEdge `json:"edges"`
	PageInfo *PageInfo          `json:"pageInfo"`
}

type RecipeBatchCreateInput

type RecipeBatchCreateInput struct {
	Tag              string  `json:"tag"`
	ProductionDate   int     `json:"productionDate"`
	SellableDate     int     `json:"sellableDate"`
	Note             string  `json:"note"`
	LipidWeight      float64 `json:"lipidWeight"`
	ProductionWeight float64 `json:"productionWeight"`
	CuredWeight      float64 `json:"curedWeight"`
	RecipeID         string  `json:"recipeId"`
	CreatedAt        int     `json:"createdAt"`
	UpdatedAt        int     `json:"updatedAt"`
	DeletedAt        *int    `json:"deletedAt"`
}

type RecipeBatchDeletePayload

type RecipeBatchDeletePayload struct {
	ID string `json:"id"`
}

type RecipeBatchEdge

type RecipeBatchEdge struct {
	Cursor string       `json:"cursor"`
	Node   *RecipeBatch `json:"node"`
}

type RecipeBatchFilter

type RecipeBatchFilter struct {
	Search *string           `json:"search"`
	Where  *RecipeBatchWhere `json:"where"`
}

type RecipeBatchFragrance

type RecipeBatchFragrance struct {
	ID        string       `json:"id"`
	Weight    float64      `json:"weight"`
	Cost      float64      `json:"cost"`
	Fragrance *Fragrance   `json:"fragrance"`
	Batch     *RecipeBatch `json:"batch"`
	CreatedAt int          `json:"createdAt"`
	UpdatedAt int          `json:"updatedAt"`
	DeletedAt *int         `json:"deletedAt"`
}

func (RecipeBatchFragrance) IsNode

func (RecipeBatchFragrance) IsNode()

type RecipeBatchFragranceConnection

type RecipeBatchFragranceConnection struct {
	Edges    []*RecipeBatchFragranceEdge `json:"edges"`
	PageInfo *PageInfo                   `json:"pageInfo"`
}

type RecipeBatchFragranceCreateInput

type RecipeBatchFragranceCreateInput struct {
	Weight      float64 `json:"weight"`
	Cost        float64 `json:"cost"`
	FragranceID string  `json:"fragranceId"`
	BatchID     string  `json:"batchId"`
	CreatedAt   int     `json:"createdAt"`
	UpdatedAt   int     `json:"updatedAt"`
	DeletedAt   *int    `json:"deletedAt"`
}

type RecipeBatchFragranceDeletePayload

type RecipeBatchFragranceDeletePayload struct {
	ID string `json:"id"`
}

type RecipeBatchFragranceEdge

type RecipeBatchFragranceEdge struct {
	Cursor string                `json:"cursor"`
	Node   *RecipeBatchFragrance `json:"node"`
}

type RecipeBatchFragranceFilter

type RecipeBatchFragranceFilter struct {
	Search *string                    `json:"search"`
	Where  *RecipeBatchFragranceWhere `json:"where"`
}

type RecipeBatchFragranceOrdering

type RecipeBatchFragranceOrdering struct {
	Sort      RecipeBatchFragranceSort `json:"sort"`
	Direction boilergql.SortDirection  `json:"direction"`
}

type RecipeBatchFragrancePayload

type RecipeBatchFragrancePayload struct {
	RecipeBatchFragrance *RecipeBatchFragrance `json:"recipeBatchFragrance"`
}

type RecipeBatchFragranceSort

type RecipeBatchFragranceSort string

const (
	RecipeBatchFragranceSortID        RecipeBatchFragranceSort = "ID"
	RecipeBatchFragranceSortWeight    RecipeBatchFragranceSort = "WEIGHT"
	RecipeBatchFragranceSortCost      RecipeBatchFragranceSort = "COST"
	RecipeBatchFragranceSortCreatedAt RecipeBatchFragranceSort = "CREATED_AT"
	RecipeBatchFragranceSortUpdatedAt RecipeBatchFragranceSort = "UPDATED_AT"
	RecipeBatchFragranceSortDeletedAt RecipeBatchFragranceSort = "DELETED_AT"
)

func (RecipeBatchFragranceSort) IsValid

func (e RecipeBatchFragranceSort) IsValid() bool

func (RecipeBatchFragranceSort) MarshalGQL

func (e RecipeBatchFragranceSort) MarshalGQL(w io.Writer)

func (RecipeBatchFragranceSort) String

func (e RecipeBatchFragranceSort) String() string

func (*RecipeBatchFragranceSort) UnmarshalGQL

func (e *RecipeBatchFragranceSort) UnmarshalGQL(v interface{}) error

type RecipeBatchFragranceUpdateInput

type RecipeBatchFragranceUpdateInput struct {
	Weight      *float64 `json:"weight"`
	Cost        *float64 `json:"cost"`
	FragranceID *string  `json:"fragranceId"`
	BatchID     *string  `json:"batchId"`
	CreatedAt   *int     `json:"createdAt"`
	UpdatedAt   *int     `json:"updatedAt"`
	DeletedAt   *int     `json:"deletedAt"`
}

type RecipeBatchFragranceWhere

type RecipeBatchFragranceWhere struct {
	ID        *IDFilter                  `json:"id"`
	Weight    *FloatFilter               `json:"weight"`
	Cost      *FloatFilter               `json:"cost"`
	Fragrance *FragranceWhere            `json:"fragrance"`
	Batch     *RecipeBatchWhere          `json:"batch"`
	CreatedAt *IntFilter                 `json:"createdAt"`
	UpdatedAt *IntFilter                 `json:"updatedAt"`
	DeletedAt *IntFilter                 `json:"deletedAt"`
	Or        *RecipeBatchFragranceWhere `json:"or"`
	And       *RecipeBatchFragranceWhere `json:"and"`
}

type RecipeBatchFragrancesDeletePayload

type RecipeBatchFragrancesDeletePayload struct {
	Ids []string `json:"ids"`
}

type RecipeBatchFragrancesUpdatePayload

type RecipeBatchFragrancesUpdatePayload struct {
	Ok bool `json:"ok"`
}

type RecipeBatchLipid

type RecipeBatchLipid struct {
	ID        string       `json:"id"`
	Weight    float64      `json:"weight"`
	Cost      float64      `json:"cost"`
	Lipid     *Lipid       `json:"lipid"`
	Batch     *RecipeBatch `json:"batch"`
	CreatedAt int          `json:"createdAt"`
	UpdatedAt int          `json:"updatedAt"`
	DeletedAt *int         `json:"deletedAt"`
}

func (RecipeBatchLipid) IsNode

func (RecipeBatchLipid) IsNode()

type RecipeBatchLipidConnection

type RecipeBatchLipidConnection struct {
	Edges    []*RecipeBatchLipidEdge `json:"edges"`
	PageInfo *PageInfo               `json:"pageInfo"`
}

type RecipeBatchLipidCreateInput

type RecipeBatchLipidCreateInput struct {
	Weight    float64 `json:"weight"`
	Cost      float64 `json:"cost"`
	LipidID   string  `json:"lipidId"`
	BatchID   string  `json:"batchId"`
	CreatedAt int     `json:"createdAt"`
	UpdatedAt int     `json:"updatedAt"`
	DeletedAt *int    `json:"deletedAt"`
}

type RecipeBatchLipidDeletePayload

type RecipeBatchLipidDeletePayload struct {
	ID string `json:"id"`
}

type RecipeBatchLipidEdge

type RecipeBatchLipidEdge struct {
	Cursor string            `json:"cursor"`
	Node   *RecipeBatchLipid `json:"node"`
}

type RecipeBatchLipidFilter

type RecipeBatchLipidFilter struct {
	Search *string                `json:"search"`
	Where  *RecipeBatchLipidWhere `json:"where"`
}

type RecipeBatchLipidOrdering

type RecipeBatchLipidOrdering struct {
	Sort      RecipeBatchLipidSort    `json:"sort"`
	Direction boilergql.SortDirection `json:"direction"`
}

type RecipeBatchLipidPayload

type RecipeBatchLipidPayload struct {
	RecipeBatchLipid *RecipeBatchLipid `json:"recipeBatchLipid"`
}

type RecipeBatchLipidSort

type RecipeBatchLipidSort string

const (
	RecipeBatchLipidSortID        RecipeBatchLipidSort = "ID"
	RecipeBatchLipidSortWeight    RecipeBatchLipidSort = "WEIGHT"
	RecipeBatchLipidSortCost      RecipeBatchLipidSort = "COST"
	RecipeBatchLipidSortCreatedAt RecipeBatchLipidSort = "CREATED_AT"
	RecipeBatchLipidSortUpdatedAt RecipeBatchLipidSort = "UPDATED_AT"
	RecipeBatchLipidSortDeletedAt RecipeBatchLipidSort = "DELETED_AT"
)

func (RecipeBatchLipidSort) IsValid

func (e RecipeBatchLipidSort) IsValid() bool

func (RecipeBatchLipidSort) MarshalGQL

func (e RecipeBatchLipidSort) MarshalGQL(w io.Writer)

func (RecipeBatchLipidSort) String

func (e RecipeBatchLipidSort) String() string

func (*RecipeBatchLipidSort) UnmarshalGQL

func (e *RecipeBatchLipidSort) UnmarshalGQL(v interface{}) error

type RecipeBatchLipidUpdateInput

type RecipeBatchLipidUpdateInput struct {
	Weight    *float64 `json:"weight"`
	Cost      *float64 `json:"cost"`
	LipidID   *string  `json:"lipidId"`
	BatchID   *string  `json:"batchId"`
	CreatedAt *int     `json:"createdAt"`
	UpdatedAt *int     `json:"updatedAt"`
	DeletedAt *int     `json:"deletedAt"`
}

type RecipeBatchLipidWhere

type RecipeBatchLipidWhere struct {
	ID        *IDFilter              `json:"id"`
	Weight    *FloatFilter           `json:"weight"`
	Cost      *FloatFilter           `json:"cost"`
	Lipid     *LipidWhere            `json:"lipid"`
	Batch     *RecipeBatchWhere      `json:"batch"`
	CreatedAt *IntFilter             `json:"createdAt"`
	UpdatedAt *IntFilter             `json:"updatedAt"`
	DeletedAt *IntFilter             `json:"deletedAt"`
	Or        *RecipeBatchLipidWhere `json:"or"`
	And       *RecipeBatchLipidWhere `json:"and"`
}

type RecipeBatchLipidsDeletePayload

type RecipeBatchLipidsDeletePayload struct {
	Ids []string `json:"ids"`
}

type RecipeBatchLipidsUpdatePayload

type RecipeBatchLipidsUpdatePayload struct {
	Ok bool `json:"ok"`
}

type RecipeBatchLye

type RecipeBatchLye struct {
	ID        string       `json:"id"`
	Weight    float64      `json:"weight"`
	Discount  float64      `json:"discount"`
	Cost      float64      `json:"cost"`
	Lye       *Lye         `json:"lye"`
	Batch     *RecipeBatch `json:"batch"`
	CreatedAt int          `json:"createdAt"`
	UpdatedAt int          `json:"updatedAt"`
	DeletedAt *int         `json:"deletedAt"`
}

func (RecipeBatchLye) IsNode

func (RecipeBatchLye) IsNode()

type RecipeBatchLyeConnection

type RecipeBatchLyeConnection struct {
	Edges    []*RecipeBatchLyeEdge `json:"edges"`
	PageInfo *PageInfo             `json:"pageInfo"`
}

type RecipeBatchLyeCreateInput

type RecipeBatchLyeCreateInput struct {
	Weight    float64 `json:"weight"`
	Discount  float64 `json:"discount"`
	Cost      float64 `json:"cost"`
	LyeID     string  `json:"lyeId"`
	BatchID   string  `json:"batchId"`
	CreatedAt int     `json:"createdAt"`
	UpdatedAt int     `json:"updatedAt"`
	DeletedAt *int    `json:"deletedAt"`
}

type RecipeBatchLyeDeletePayload

type RecipeBatchLyeDeletePayload struct {
	ID string `json:"id"`
}

type RecipeBatchLyeEdge

type RecipeBatchLyeEdge struct {
	Cursor string          `json:"cursor"`
	Node   *RecipeBatchLye `json:"node"`
}

type RecipeBatchLyeFilter

type RecipeBatchLyeFilter struct {
	Search *string              `json:"search"`
	Where  *RecipeBatchLyeWhere `json:"where"`
}

type RecipeBatchLyeOrdering

type RecipeBatchLyeOrdering struct {
	Sort      RecipeBatchLyeSort      `json:"sort"`
	Direction boilergql.SortDirection `json:"direction"`
}

type RecipeBatchLyePayload

type RecipeBatchLyePayload struct {
	RecipeBatchLye *RecipeBatchLye `json:"recipeBatchLye"`
}

type RecipeBatchLyeSort

type RecipeBatchLyeSort string

const (
	RecipeBatchLyeSortID        RecipeBatchLyeSort = "ID"
	RecipeBatchLyeSortWeight    RecipeBatchLyeSort = "WEIGHT"
	RecipeBatchLyeSortDiscount  RecipeBatchLyeSort = "DISCOUNT"
	RecipeBatchLyeSortCost      RecipeBatchLyeSort = "COST"
	RecipeBatchLyeSortCreatedAt RecipeBatchLyeSort = "CREATED_AT"
	RecipeBatchLyeSortUpdatedAt RecipeBatchLyeSort = "UPDATED_AT"
	RecipeBatchLyeSortDeletedAt RecipeBatchLyeSort = "DELETED_AT"
)

func (RecipeBatchLyeSort) IsValid

func (e RecipeBatchLyeSort) IsValid() bool

func (RecipeBatchLyeSort) MarshalGQL

func (e RecipeBatchLyeSort) MarshalGQL(w io.Writer)

func (RecipeBatchLyeSort) String

func (e RecipeBatchLyeSort) String() string

func (*RecipeBatchLyeSort) UnmarshalGQL

func (e *RecipeBatchLyeSort) UnmarshalGQL(v interface{}) error

type RecipeBatchLyeUpdateInput

type RecipeBatchLyeUpdateInput struct {
	Weight    *float64 `json:"weight"`
	Discount  *float64 `json:"discount"`
	Cost      *float64 `json:"cost"`
	LyeID     *string  `json:"lyeId"`
	BatchID   *string  `json:"batchId"`
	CreatedAt *int     `json:"createdAt"`
	UpdatedAt *int     `json:"updatedAt"`
	DeletedAt *int     `json:"deletedAt"`
}

type RecipeBatchLyeWhere

type RecipeBatchLyeWhere struct {
	ID        *IDFilter            `json:"id"`
	Weight    *FloatFilter         `json:"weight"`
	Discount  *FloatFilter         `json:"discount"`
	Cost      *FloatFilter         `json:"cost"`
	Lye       *LyeWhere            `json:"lye"`
	Batch     *RecipeBatchWhere    `json:"batch"`
	CreatedAt *IntFilter           `json:"createdAt"`
	UpdatedAt *IntFilter           `json:"updatedAt"`
	DeletedAt *IntFilter           `json:"deletedAt"`
	Or        *RecipeBatchLyeWhere `json:"or"`
	And       *RecipeBatchLyeWhere `json:"and"`
}

type RecipeBatchLyesDeletePayload

type RecipeBatchLyesDeletePayload struct {
	Ids []string `json:"ids"`
}

type RecipeBatchLyesUpdatePayload

type RecipeBatchLyesUpdatePayload struct {
	Ok bool `json:"ok"`
}

type RecipeBatchNote

type RecipeBatchNote struct {
	ID        string       `json:"id"`
	Note      string       `json:"note"`
	Link      string       `json:"link"`
	Batch     *RecipeBatch `json:"batch"`
	CreatedAt int          `json:"createdAt"`
	UpdatedAt int          `json:"updatedAt"`
	DeletedAt *int         `json:"deletedAt"`
}

func (RecipeBatchNote) IsNode

func (RecipeBatchNote) IsNode()

type RecipeBatchNoteConnection

type RecipeBatchNoteConnection struct {
	Edges    []*RecipeBatchNoteEdge `json:"edges"`
	PageInfo *PageInfo              `json:"pageInfo"`
}

type RecipeBatchNoteCreateInput

type RecipeBatchNoteCreateInput struct {
	Note      string `json:"note"`
	Link      string `json:"link"`
	BatchID   string `json:"batchId"`
	CreatedAt int    `json:"createdAt"`
	UpdatedAt int    `json:"updatedAt"`
	DeletedAt *int   `json:"deletedAt"`
}

type RecipeBatchNoteDeletePayload

type RecipeBatchNoteDeletePayload struct {
	ID string `json:"id"`
}

type RecipeBatchNoteEdge

type RecipeBatchNoteEdge struct {
	Cursor string           `json:"cursor"`
	Node   *RecipeBatchNote `json:"node"`
}

type RecipeBatchNoteFilter

type RecipeBatchNoteFilter struct {
	Search *string               `json:"search"`
	Where  *RecipeBatchNoteWhere `json:"where"`
}

type RecipeBatchNoteOrdering

type RecipeBatchNoteOrdering struct {
	Sort      RecipeBatchNoteSort     `json:"sort"`
	Direction boilergql.SortDirection `json:"direction"`
}

type RecipeBatchNotePayload

type RecipeBatchNotePayload struct {
	RecipeBatchNote *RecipeBatchNote `json:"recipeBatchNote"`
}

type RecipeBatchNoteSort

type RecipeBatchNoteSort string

const (
	RecipeBatchNoteSortID        RecipeBatchNoteSort = "ID"
	RecipeBatchNoteSortNote      RecipeBatchNoteSort = "NOTE"
	RecipeBatchNoteSortLink      RecipeBatchNoteSort = "LINK"
	RecipeBatchNoteSortCreatedAt RecipeBatchNoteSort = "CREATED_AT"
	RecipeBatchNoteSortUpdatedAt RecipeBatchNoteSort = "UPDATED_AT"
	RecipeBatchNoteSortDeletedAt RecipeBatchNoteSort = "DELETED_AT"
)

func (RecipeBatchNoteSort) IsValid

func (e RecipeBatchNoteSort) IsValid() bool

func (RecipeBatchNoteSort) MarshalGQL

func (e RecipeBatchNoteSort) MarshalGQL(w io.Writer)

func (RecipeBatchNoteSort) String

func (e RecipeBatchNoteSort) String() string

func (*RecipeBatchNoteSort) UnmarshalGQL

func (e *RecipeBatchNoteSort) UnmarshalGQL(v interface{}) error

type RecipeBatchNoteUpdateInput

type RecipeBatchNoteUpdateInput struct {
	Note      *string `json:"note"`
	Link      *string `json:"link"`
	BatchID   *string `json:"batchId"`
	CreatedAt *int    `json:"createdAt"`
	UpdatedAt *int    `json:"updatedAt"`
	DeletedAt *int    `json:"deletedAt"`
}

type RecipeBatchNoteWhere

type RecipeBatchNoteWhere struct {
	ID        *IDFilter             `json:"id"`
	Note      *StringFilter         `json:"note"`
	Link      *StringFilter         `json:"link"`
	Batch     *RecipeBatchWhere     `json:"batch"`
	CreatedAt *IntFilter            `json:"createdAt"`
	UpdatedAt *IntFilter            `json:"updatedAt"`
	DeletedAt *IntFilter            `json:"deletedAt"`
	Or        *RecipeBatchNoteWhere `json:"or"`
	And       *RecipeBatchNoteWhere `json:"and"`
}

type RecipeBatchNotesDeletePayload

type RecipeBatchNotesDeletePayload struct {
	Ids []string `json:"ids"`
}

type RecipeBatchNotesUpdatePayload

type RecipeBatchNotesUpdatePayload struct {
	Ok bool `json:"ok"`
}

type RecipeBatchOrdering

type RecipeBatchOrdering struct {
	Sort      RecipeBatchSort         `json:"sort"`
	Direction boilergql.SortDirection `json:"direction"`
}

type RecipeBatchPayload

type RecipeBatchPayload struct {
	RecipeBatch *RecipeBatch `json:"recipeBatch"`
}

type RecipeBatchSort

type RecipeBatchSort string

const (
	RecipeBatchSortID               RecipeBatchSort = "ID"
	RecipeBatchSortTag              RecipeBatchSort = "TAG"
	RecipeBatchSortProductionDate   RecipeBatchSort = "PRODUCTION_DATE"
	RecipeBatchSortSellableDate     RecipeBatchSort = "SELLABLE_DATE"
	RecipeBatchSortNote             RecipeBatchSort = "NOTE"
	RecipeBatchSortLipidWeight      RecipeBatchSort = "LIPID_WEIGHT"
	RecipeBatchSortProductionWeight RecipeBatchSort = "PRODUCTION_WEIGHT"
	RecipeBatchSortCuredWeight      RecipeBatchSort = "CURED_WEIGHT"
	RecipeBatchSortCreatedAt        RecipeBatchSort = "CREATED_AT"
	RecipeBatchSortUpdatedAt        RecipeBatchSort = "UPDATED_AT"
	RecipeBatchSortDeletedAt        RecipeBatchSort = "DELETED_AT"
)

func (RecipeBatchSort) IsValid

func (e RecipeBatchSort) IsValid() bool

func (RecipeBatchSort) MarshalGQL

func (e RecipeBatchSort) MarshalGQL(w io.Writer)

func (RecipeBatchSort) String

func (e RecipeBatchSort) String() string

func (*RecipeBatchSort) UnmarshalGQL

func (e *RecipeBatchSort) UnmarshalGQL(v interface{}) error

type RecipeBatchUpdateInput

type RecipeBatchUpdateInput struct {
	Tag              *string  `json:"tag"`
	ProductionDate   *int     `json:"productionDate"`
	SellableDate     *int     `json:"sellableDate"`
	Note             *string  `json:"note"`
	LipidWeight      *float64 `json:"lipidWeight"`
	ProductionWeight *float64 `json:"productionWeight"`
	CuredWeight      *float64 `json:"curedWeight"`
	RecipeID         *string  `json:"recipeId"`
	CreatedAt        *int     `json:"createdAt"`
	UpdatedAt        *int     `json:"updatedAt"`
	DeletedAt        *int     `json:"deletedAt"`
}

type RecipeBatchWhere

type RecipeBatchWhere struct {
	ID                         *IDFilter                  `json:"id"`
	Tag                        *StringFilter              `json:"tag"`
	ProductionDate             *IntFilter                 `json:"productionDate"`
	SellableDate               *IntFilter                 `json:"sellableDate"`
	Note                       *StringFilter              `json:"note"`
	LipidWeight                *FloatFilter               `json:"lipidWeight"`
	ProductionWeight           *FloatFilter               `json:"productionWeight"`
	CuredWeight                *FloatFilter               `json:"curedWeight"`
	Recipe                     *RecipeWhere               `json:"recipe"`
	CreatedAt                  *IntFilter                 `json:"createdAt"`
	UpdatedAt                  *IntFilter                 `json:"updatedAt"`
	DeletedAt                  *IntFilter                 `json:"deletedAt"`
	BatchRecipeBatchAdditives  *RecipeBatchAdditiveWhere  `json:"batchRecipeBatchAdditives"`
	BatchRecipeBatchFragrances *RecipeBatchFragranceWhere `json:"batchRecipeBatchFragrances"`
	BatchRecipeBatchLipids     *RecipeBatchLipidWhere     `json:"batchRecipeBatchLipids"`
	BatchRecipeBatchLyes       *RecipeBatchLyeWhere       `json:"batchRecipeBatchLyes"`
	BatchRecipeBatchNotes      *RecipeBatchNoteWhere      `json:"batchRecipeBatchNotes"`
	Or                         *RecipeBatchWhere          `json:"or"`
	And                        *RecipeBatchWhere          `json:"and"`
}

type RecipeBatchesDeletePayload

type RecipeBatchesDeletePayload struct {
	Ids []string `json:"ids"`
}

type RecipeBatchesUpdatePayload

type RecipeBatchesUpdatePayload struct {
	Ok bool `json:"ok"`
}

type RecipeConnection

type RecipeConnection struct {
	Edges    []*RecipeEdge `json:"edges"`
	PageInfo *PageInfo     `json:"pageInfo"`
}

type RecipeCreateInput

type RecipeCreateInput struct {
	Name      string `json:"name"`
	Note      string `json:"note"`
	CreatedAt int    `json:"createdAt"`
	UpdatedAt int    `json:"updatedAt"`
	DeletedAt *int   `json:"deletedAt"`
}

type RecipeDeletePayload

type RecipeDeletePayload struct {
	ID string `json:"id"`
}

type RecipeEdge

type RecipeEdge struct {
	Cursor string  `json:"cursor"`
	Node   *Recipe `json:"node"`
}

type RecipeFilter

type RecipeFilter struct {
	Search *string      `json:"search"`
	Where  *RecipeWhere `json:"where"`
}

type RecipeFragrance

type RecipeFragrance struct {
	ID         string     `json:"id"`
	Percentage float64    `json:"percentage"`
	Fragrance  *Fragrance `json:"fragrance"`
	Recipe     *Recipe    `json:"recipe"`
	CreatedAt  int        `json:"createdAt"`
	UpdatedAt  int        `json:"updatedAt"`
	DeletedAt  *int       `json:"deletedAt"`
}

func (RecipeFragrance) IsNode

func (RecipeFragrance) IsNode()

type RecipeFragranceConnection

type RecipeFragranceConnection struct {
	Edges    []*RecipeFragranceEdge `json:"edges"`
	PageInfo *PageInfo              `json:"pageInfo"`
}

type RecipeFragranceCreateInput

type RecipeFragranceCreateInput struct {
	Percentage  float64 `json:"percentage"`
	FragranceID string  `json:"fragranceId"`
	RecipeID    string  `json:"recipeId"`
	CreatedAt   int     `json:"createdAt"`
	UpdatedAt   int     `json:"updatedAt"`
	DeletedAt   *int    `json:"deletedAt"`
}

type RecipeFragranceDeletePayload

type RecipeFragranceDeletePayload struct {
	ID string `json:"id"`
}

type RecipeFragranceEdge

type RecipeFragranceEdge struct {
	Cursor string           `json:"cursor"`
	Node   *RecipeFragrance `json:"node"`
}

type RecipeFragranceFilter

type RecipeFragranceFilter struct {
	Search *string               `json:"search"`
	Where  *RecipeFragranceWhere `json:"where"`
}

type RecipeFragranceOrdering

type RecipeFragranceOrdering struct {
	Sort      RecipeFragranceSort     `json:"sort"`
	Direction boilergql.SortDirection `json:"direction"`
}

type RecipeFragrancePayload

type RecipeFragrancePayload struct {
	RecipeFragrance *RecipeFragrance `json:"recipeFragrance"`
}

type RecipeFragranceSort

type RecipeFragranceSort string

const (
	RecipeFragranceSortID         RecipeFragranceSort = "ID"
	RecipeFragranceSortPercentage RecipeFragranceSort = "PERCENTAGE"
	RecipeFragranceSortCreatedAt  RecipeFragranceSort = "CREATED_AT"
	RecipeFragranceSortUpdatedAt  RecipeFragranceSort = "UPDATED_AT"
	RecipeFragranceSortDeletedAt  RecipeFragranceSort = "DELETED_AT"
)

func (RecipeFragranceSort) IsValid

func (e RecipeFragranceSort) IsValid() bool

func (RecipeFragranceSort) MarshalGQL

func (e RecipeFragranceSort) MarshalGQL(w io.Writer)

func (RecipeFragranceSort) String

func (e RecipeFragranceSort) String() string

func (*RecipeFragranceSort) UnmarshalGQL

func (e *RecipeFragranceSort) UnmarshalGQL(v interface{}) error

type RecipeFragranceUpdateInput

type RecipeFragranceUpdateInput struct {
	Percentage  *float64 `json:"percentage"`
	FragranceID *string  `json:"fragranceId"`
	RecipeID    *string  `json:"recipeId"`
	CreatedAt   *int     `json:"createdAt"`
	UpdatedAt   *int     `json:"updatedAt"`
	DeletedAt   *int     `json:"deletedAt"`
}

type RecipeFragranceWhere

type RecipeFragranceWhere struct {
	ID         *IDFilter             `json:"id"`
	Percentage *FloatFilter          `json:"percentage"`
	Fragrance  *FragranceWhere       `json:"fragrance"`
	Recipe     *RecipeWhere          `json:"recipe"`
	CreatedAt  *IntFilter            `json:"createdAt"`
	UpdatedAt  *IntFilter            `json:"updatedAt"`
	DeletedAt  *IntFilter            `json:"deletedAt"`
	Or         *RecipeFragranceWhere `json:"or"`
	And        *RecipeFragranceWhere `json:"and"`
}

type RecipeFragrancesDeletePayload

type RecipeFragrancesDeletePayload struct {
	Ids []string `json:"ids"`
}

type RecipeFragrancesUpdatePayload

type RecipeFragrancesUpdatePayload struct {
	Ok bool `json:"ok"`
}

type RecipeLipid

type RecipeLipid struct {
	ID         string  `json:"id"`
	Percentage float64 `json:"percentage"`
	Lipid      *Lipid  `json:"lipid"`
	Recipe     *Recipe `json:"recipe"`
	CreatedAt  int     `json:"createdAt"`
	UpdatedAt  int     `json:"updatedAt"`
	DeletedAt  *int    `json:"deletedAt"`
}

func (RecipeLipid) IsNode

func (RecipeLipid) IsNode()

type RecipeLipidConnection

type RecipeLipidConnection struct {
	Edges    []*RecipeLipidEdge `json:"edges"`
	PageInfo *PageInfo          `json:"pageInfo"`
}

type RecipeLipidCreateInput

type RecipeLipidCreateInput struct {
	Percentage float64 `json:"percentage"`
	LipidID    string  `json:"lipidId"`
	RecipeID   string  `json:"recipeId"`
	CreatedAt  int     `json:"createdAt"`
	UpdatedAt  int     `json:"updatedAt"`
	DeletedAt  *int    `json:"deletedAt"`
}

type RecipeLipidDeletePayload

type RecipeLipidDeletePayload struct {
	ID string `json:"id"`
}

type RecipeLipidEdge

type RecipeLipidEdge struct {
	Cursor string       `json:"cursor"`
	Node   *RecipeLipid `json:"node"`
}

type RecipeLipidFilter

type RecipeLipidFilter struct {
	Search *string           `json:"search"`
	Where  *RecipeLipidWhere `json:"where"`
}

type RecipeLipidOrdering

type RecipeLipidOrdering struct {
	Sort      RecipeLipidSort         `json:"sort"`
	Direction boilergql.SortDirection `json:"direction"`
}

type RecipeLipidPayload

type RecipeLipidPayload struct {
	RecipeLipid *RecipeLipid `json:"recipeLipid"`
}

type RecipeLipidSort

type RecipeLipidSort string

const (
	RecipeLipidSortID         RecipeLipidSort = "ID"
	RecipeLipidSortPercentage RecipeLipidSort = "PERCENTAGE"
	RecipeLipidSortCreatedAt  RecipeLipidSort = "CREATED_AT"
	RecipeLipidSortUpdatedAt  RecipeLipidSort = "UPDATED_AT"
	RecipeLipidSortDeletedAt  RecipeLipidSort = "DELETED_AT"
)

func (RecipeLipidSort) IsValid

func (e RecipeLipidSort) IsValid() bool

func (RecipeLipidSort) MarshalGQL

func (e RecipeLipidSort) MarshalGQL(w io.Writer)

func (RecipeLipidSort) String

func (e RecipeLipidSort) String() string

func (*RecipeLipidSort) UnmarshalGQL

func (e *RecipeLipidSort) UnmarshalGQL(v interface{}) error

type RecipeLipidUpdateInput

type RecipeLipidUpdateInput struct {
	Percentage *float64 `json:"percentage"`
	LipidID    *string  `json:"lipidId"`
	RecipeID   *string  `json:"recipeId"`
	CreatedAt  *int     `json:"createdAt"`
	UpdatedAt  *int     `json:"updatedAt"`
	DeletedAt  *int     `json:"deletedAt"`
}

type RecipeLipidWhere

type RecipeLipidWhere struct {
	ID         *IDFilter         `json:"id"`
	Percentage *FloatFilter      `json:"percentage"`
	Lipid      *LipidWhere       `json:"lipid"`
	Recipe     *RecipeWhere      `json:"recipe"`
	CreatedAt  *IntFilter        `json:"createdAt"`
	UpdatedAt  *IntFilter        `json:"updatedAt"`
	DeletedAt  *IntFilter        `json:"deletedAt"`
	Or         *RecipeLipidWhere `json:"or"`
	And        *RecipeLipidWhere `json:"and"`
}

type RecipeLipidsDeletePayload

type RecipeLipidsDeletePayload struct {
	Ids []string `json:"ids"`
}

type RecipeLipidsUpdatePayload

type RecipeLipidsUpdatePayload struct {
	Ok bool `json:"ok"`
}

type RecipeOrdering

type RecipeOrdering struct {
	Sort      RecipeSort              `json:"sort"`
	Direction boilergql.SortDirection `json:"direction"`
}

type RecipePayload

type RecipePayload struct {
	Recipe *Recipe `json:"recipe"`
}

type RecipeSort

type RecipeSort string

const (
	RecipeSortID        RecipeSort = "ID"
	RecipeSortName      RecipeSort = "NAME"
	RecipeSortNote      RecipeSort = "NOTE"
	RecipeSortCreatedAt RecipeSort = "CREATED_AT"
	RecipeSortUpdatedAt RecipeSort = "UPDATED_AT"
	RecipeSortDeletedAt RecipeSort = "DELETED_AT"
)

func (RecipeSort) IsValid

func (e RecipeSort) IsValid() bool

func (RecipeSort) MarshalGQL

func (e RecipeSort) MarshalGQL(w io.Writer)

func (RecipeSort) String

func (e RecipeSort) String() string

func (*RecipeSort) UnmarshalGQL

func (e *RecipeSort) UnmarshalGQL(v interface{}) error

type RecipeStep

type RecipeStep struct {
	ID        string  `json:"id"`
	Num       int     `json:"num"`
	Note      string  `json:"note"`
	Recipe    *Recipe `json:"recipe"`
	CreatedAt int     `json:"createdAt"`
	UpdatedAt int     `json:"updatedAt"`
	DeletedAt *int    `json:"deletedAt"`
}

func (RecipeStep) IsNode

func (RecipeStep) IsNode()

type RecipeStepConnection

type RecipeStepConnection struct {
	Edges    []*RecipeStepEdge `json:"edges"`
	PageInfo *PageInfo         `json:"pageInfo"`
}

type RecipeStepCreateInput

type RecipeStepCreateInput struct {
	Num       int    `json:"num"`
	Note      string `json:"note"`
	RecipeID  string `json:"recipeId"`
	CreatedAt int    `json:"createdAt"`
	UpdatedAt int    `json:"updatedAt"`
	DeletedAt *int   `json:"deletedAt"`
}

type RecipeStepDeletePayload

type RecipeStepDeletePayload struct {
	ID string `json:"id"`
}

type RecipeStepEdge

type RecipeStepEdge struct {
	Cursor string      `json:"cursor"`
	Node   *RecipeStep `json:"node"`
}

type RecipeStepFilter

type RecipeStepFilter struct {
	Search *string          `json:"search"`
	Where  *RecipeStepWhere `json:"where"`
}

type RecipeStepOrdering

type RecipeStepOrdering struct {
	Sort      RecipeStepSort          `json:"sort"`
	Direction boilergql.SortDirection `json:"direction"`
}

type RecipeStepPayload

type RecipeStepPayload struct {
	RecipeStep *RecipeStep `json:"recipeStep"`
}

type RecipeStepSort

type RecipeStepSort string

const (
	RecipeStepSortID        RecipeStepSort = "ID"
	RecipeStepSortNum       RecipeStepSort = "NUM"
	RecipeStepSortNote      RecipeStepSort = "NOTE"
	RecipeStepSortCreatedAt RecipeStepSort = "CREATED_AT"
	RecipeStepSortUpdatedAt RecipeStepSort = "UPDATED_AT"
	RecipeStepSortDeletedAt RecipeStepSort = "DELETED_AT"
)

func (RecipeStepSort) IsValid

func (e RecipeStepSort) IsValid() bool

func (RecipeStepSort) MarshalGQL

func (e RecipeStepSort) MarshalGQL(w io.Writer)

func (RecipeStepSort) String

func (e RecipeStepSort) String() string

func (*RecipeStepSort) UnmarshalGQL

func (e *RecipeStepSort) UnmarshalGQL(v interface{}) error

type RecipeStepUpdateInput

type RecipeStepUpdateInput struct {
	Num       *int    `json:"num"`
	Note      *string `json:"note"`
	RecipeID  *string `json:"recipeId"`
	CreatedAt *int    `json:"createdAt"`
	UpdatedAt *int    `json:"updatedAt"`
	DeletedAt *int    `json:"deletedAt"`
}

type RecipeStepWhere

type RecipeStepWhere struct {
	ID        *IDFilter        `json:"id"`
	Num       *IntFilter       `json:"num"`
	Note      *StringFilter    `json:"note"`
	Recipe    *RecipeWhere     `json:"recipe"`
	CreatedAt *IntFilter       `json:"createdAt"`
	UpdatedAt *IntFilter       `json:"updatedAt"`
	DeletedAt *IntFilter       `json:"deletedAt"`
	Or        *RecipeStepWhere `json:"or"`
	And       *RecipeStepWhere `json:"and"`
}

type RecipeStepsDeletePayload

type RecipeStepsDeletePayload struct {
	Ids []string `json:"ids"`
}

type RecipeStepsUpdatePayload

type RecipeStepsUpdatePayload struct {
	Ok bool `json:"ok"`
}

type RecipeUpdateInput

type RecipeUpdateInput struct {
	Name      *string `json:"name"`
	Note      *string `json:"note"`
	CreatedAt *int    `json:"createdAt"`
	UpdatedAt *int    `json:"updatedAt"`
	DeletedAt *int    `json:"deletedAt"`
}

type RecipeWhere

type RecipeWhere struct {
	ID               *IDFilter             `json:"id"`
	Name             *StringFilter         `json:"name"`
	Note             *StringFilter         `json:"note"`
	CreatedAt        *IntFilter            `json:"createdAt"`
	UpdatedAt        *IntFilter            `json:"updatedAt"`
	DeletedAt        *IntFilter            `json:"deletedAt"`
	RecipeAdditives  *RecipeAdditiveWhere  `json:"recipeAdditives"`
	RecipeBatches    *RecipeBatchWhere     `json:"recipeBatches"`
	RecipeFragrances *RecipeFragranceWhere `json:"recipeFragrances"`
	RecipeLipids     *RecipeLipidWhere     `json:"recipeLipids"`
	RecipeSteps      *RecipeStepWhere      `json:"recipeSteps"`
	Or               *RecipeWhere          `json:"or"`
	And              *RecipeWhere          `json:"and"`
}

type RecipesDeletePayload

type RecipesDeletePayload struct {
	Ids []string `json:"ids"`
}

type RecipesUpdatePayload

type RecipesUpdatePayload struct {
	Ok bool `json:"ok"`
}

type ResolverRoot

type ResolverRoot interface {
	Mutation() MutationResolver
	Query() QueryResolver
}

type StringFilter

type StringFilter struct {
	EqualTo            *string  `json:"equalTo"`
	NotEqualTo         *string  `json:"notEqualTo"`
	In                 []string `json:"in"`
	NotIn              []string `json:"notIn"`
	StartWith          *string  `json:"startWith"`
	NotStartWith       *string  `json:"notStartWith"`
	EndWith            *string  `json:"endWith"`
	NotEndWith         *string  `json:"notEndWith"`
	Contain            *string  `json:"contain"`
	NotContain         *string  `json:"notContain"`
	StartWithStrict    *string  `json:"startWithStrict"`
	NotStartWithStrict *string  `json:"notStartWithStrict"`
	EndWithStrict      *string  `json:"endWithStrict"`
	NotEndWithStrict   *string  `json:"notEndWithStrict"`
	ContainStrict      *string  `json:"containStrict"`
	NotContainStrict   *string  `json:"notContainStrict"`
}

type Supplier

type Supplier struct {
	ID                   string                `json:"id"`
	Name                 string                `json:"name"`
	Website              string                `json:"website"`
	Note                 string                `json:"note"`
	CreatedAt            int                   `json:"createdAt"`
	UpdatedAt            int                   `json:"updatedAt"`
	DeletedAt            *int                  `json:"deletedAt"`
	AdditiveInventories  []*AdditiveInventory  `json:"additiveInventories"`
	FragranceInventories []*FragranceInventory `json:"fragranceInventories"`
	LipidInventories     []*LipidInventory     `json:"lipidInventories"`
	LyeInventories       []*LyeInventory       `json:"lyeInventories"`
}

func (Supplier) IsNode

func (Supplier) IsNode()

type SupplierConnection

type SupplierConnection struct {
	Edges    []*SupplierEdge `json:"edges"`
	PageInfo *PageInfo       `json:"pageInfo"`
}

type SupplierCreateInput

type SupplierCreateInput struct {
	Name      string `json:"name"`
	Website   string `json:"website"`
	Note      string `json:"note"`
	CreatedAt int    `json:"createdAt"`
	UpdatedAt int    `json:"updatedAt"`
	DeletedAt *int   `json:"deletedAt"`
}

type SupplierDeletePayload

type SupplierDeletePayload struct {
	ID string `json:"id"`
}

type SupplierEdge

type SupplierEdge struct {
	Cursor string    `json:"cursor"`
	Node   *Supplier `json:"node"`
}

type SupplierFilter

type SupplierFilter struct {
	Search *string        `json:"search"`
	Where  *SupplierWhere `json:"where"`
}

type SupplierOrdering

type SupplierOrdering struct {
	Sort      SupplierSort            `json:"sort"`
	Direction boilergql.SortDirection `json:"direction"`
}

type SupplierPayload

type SupplierPayload struct {
	Supplier *Supplier `json:"supplier"`
}

type SupplierSort

type SupplierSort string

const (
	SupplierSortID        SupplierSort = "ID"
	SupplierSortName      SupplierSort = "NAME"
	SupplierSortWebsite   SupplierSort = "WEBSITE"
	SupplierSortNote      SupplierSort = "NOTE"
	SupplierSortCreatedAt SupplierSort = "CREATED_AT"
	SupplierSortUpdatedAt SupplierSort = "UPDATED_AT"
	SupplierSortDeletedAt SupplierSort = "DELETED_AT"
)

func (SupplierSort) IsValid

func (e SupplierSort) IsValid() bool

func (SupplierSort) MarshalGQL

func (e SupplierSort) MarshalGQL(w io.Writer)

func (SupplierSort) String

func (e SupplierSort) String() string

func (*SupplierSort) UnmarshalGQL

func (e *SupplierSort) UnmarshalGQL(v interface{}) error

type SupplierUpdateInput

type SupplierUpdateInput struct {
	Name      *string `json:"name"`
	Website   *string `json:"website"`
	Note      *string `json:"note"`
	CreatedAt *int    `json:"createdAt"`
	UpdatedAt *int    `json:"updatedAt"`
	DeletedAt *int    `json:"deletedAt"`
}

type SupplierWhere

type SupplierWhere struct {
	ID                   *IDFilter                `json:"id"`
	Name                 *StringFilter            `json:"name"`
	Website              *StringFilter            `json:"website"`
	Note                 *StringFilter            `json:"note"`
	CreatedAt            *IntFilter               `json:"createdAt"`
	UpdatedAt            *IntFilter               `json:"updatedAt"`
	DeletedAt            *IntFilter               `json:"deletedAt"`
	AdditiveInventories  *AdditiveInventoryWhere  `json:"additiveInventories"`
	FragranceInventories *FragranceInventoryWhere `json:"fragranceInventories"`
	LipidInventories     *LipidInventoryWhere     `json:"lipidInventories"`
	LyeInventories       *LyeInventoryWhere       `json:"lyeInventories"`
	Or                   *SupplierWhere           `json:"or"`
	And                  *SupplierWhere           `json:"and"`
}

type SuppliersDeletePayload

type SuppliersDeletePayload struct {
	Ids []string `json:"ids"`
}

type SuppliersUpdatePayload

type SuppliersUpdatePayload struct {
	Ok bool `json:"ok"`
}