billing

type Adapter interface {
	ProfileAdapter
	CustomerOverrideAdapter
	InvoiceLineAdapter
	InvoiceSplitLineGroupAdapter
	InvoiceAdapter
	GatheringInvoiceAdapter
	SequenceAdapter
	InvoiceAppAdapter
	CustomerSynchronizationAdapter
	SchemaLevelAdapter

	entutils.TxCreator
}

type AdapterGetProfileResponse struct {
	BaseProfile

	WorkflowConfigID string `json:"workflowConfigId"`
}

type AdvanceInvoiceInput = InvoiceID

type AdvanceStandardInvoiceEvent struct {
	Invoice    InvoiceID `json:"invoice"`
	CustomerID string    `json:"customer_id"`
}

type AdvancementStrategy string

type AlignmentKind string

type AmountLineDiscount struct {
	LineDiscountBase `json:",inline"`

	Amount alpacadecimal.Decimal `json:"amount"`

	// RoundingAmount is a correction value, to ensure that if multiple discounts are applied,
	// then sum of discount amounts equals the total * sum(discount percentages).
	RoundingAmount alpacadecimal.Decimal `json:"roundingAmount"`
}

type AmountLineDiscountManaged struct {
	models.ManagedModelWithID `json:",inline"`
	AmountLineDiscount        `json:",inline"`
}

type AmountLineDiscountsManaged []AmountLineDiscountManaged

type AnchoredAlignmentDetail struct {
	Interval datetime.ISODuration `json:"interval"`
	Anchor   time.Time            `json:"anchor"`
}

type AppError struct {
	AppID   app.AppID
	AppType app.AppType
	Err     error
}

type ApproveInvoiceInput = InvoiceID

type AssociatedLineCountsAdapterInput = genericMultiInvoiceInput

type AssociatedLineCountsAdapterResponse struct {
	Counts map[InvoiceID]int64
}

type BaseProfile struct {
	ID        string `json:"id"`
	Namespace string `json:"namespace"`

	Name        string  `json:"name"`
	Description *string `json:"description,omitempty"`

	CreatedAt time.Time  `json:"createdAt"`
	UpdatedAt time.Time  `json:"updatedAt"`
	DeletedAt *time.Time `json:"deletedAt,omitempty"`

	WorkflowConfig WorkflowConfig `json:"workflow"`

	Supplier SupplierContact `json:"supplier"`

	Default  bool     `json:"default"`
	Metadata Metadata `json:"metadata"`

	AppReferences *ProfileAppReferences `json:"appReferences,omitempty"`
}

type BulkAssignCustomersToProfileInput struct {
	ProfileID   ProfileID
	CustomerIDs []customer.CustomerID
}

type CollectionConfig struct {
	Alignment               AlignmentKind            `json:"alignment"`
	AnchoredAlignmentDetail *AnchoredAlignmentDetail `json:"anchoredAlignmentDetail,omitempty"`
	Interval                datetime.ISODuration     `json:"period,omitempty"`
}

type CollectionMethod string

type CollectionOverrideConfig struct {
	Alignment               *AlignmentKind           `json:"alignment,omitempty"`
	AnchoredAlignmentDetail *AnchoredAlignmentDetail `json:"anchoredAlignmentDetail,omitempty"`
	Interval                *datetime.ISODuration    `json:"interval,omitempty"`
}

type ComponentName string

type ConfigService interface {
	GetAdvancementStrategy() AdvancementStrategy
	WithAdvancementStrategy(strategy AdvancementStrategy) Service
	WithLockedNamespaces(namespaces []string) Service
}

type CreateCustomerOverrideAdapterInput = UpdateCustomerOverrideAdapterInput

type CreateGatheringInvoiceAdapterInput struct {
	Namespace string
	Number    string
	Currency  currencyx.Code
	Metadata  map[string]string

	Description      *string
	NextCollectionAt *time.Time

	// TODO[later]: This should be just a CustomerID once we have split the invoices table
	Customer      customer.Customer
	MergedProfile Profile
}

type CreateInvoiceAdapterInput struct {
	Namespace string
	Customer  customer.Customer
	Profile   Profile
	Number    string
	Currency  currencyx.Code
	Status    StandardInvoiceStatus
	Metadata  map[string]string
	IssuedAt  time.Time

	Type         InvoiceType
	Description  *string
	DueAt        *time.Time
	CollectionAt *time.Time

	Totals Totals
}

type CreateInvoiceAdapterRespone = StandardInvoice

type CreatePendingInvoiceLinesInput struct {
	Customer customer.CustomerID `json:"customer"`
	Currency currencyx.Code      `json:"currency"`

	Lines []GatheringLine `json:"lines"`
}

type CreatePendingInvoiceLinesResult struct {
	Lines        []GatheringLine
	Invoice      GatheringInvoice
	IsInvoiceNew bool
}

type CreateProfileAppsInput = ProfileAppReferences

type CreateProfileInput struct {
	Namespace   string            `json:"namespace"`
	Name        string            `json:"name"`
	Description *string           `json:"description,omitempty"`
	Metadata    map[string]string `json:"metadata"`
	Supplier    SupplierContact   `json:"supplier"`
	Default     bool              `json:"default"`

	WorkflowConfig WorkflowConfig         `json:"workflowConfig"`
	Apps           CreateProfileAppsInput `json:"apps"`
}

type CreateSplitLineGroupAdapterInput = SplitLineGroupCreate

type CreateWorkflowConfigInput struct {
	WorkflowConfig
}

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

type CustomerOverride struct {
	Namespace string `json:"namespace"`
	ID        string `json:"id"`

	CreatedAt time.Time  `json:"createdAt"`
	UpdatedAt time.Time  `json:"updatedAt"`
	DeletedAt *time.Time `json:"deletedAt,omitempty"`

	CustomerID string   `json:"customerID"`
	Profile    *Profile `json:"billingProfile,omitempty"`

	Collection CollectionOverrideConfig `json:"collection"`
	Invoicing  InvoicingOverrideConfig  `json:"invoicing"`
	Payment    PaymentOverrideConfig    `json:"payment"`
}

type CustomerOverrideAdapter interface {
	CreateCustomerOverride(ctx context.Context, input UpdateCustomerOverrideAdapterInput) (*CustomerOverride, error)
	GetCustomerOverride(ctx context.Context, input GetCustomerOverrideAdapterInput) (*CustomerOverride, error)
	UpdateCustomerOverride(ctx context.Context, input UpdateCustomerOverrideAdapterInput) (*CustomerOverride, error)
	DeleteCustomerOverride(ctx context.Context, input DeleteCustomerOverrideInput) error
	ListCustomerOverrides(ctx context.Context, input ListCustomerOverridesInput) (ListCustomerOverridesAdapterResult, error)

	BulkAssignCustomersToProfile(ctx context.Context, input BulkAssignCustomersToProfileInput) error

	GetCustomerOverrideReferencingProfile(ctx context.Context, input HasCustomerOverrideReferencingProfileAdapterInput) ([]customer.CustomerID, error)
}

type CustomerOverrideExpand struct {
	// Apps specifies if the merged profile should include the apps
	Apps bool `json:"apps,omitempty"`

	// Customer specifies if the customer should be included in the response
	Customer bool `json:"customer,omitempty"`
}

type CustomerOverrideOrderBy string

type CustomerOverrideService interface {
	UpsertCustomerOverride(ctx context.Context, input UpsertCustomerOverrideInput) (CustomerOverrideWithDetails, error)
	DeleteCustomerOverride(ctx context.Context, input DeleteCustomerOverrideInput) error

	GetCustomerOverride(ctx context.Context, input GetCustomerOverrideInput) (CustomerOverrideWithDetails, error)
	GetCustomerApp(ctx context.Context, input GetCustomerAppInput) (app.App, error)
	ListCustomerOverrides(ctx context.Context, input ListCustomerOverridesInput) (ListCustomerOverridesResult, error)
}

type CustomerOverrideWithAdapterProfile struct {
	CustomerOverride `json:",inline"`

	DefaultProfile *AdapterGetProfileResponse `json:"billingProfile,omitempty"`
}

type CustomerOverrideWithCustomerID struct {
	*CustomerOverride `json:",inline"`

	CustomerID customer.CustomerID `json:"customerID,omitempty"`
}

type CustomerOverrideWithDetails struct {
	CustomerOverride *CustomerOverride `json:",inline"`
	MergedProfile    Profile           `json:"mergedProfile,omitempty"`

	// Expanded fields
	Expand   CustomerOverrideExpand `json:"expand,omitempty"`
	Customer *customer.Customer     `json:"customer,omitempty"`
}

type CustomerSynchronizationAdapter interface {
	// UpsertCustomerOverride upserts a customer override ignoring the transactional context, the override
	// will be empty.
	UpsertCustomerLock(ctx context.Context, input UpsertCustomerLockAdapterInput) error
	LockCustomerForUpdate(ctx context.Context, input LockCustomerForUpdateAdapterInput) error
}

type DeleteCustomerOverrideInput struct {
	Customer customer.CustomerID
}

type DeleteGatheringInvoiceAdapterInput = InvoiceID

type DeleteGatheringInvoicesInput = genericMultiInvoiceInput

type DeleteInvoiceInput = InvoiceID

type DeleteInvoiceLineInput = LineID

type DeleteProfileInput = ProfileID

type DeleteSplitLineGroupInput = models.NamespacedID

type DetailedLine struct {
	DetailedLineBase

	// Discounts
	AmountDiscounts AmountLineDiscountsManaged `json:"discounts,omitempty"`
}

type DetailedLineBase struct {
	models.ManagedResource

	// Relationships
	InvoiceID string `json:"invoiceID"`

	// Line details
	Category               FlatFeeCategory                `json:"category"`
	ChildUniqueReferenceID *string                        `json:"childUniqueReferenceID,omitempty"`
	Index                  *int                           `json:"index,omitempty"`
	PaymentTerm            productcatalog.PaymentTermType `json:"paymentTerm"`
	ServicePeriod          Period                         `json:"servicePeriod"`

	// Line amount
	Currency      currencyx.Code        `json:"currency"`
	PerUnitAmount alpacadecimal.Decimal `json:"perUnitAmount"`
	Quantity      alpacadecimal.Decimal `json:"quantity"`
	Totals        Totals                `json:"totals"`

	// Apps
	TaxConfig   *productcatalog.TaxConfig `json:"taxConfig,omitempty"`
	ExternalIDs LineExternalIDs           `json:"externalIDs,omitempty"`

	// FeeLineConfigID contains the ID of the fee configuration in the DB, this should go away
	// as soon as we split the ubp/flatfee db parts
	FeeLineConfigID string `json:"feeLineConfigID,omitempty"`
}

type DetailedLines []DetailedLine

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

type DiscountReasonType string

type Discounts struct {
	Percentage *PercentageDiscount `json:"percentage,omitempty"`
	Usage      *UsageDiscount      `json:"usage,omitempty"`
}

type ErrSnapshotInvalidDatabaseState struct {
	Err error
}

type EventStandardInvoice struct {
	Invoice StandardInvoice `json:"invoice"`
	Apps    InvoiceApps     `json:"apps,omitempty"`
}

type ExternalIDType string

type FeatureMeter struct {
	Feature feature.Feature
	Meter   *meter.Meter
}

type FeatureMeters map[string]FeatureMeter

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

type FlatFeeCategory string

type ForEachChildInput struct {
	PeriodEndLTE time.Time
	Callback     func(child LineWithInvoiceHeader) error
}

type GatheringInvoice struct {
	GatheringInvoiceBase `json:",inline"`

	// Entities external to the invoice entity
	Lines GatheringInvoiceLines `json:"lines,omitempty"`

	// TODO[later]: implement this once we have a lineservice capable of operating on
	// these lines too.
	AvailableActions *GatheringInvoiceAvailableActions `json:"availableActions,omitempty"`
}

type GatheringInvoiceAdapter interface {
	CreateGatheringInvoice(ctx context.Context, input CreateGatheringInvoiceAdapterInput) (GatheringInvoice, error)
	UpdateGatheringInvoice(ctx context.Context, input UpdateGatheringInvoiceAdapterInput) error
	DeleteGatheringInvoice(ctx context.Context, input DeleteGatheringInvoiceAdapterInput) error
	GetGatheringInvoiceById(ctx context.Context, input GetGatheringInvoiceByIdInput) (GatheringInvoice, error)
	ListGatheringInvoices(ctx context.Context, input ListGatheringInvoicesInput) (pagination.Result[GatheringInvoice], error)

	HardDeleteGatheringInvoiceLines(ctx context.Context, invoiceID InvoiceID, lineIDs []string) error
}

type GatheringInvoiceAvailableActions struct {
	CanBeInvoiced bool `json:"canBeInvoiced"`
}

type GatheringInvoiceBase struct {
	models.ManagedResource

	Metadata models.Metadata `json:"metadata"`

	Number        string                `json:"number"`
	CustomerID    string                `json:"customerID"`
	Currency      currencyx.Code        `json:"currency"`
	ServicePeriod timeutil.ClosedPeriod `json:"servicePeriod"`

	NextCollectionAt time.Time `json:"nextCollectionAt"`

	SchemaLevel int `json:"schemaLevel"`
}

type GatheringInvoiceCreatedEvent struct {
	Invoice GatheringInvoice `json:"gatheringInvoice"`
}

type GatheringInvoiceExpand string

type GatheringInvoiceExpands []GatheringInvoiceExpand

type GatheringInvoiceLines struct {
	mo.Option[GatheringLines]
}

type GatheringInvoiceService interface {
	// CreatePendingInvoiceLines creates pending invoice lines for a customer, if the lines are zero valued, the response is nil
	CreatePendingInvoiceLines(ctx context.Context, input CreatePendingInvoiceLinesInput) (*CreatePendingInvoiceLinesResult, error)

	ListGatheringInvoices(ctx context.Context, input ListGatheringInvoicesInput) (pagination.Result[GatheringInvoice], error)
	GetGatheringInvoiceById(ctx context.Context, input GetGatheringInvoiceByIdInput) (GatheringInvoice, error)
	UpdateGatheringInvoice(ctx context.Context, input UpdateGatheringInvoiceInput) error
}

type GatheringLine struct {
	GatheringLineBase `json:",inline"`

	DBState *GatheringLine `json:"-"`
}

type GatheringLineBase struct {
	models.ManagedResource

	Metadata    models.Metadata      `json:"metadata"`
	Annotations models.Annotations   `json:"annotations"`
	ManagedBy   InvoiceLineManagedBy `json:"managedBy"`
	InvoiceID   string               `json:"invoiceID"`

	Currency      currencyx.Code        `json:"currency"`
	ServicePeriod timeutil.ClosedPeriod `json:"period"`
	InvoiceAt     time.Time             `json:"invoiceAt"`
	Price         productcatalog.Price  `json:"price"`
	FeatureKey    string                `json:"featureKey"`

	TaxConfig         *productcatalog.TaxConfig `json:"taxOverrides,omitempty"`
	RateCardDiscounts Discounts                 `json:"rateCardDiscounts,omitempty"`

	ChildUniqueReferenceID *string                `json:"childUniqueReferenceID,omitempty"`
	Subscription           *SubscriptionReference `json:"subscription,omitempty"`
	SplitLineGroupID       *string                `json:"splitLineGroupID,omitempty"`

	// TODO: Remove once we have dedicated db field for gathering invoice lines
	UBPConfigID string `json:"ubpConfigID"`
}

type GatheringLineWithInvoiceHeader struct {
	Line    GatheringLine
	Invoice GatheringInvoice
}

type GatheringLines []GatheringLine

type GenericInvoice interface {
	GenericInvoiceReader

	SetLines(lines []GenericInvoiceLine) error
}

type GenericInvoiceLine interface {
	GenericInvoiceLineReader

	Clone() (GenericInvoiceLine, error)
	CloneWithoutChildren() (GenericInvoiceLine, error)

	SetDeletedAt(at *time.Time)
	SetPrice(price productcatalog.Price)
	UpdateServicePeriod(func(p *timeutil.ClosedPeriod))
	SetChildUniqueReferenceID(id *string)
}

type GenericInvoiceLineReader interface {
	GetDeletedAt() *time.Time
	GetID() string
	GetLineID() LineID
	GetManagedBy() InvoiceLineManagedBy
	GetAnnotations() models.Annotations
	GetInvoiceID() string
	GetPrice() *productcatalog.Price
	GetServicePeriod() timeutil.ClosedPeriod
	GetChildUniqueReferenceID() *string
	GetFeatureKey() string

	Validate() error
	AsInvoiceLine() InvoiceLine
	GetRateCardDiscounts() Discounts
	GetSubscriptionReference() *SubscriptionReference
	GetSplitLineGroupID() *string
}

type GenericInvoiceReader interface {
	GetDeletedAt() *time.Time
	GetID() string
	GetInvoiceID() InvoiceID
	GetCustomerID() customer.CustomerID

	// GetGenericLines returns the lines of the invoice as generic lines.
	GetGenericLines() mo.Option[[]GenericInvoiceLine]

	AsInvoice() Invoice
}

type GetCustomerAppInput struct {
	CustomerID customer.CustomerID
	AppType    app.AppType
}

type GetCustomerOverrideAdapterInput struct {
	Customer customer.CustomerID

	IncludeDeleted bool
}

type GetCustomerOverrideInput struct {
	Customer customer.CustomerID    `json:"customerID"`
	Expand   CustomerOverrideExpand `json:"expand,omitempty"`
}

type GetDefaultProfileInput struct {
	Namespace string
}

type GetGatheringInvoiceByIdInput struct {
	Invoice InvoiceID
	Expand  GatheringInvoiceExpands
}

type GetInvoiceByIdInput struct {
	Invoice InvoiceID
	Expand  InvoiceExpand
}

type GetInvoiceLineAdapterInput = LineID

type GetInvoiceLineInput = LineID

type GetInvoiceLineOwnershipAdapterInput = LineID

type GetInvoiceOwnershipAdapterInput = InvoiceID

type GetInvoiceTypeAdapterInput = InvoiceID

type GetLinesForSubscriptionInput struct {
	Namespace      string
	SubscriptionID string
	CustomerID     string
}

type GetOwnershipAdapterResponse struct {
	Namespace  string
	InvoiceID  string
	CustomerID string
}

type GetProfileInput struct {
	Profile ProfileID
	Expand  ProfileExpand
}

type GetProfileWithCustomerOverrideInput struct {
	Customer customer.CustomerID
}

type GetSplitLineGroupHeadersInput struct {
	Namespace         string
	SplitLineGroupIDs []string
}

type GetSplitLineGroupInput = models.NamespacedID

type GetUnpinnedCustomerIDsWithPaidSubscriptionInput struct {
	Namespace string
}

type GranularityResolution string

type HasCustomerOverrideReferencingProfileAdapterInput = ProfileID

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

type InvoiceAdapter interface {
	CreateInvoice(ctx context.Context, input CreateInvoiceAdapterInput) (CreateInvoiceAdapterRespone, error)
	GetInvoiceById(ctx context.Context, input GetInvoiceByIdInput) (StandardInvoice, error)
	DeleteGatheringInvoices(ctx context.Context, input DeleteGatheringInvoicesInput) error
	ListInvoices(ctx context.Context, input ListInvoicesInput) (ListInvoicesResponse, error)
	AssociatedLineCounts(ctx context.Context, input AssociatedLineCountsAdapterInput) (AssociatedLineCountsAdapterResponse, error)
	UpdateInvoice(ctx context.Context, input UpdateInvoiceAdapterInput) (StandardInvoice, error)

	GetInvoiceOwnership(ctx context.Context, input GetInvoiceOwnershipAdapterInput) (GetOwnershipAdapterResponse, error)

	GetInvoiceType(ctx context.Context, input GetInvoiceTypeAdapterInput) (InvoiceType, error)
}

type InvoiceAppAdapter interface {
	UpdateInvoiceFields(ctx context.Context, input UpdateInvoiceFieldsInput) error
}

type InvoiceAppService interface {
	// TriggerInvoice triggers the invoice state machine to start processing the invoice
	TriggerInvoice(ctx context.Context, input InvoiceTriggerServiceInput) error

	// UpdateInvoiceFields updates the fields of an invoice which are not managed by the state machine
	// These are usually metadata fields settable after the invoice has been finalized
	UpdateInvoiceFields(ctx context.Context, input UpdateInvoiceFieldsInput) error

	// Async sync support
	SyncDraftInvoice(ctx context.Context, input SyncDraftStandardInvoiceInput) (StandardInvoice, error)
	SyncIssuingInvoice(ctx context.Context, input SyncIssuingStandardInvoiceInput) (StandardInvoice, error)
}

type InvoiceApps struct {
	Tax       app.EventApp `json:"tax"`
	Payment   app.EventApp `json:"payment"`
	Invoicing app.EventApp `json:"invoicing"`
}

type InvoiceAtAccessor interface {
	GetInvoiceAt() time.Time
	SetInvoiceAt(at time.Time)
}

type InvoiceAvailableActionsFilter string

type InvoiceCustomer struct {
	Key              *string                             `json:"key,omitempty"`
	CustomerID       string                              `json:"customerId,omitempty"`
	Name             string                              `json:"name"`
	BillingAddress   *models.Address                     `json:"billingAddress,omitempty"`
	UsageAttribution *streaming.CustomerUsageAttribution `json:"usageAttribution,omitempty"`
}

type InvoiceExpand struct {
	Preceding bool

	Lines        bool
	DeletedLines bool

	// RecalculateGatheringInvoice is used to calculate the totals and status details of the invoice when gathering,
	// this is temporary until we implement the full progressive billing stack, including gathering invoice recalculations.
	RecalculateGatheringInvoice bool
}

type InvoiceExternalIDs struct {
	Invoicing string `json:"invoicing,omitempty"`
	Payment   string `json:"payment,omitempty"`
}

type InvoiceID models.NamespacedID

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

type InvoiceLineAdapter interface {
	UpsertInvoiceLines(ctx context.Context, input UpsertInvoiceLinesAdapterInput) ([]*StandardLine, error)
	ListInvoiceLines(ctx context.Context, input ListInvoiceLinesAdapterInput) ([]*StandardLine, error)
	GetLinesForSubscription(ctx context.Context, input GetLinesForSubscriptionInput) ([]LineOrHierarchy, error)
}

type InvoiceLineAdapterType string

type InvoiceLineManagedBy string

type InvoiceLineService interface {
	GetLinesForSubscription(ctx context.Context, input GetLinesForSubscriptionInput) ([]LineOrHierarchy, error)
	// SnapshotLineQuantity returns an updated line with the quantity snapshoted from meters
	// the invoice is used as contextual information to the call.
	SnapshotLineQuantity(ctx context.Context, input SnapshotLineQuantityInput) (*StandardLine, error)
}

type InvoiceLineStatus string

type InvoiceLineType string

type InvoicePendingLinesInput struct {
	Customer customer.CustomerID

	IncludePendingLines mo.Option[[]string]
	AsOf                *time.Time

	// ProgressiveBillingOverride allows to override the progressive billing setting of the customer.
	// This is used to make sure that system collection does not use progressive billing.
	ProgressiveBillingOverride *bool
}

type InvoiceService interface {
	ListInvoices(ctx context.Context, input ListInvoicesInput) (ListInvoicesResponse, error)
	GetInvoiceByID(ctx context.Context, input GetInvoiceByIdInput) (StandardInvoice, error)
	InvoicePendingLines(ctx context.Context, input InvoicePendingLinesInput) ([]StandardInvoice, error)
	// AdvanceInvoice advances the invoice to the next stage, the advancement is stopped until:
	// - an error is occurred
	// - the invoice is in a state that cannot be advanced (e.g. waiting for draft period to expire)
	// - the invoice is advanced to the final state
	AdvanceInvoice(ctx context.Context, input AdvanceInvoiceInput) (StandardInvoice, error)
	SnapshotQuantities(ctx context.Context, input SnapshotQuantitiesInput) (StandardInvoice, error)
	ApproveInvoice(ctx context.Context, input ApproveInvoiceInput) (StandardInvoice, error)
	RetryInvoice(ctx context.Context, input RetryInvoiceInput) (StandardInvoice, error)
	DeleteInvoice(ctx context.Context, input DeleteInvoiceInput) (StandardInvoice, error)
	UpdateInvoice(ctx context.Context, input UpdateInvoiceInput) (Invoice, error)

	// SimulateInvoice generates an invoice based on the provided input, but does not persist it
	// can be used to execute the invoice generation logic without actually creating an invoice in the database
	SimulateInvoice(ctx context.Context, input SimulateInvoiceInput) (StandardInvoice, error)
	// UpsertValidationIssues upserts validation errors to the invoice bypassing the state machine, can only be
	// used on invoices in immutable state.
	UpsertValidationIssues(ctx context.Context, input UpsertValidationIssuesInput) error

	// RecalculateGatheringInvoices recalculates the gathering invoices for a given customer, updating the
	// collection_at attribute and deleting the gathering invoice if it has no lines.
	RecalculateGatheringInvoices(ctx context.Context, input RecalculateGatheringInvoicesInput) error
}

type InvoiceSplitLineGroupAdapter interface {
	CreateSplitLineGroup(ctx context.Context, input CreateSplitLineGroupAdapterInput) (SplitLineGroup, error)
	UpdateSplitLineGroup(ctx context.Context, input UpdateSplitLineGroupInput) (SplitLineGroup, error)
	DeleteSplitLineGroup(ctx context.Context, input DeleteSplitLineGroupInput) error
	GetSplitLineGroup(ctx context.Context, input GetSplitLineGroupInput) (SplitLineHierarchy, error)
	GetSplitLineGroupHeaders(ctx context.Context, input GetSplitLineGroupHeadersInput) (SplitLineGroupHeaders, error)
}

type InvoiceTrigger = stateless.Trigger

type InvoiceTriggerInput struct {
	Invoice InvoiceID
	// Trigger specifies the trigger that caused the invoice to be changed, only triggerPaid and triggerPayment* are allowed
	Trigger InvoiceTrigger

	ValidationErrors *InvoiceTriggerValidationInput
}

type InvoiceTriggerServiceInput struct {
	InvoiceTriggerInput

	// AppType is the type of the app that triggered the invoice
	AppType app.AppType
	// Capability is the capability of the app that was processing this trigger
	Capability app.CapabilityType
}

type InvoiceTriggerValidationInput struct {
	// Operation specifies the operation that yielded the validation errors
	// previous validation errors from this operation will be replaced by this one
	Operation StandardInvoiceOperation
	Errors    []error
}

type InvoiceType string

type InvoiceWorkflow struct {
	AppReferences          ProfileAppReferences `json:"appReferences"`
	Apps                   *ProfileApps         `json:"apps,omitempty"`
	SourceBillingProfileID string               `json:"sourceBillingProfileId,omitempty"`
	Config                 WorkflowConfig       `json:"config"`
}

type InvoicingApp interface {
	// ValidateStandardInvoice validates if the app can run for the given invoice
	ValidateStandardInvoice(ctx context.Context, invoice StandardInvoice) error

	// UpsertStandardInvoice upserts the invoice on the remote system, the invoice is read-only, the app should not modify it
	// the recommended behavior is that the invoices FlattenLinesByID is used to get all lines, then the app should
	// synchronize all the fee lines and store the external IDs in the result.
	UpsertStandardInvoice(ctx context.Context, invoice StandardInvoice) (*UpsertStandardInvoiceResult, error)

	// FinalizeStandardInvoice finalizes the invoice on the remote system, starts the payment flow. It is safe to assume
	// that the state machine have already performed an upsert as part of this state transition.
	//
	// If the payment is handled by a decoupled implementation (different app or app has strict separation of concerns)
	// then the payment app will be called with FinalizePayment and that should return the external ID of the payment. (later)
	FinalizeStandardInvoice(ctx context.Context, invoice StandardInvoice) (*FinalizeStandardInvoiceResult, error)

	// DeleteStandardInvoice deletes the invoice on the remote system, the invoice is read-only, the app should not modify it
	// the invoice deletion is only invoked for non-finalized invoices.
	DeleteStandardInvoice(ctx context.Context, invoice StandardInvoice) error
}

type InvoicingAppAsyncSyncer interface {
	CanDraftSyncAdvance(invoice StandardInvoice) (bool, error)
	CanIssuingSyncAdvance(invoice StandardInvoice) (bool, error)
}

type InvoicingAppPostAdvanceHook interface {
	// PostAdvanceInvoiceHook is called after the invoice has been advanced to the next stable state
	// (e.g. no next trigger is available)
	//
	// Can be used by the app to perform additional actions in case there are some post-processing steps
	// required on the invoice.
	PostAdvanceStandardInvoiceHook(ctx context.Context, invoice StandardInvoice) (*PostAdvanceHookResult, error)
}

type InvoicingConfig struct {
	AutoAdvance        bool                      `json:"autoAdvance,omitempty"`
	DraftPeriod        datetime.ISODuration      `json:"draftPeriod,omitempty"`
	DueAfter           datetime.ISODuration      `json:"dueAfter,omitempty"`
	ProgressiveBilling bool                      `json:"progressiveBilling,omitempty"`
	DefaultTaxConfig   *productcatalog.TaxConfig `json:"defaultTaxConfig,omitempty"`
}

type InvoicingOverrideConfig struct {
	AutoAdvance        *bool                     `json:"autoAdvance,omitempty"`
	DraftPeriod        *datetime.ISODuration     `json:"draftPeriod,omitempty"`
	DueAfter           *datetime.ISODuration     `json:"dueAfter,omitempty"`
	ProgressiveBilling *bool                     `json:"progressiveBilling,omitempty"`
	DefaultTaxConfig   *productcatalog.TaxConfig `json:"defaultTaxConfig,omitempty"`
}

type LineDiscountBase struct {
	Description            *string         `json:"description,omitempty"`
	ChildUniqueReferenceID *string         `json:"childUniqueReferenceId,omitempty"`
	ExternalIDs            LineExternalIDs `json:"externalIDs,omitempty"`
	Reason                 DiscountReason  `json:"reason,omitempty"`
}

type LineDiscountBaseManaged struct {
	models.ManagedModelWithID `json:",inline"`
	LineDiscountBase          `json:",inline"`
}

type LineDiscounts struct {
	Amount AmountLineDiscountsManaged `json:"amount,omitempty"`
	Usage  UsageLineDiscountsManaged  `json:"usage,omitempty"`
}

type LineExternalIDs struct {
	Invoicing string `json:"invoicing,omitempty"`
}

type LineID models.NamespacedID

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

type LineOrHierarchyType string

type LineWithInvoiceHeader struct {
	Line    GenericInvoiceLine
	Invoice GenericInvoiceReader
}

type LinesWithInvoiceHeaders []LineWithInvoiceHeader

type ListCustomerOverridesAdapterResult = pagination.Result[CustomerOverrideWithCustomerID]

type ListCustomerOverridesInput struct {
	pagination.Page

	// Warning: We only support a single namespace for now as the default profile handling
	// complicates things. If we need multiple namespace support, I would recommend a different
	// endpoint that doesn't take default namespace into account.
	Namespace                     string                 `json:"namespace"`
	BillingProfiles               []string               `json:"billingProfile,omitempty"`
	CustomersWithoutPinnedProfile bool                   `json:"customersWithoutPinnedProfile,omitempty"`
	Expand                        CustomerOverrideExpand `json:"expand,omitempty"`

	IncludeAllCustomers  bool     `json:"includeAllCustomers,omitempty"`
	CustomerIDs          []string `json:"customerID,omitempty"`
	CustomerName         string   `json:"customerName,omitempty"`
	CustomerKey          string   `json:"customerKey,omitempty"`
	CustomerPrimaryEmail string   `json:"customerPrimaryEmail,omitempty"`

	OrderBy CustomerOverrideOrderBy
	Order   sortx.Order
}

type ListCustomerOverridesResult = pagination.Result[CustomerOverrideWithDetails]

type ListGatheringInvoicesInput struct {
	pagination.Page

	Namespaces     []string
	Customers      []string
	Currencies     []currencyx.Code
	OrderBy        api.InvoiceOrderBy
	Order          sortx.Order
	IncludeDeleted bool
	Expand         GatheringInvoiceExpands
}

type ListInvoiceLinesAdapterInput struct {
	Namespace string

	CustomerID      string
	InvoiceIDs      []string
	InvoiceStatuses []StandardInvoiceStatus
	IncludeDeleted  bool
	Statuses        []InvoiceLineStatus

	LineIDs []string
}

type ListInvoicesExternalIDFilter struct {
	Type ExternalIDType
	IDs  []string
}

type ListInvoicesInput struct {
	pagination.Page

	Namespaces []string
	IDs        []string
	Customers  []string
	// Statuses searches by short InvoiceStatus (e.g. draft, issued)
	Statuses []string

	HasAvailableAction []InvoiceAvailableActionsFilter

	// ExtendedStatuses searches by exact InvoiceStatus
	ExtendedStatuses []StandardInvoiceStatus
	Currencies       []currencyx.Code

	IssuedAfter  *time.Time
	IssuedBefore *time.Time

	PeriodStartAfter  *time.Time
	PeriodStartBefore *time.Time

	// Filter by invoice creation time
	CreatedAfter  *time.Time
	CreatedBefore *time.Time

	IncludeDeleted bool

	// DraftUtil allows to filter invoices which have their draft state expired based on the provided time.
	// Invoice is expired if the time defined by Invoice.DraftUntil is in the past compared to ListInvoicesInput.DraftUntil.
	DraftUntil *time.Time

	// CollectionAt allows to filter invoices which have their collection_at attribute is in the past compared
	// to the time provided in CollectionAt parameter.
	CollectionAt *time.Time

	Expand InvoiceExpand

	ExternalIDs *ListInvoicesExternalIDFilter

	OrderBy api.InvoiceOrderBy
	Order   sortx.Order
}

type ListInvoicesResponse = pagination.Result[StandardInvoice]

type ListProfilesInput struct {
	pagination.Page

	Expand ProfileExpand

	Namespace       string
	IncludeArchived bool
	OrderBy         api.BillingProfileOrderBy
	Order           sortx.Order
}

type ListProfilesResult = pagination.Result[Profile]

type LockCustomerForUpdateAdapterInput = customer.CustomerID

type LockInvoicesForUpdateInput = genericMultiInvoiceInput

type LockableService interface {
	WithLock(ctx context.Context, customerID customer.CustomerID, fn func(ctx context.Context) error) error
}

type MaximumSpendDiscount struct{}

type Metadata map[string]string

type NewFlatFeeLineInput struct {
	ID        string
	CreatedAt time.Time
	UpdatedAt time.Time

	Namespace string
	Period    Period
	InvoiceAt time.Time

	InvoiceID string

	Name        string
	Metadata    map[string]string
	Annotations models.Annotations
	Description *string

	Currency currencyx.Code

	ManagedBy InvoiceLineManagedBy

	PerUnitAmount alpacadecimal.Decimal
	PaymentTerm   productcatalog.PaymentTermType

	RateCardDiscounts Discounts
}

type NextSequenceNumberInput struct {
	Namespace string
	Scope     string
}

type NotFoundError struct {
	ID     string
	Entity string
	Err    error
}

type PaymentConfig struct {
	CollectionMethod CollectionMethod `json:"collectionMethod"`
}

type PaymentOverrideConfig struct {
	CollectionMethod *CollectionMethod
}

type PercentageDiscount struct {
	productcatalog.PercentageDiscount `json:",inline"`

	CorrelationID string `json:"correlationID"`
}

type Period struct {
	Start time.Time `json:"start"`
	End   time.Time `json:"end"`
}

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

type Profile struct {
	BaseProfile

	// Optionaly expanded fields
	Apps *ProfileApps `json:"-"`
}

type ProfileAdapter interface {
	CreateProfile(ctx context.Context, input CreateProfileInput) (*BaseProfile, error)
	ListProfiles(ctx context.Context, input ListProfilesInput) (pagination.Result[BaseProfile], error)
	GetProfile(ctx context.Context, input GetProfileInput) (*AdapterGetProfileResponse, error)
	GetDefaultProfile(ctx context.Context, input GetDefaultProfileInput) (*AdapterGetProfileResponse, error)
	DeleteProfile(ctx context.Context, input DeleteProfileInput) error
	UpdateProfile(ctx context.Context, input UpdateProfileAdapterInput) (*BaseProfile, error)

	IsAppUsed(ctx context.Context, appID app.AppID) error

	GetUnpinnedCustomerIDsWithPaidSubscription(ctx context.Context, input GetUnpinnedCustomerIDsWithPaidSubscriptionInput) ([]customer.CustomerID, error)
}

type ProfileAppReferences struct {
	Tax       app.AppID `json:"tax"`
	Invoicing app.AppID `json:"invoicing"`
	Payment   app.AppID `json:"payment"`
}

type ProfileApps struct {
	Tax       app.App `json:"tax"`
	Invoicing app.App `json:"invoicing"`
	Payment   app.App `json:"payment"`
}

type ProfileExpand struct {
	Apps bool
}

type ProfileID models.NamespacedID

type ProfileService interface {
	CreateProfile(ctx context.Context, param CreateProfileInput) (*Profile, error)
	GetDefaultProfile(ctx context.Context, input GetDefaultProfileInput) (*Profile, error)
	GetProfile(ctx context.Context, input GetProfileInput) (*Profile, error)
	ListProfiles(ctx context.Context, input ListProfilesInput) (ListProfilesResult, error)
	DeleteProfile(ctx context.Context, input DeleteProfileInput) error
	UpdateProfile(ctx context.Context, input UpdateProfileInput) (*Profile, error)
	ProvisionDefaultBillingProfile(ctx context.Context, namespace string) error
	IsAppUsed(ctx context.Context, appID app.AppID) error
	ResolveStripeAppIDFromBillingProfile(ctx context.Context, namespace string, customerId *customer.CustomerID) (app.AppID, error)
}

type QuantityAccessor interface {
	GetQuantity() *alpacadecimal.Decimal
}

type RecalculateGatheringInvoicesInput = customer.CustomerID

type RetryInvoiceInput = InvoiceID

type SchemaLevelAdapter interface {
	// GetInvoiceDefaultSchemaLevel returns the current default schema level for invoices.
	GetInvoiceDefaultSchemaLevel(ctx context.Context) (int, error)
	// SetInvoiceDefaultSchemaLevel sets the current default schema level for invoices.
	SetInvoiceDefaultSchemaLevel(ctx context.Context, level int) error
}

type SequenceAdapter interface {
	NextSequenceNumber(ctx context.Context, input NextSequenceNumberInput) (alpacadecimal.Decimal, error)
}

type SequenceDefinition struct {
	Prefix         string
	SuffixTemplate string
	Scope          string
}

type SequenceGenerationInput struct {
	Namespace    string
	CustomerName string
	Currency     currencyx.Code
}

type SequenceService interface {
	GenerateInvoiceSequenceNumber(ctx context.Context, in SequenceGenerationInput, def SequenceDefinition) (string, error)
}

type Service interface {
	ProfileService
	CustomerOverrideService
	InvoiceLineService
	SplitLineGroupService
	InvoiceService
	GatheringInvoiceService
	StandardInvoiceService
	SequenceService
	LockableService

	InvoiceAppService

	ConfigService
}

type SimulateInvoiceInput struct {
	Namespace  string
	CustomerID *string
	Customer   *customer.Customer

	Number   *string
	Currency currencyx.Code
	Lines    StandardInvoiceLines
}

type SnapshotLineQuantityInput struct {
	Invoice *StandardInvoice
	Line    *StandardLine
}

type SnapshotQuantitiesInput = InvoiceID

type SplitLineGroup struct {
	models.ManagedModel         `json:",inline"`
	models.NamespacedID         `json:",inline"`
	SplitLineGroupMutableFields `json:",inline"`

	Price             *productcatalog.Price  `json:"price"`
	FeatureKey        *string                `json:"featureKey,omitempty"`
	Subscription      *SubscriptionReference `json:"subscription,omitempty"`
	Currency          currencyx.Code         `json:"currency"`
	UniqueReferenceID *string                `json:"childUniqueReferenceId,omitempty"`
}