i18n

type AbstractTranslatorFactory struct {
	Create LocalizerCreatorFn
	// contains filtered or unexported fields
}

type ExtendioTemplData struct{}

type FailedToReadDirectoryContentsError struct {
	LocalisableError
}

type FailedToReadDirectoryContentsErrorBehaviourQuery interface {
	FailedToReadDirectoryContents() bool
}

type FailedToReadDirectoryContentsTemplData struct {
	ExtendioTemplData
	Path   string
	Reason error
}

type FailedToResumeFromFileError struct {
	LocalisableError
}

type FailedToResumeFromFileErrorBehaviourQuery interface {
	FailedToResumeFromFile() bool
}

type FailedToResumeFromFileTemplData struct {
	ExtendioTemplData
	Path   string
	Reason error
}

type InternationalisationTemplData struct {
	ExtendioTemplData
}

type InvalidConfigEntryError struct {
	LocalisableError
}

type InvalidConfigEntryErrorBehaviourQuery interface {
	InvalidConfigEntry() bool
}

type InvalidConfigEntryTemplData struct {
	ExtendioTemplData
	Value string
	At    string
}

type InvalidResumeStrategyError struct {
	LocalisableError
}

type InvalidResumeStrategyErrorBehaviourQuery interface {
	InvalidResumeStrategy() bool
}

type InvalidResumeStrategyTemplData struct {
	ExtendioTemplData
	Value string
}

type LanguageInfo struct {
	UseOptions

	// Default language reflects the base language. If all else fails, messages will
	// be in this language. It is fixed at BritishEnglish reflecting the language this
	// package is written in.
	//
	Default language.Tag

	// Supported indicates the list of languages for which translations are available.
	//
	Supported SupportedLanguages
}

type LoadFrom struct {
	// Path denoting where to load language file from, defaults to exe location
	//
	Path string

	// Sources are the translation files that need to be loaded. They represent
	// the client app/library its dependencies.
	//
	// The source id would typically be the name of a package that is the source
	// of string messages that are to be translated. Actually, we could use
	// the top level url of the package by convention, as that is unique.
	// So extendio would use "github.com/snivilised/extendio" but clients
	// are free to use whatever naming scheme they want to use for their own
	// dependencies.
	//
	Sources TranslationFiles
}

type Localisable interface {
	Message() *Message
	SourceID() string
}

type LocalisableError struct {
	Data Localisable
}

type LocalisationTemplData struct {
	ExtendioTemplData
}

type LocalizeConfig = i18n.LocalizeConfig

type Localizer = i18n.Localizer

type LocalizerCreatorFn func(li *LanguageInfo, sourceID string) (*Localizer, error)

type LocalizerInfo struct {
	// Localizer by default created internally, but can be overridden by
	// the client if they provide a create function to the Translator Factory
	//
	Localizer *Localizer
	// contains filtered or unexported fields
}

type Message = i18n.Message

type MissingCallbackBehaviourQuery interface {
	MissingCallback() bool
}

type MissingCallbackError struct {
	LocalisableError
}

type MissingCallbackTemplData struct {
	ExtendioTemplData
}

type MissingCustomFilterDefinitionBehaviourQuery interface {
	MissingCustomFilterDefinition() bool
}

type MissingCustomFilterDefinitionError struct {
	LocalisableError
}

type MissingCustomFilterDefinitionTemplData struct {
	ExtendioTemplData
	At string
}

type NotADirectoryError struct {
	LocalisableError
}

type NotADirectoryErrorBehaviourQuery interface {
	NotADirectory() bool
}

type NotADirectoryTemplData struct {
	ExtendioTemplData
	Path string
}

type PathNotFoundError struct {
	LocalisableError
}

type PathNotFoundErrorBehaviourQuery interface {
	IsPathNotFound() bool
}

type PathNotFoundTemplData struct {
	ExtendioTemplData
	Name string
	Path string
}

type SortFnFailedBehaviourQuery interface {
	SortFnFailed() bool
}

type SortFnFailedError struct {
	LocalisableError
}

type SortFnFailedTemplData struct {
	ExtendioTemplData
}

type SupportedLanguages []language.Tag

type TerminateTraverseBehaviourQuery interface {
	TraverseTerminated() bool
}

type TerminateTraverseError struct {
	LocalisableError
}

type TerminateTraverseTemplData struct {
	ExtendioTemplData
	Reason string
}

type ThirdPartyError struct {
	LocalisableError
}

type ThirdPartyErrorTemplData struct {
	ExtendioTemplData

	Error error
}

type TranslationFiles map[string]TranslationSource

type TranslationSource struct {
	// Name of dependency's translation file
	Name string
	Path string
}

type Translator interface {
	Localise(data Localisable) string
	LanguageInfoRef() utils.RoProp[*LanguageInfo]
	// contains filtered or unexported methods
}

type TranslatorFactory interface {
	New(lang *LanguageInfo) Translator
}

type UnknownMarshalFormatError struct {
	LocalisableError
}

type UnknownMarshalFormatErrorBehaviourQuery interface {
	UnknownMarshalFormat() bool
}

type UnknownMarshalFormatTemplData struct {
	ExtendioTemplData
	Format string
	At     string
}

type UseOptionFn func(*UseOptions)

type UseOptions struct {
	// Tag sets the language to use
	//
	Tag language.Tag

	// From denotes where to load the translation file from
	//
	From LoadFrom

	// DefaultIsAcceptable controls whether an error is returned if the
	// request language is not available. By default DefaultIsAcceptable
	// is true so that the application continues in the default language
	// even if the requested language is not available.
	//
	DefaultIsAcceptable bool

	// Create allows the client to  override the default function to create
	// the i18n Localizer(s) (1 per language).
	//
	Create LocalizerCreatorFn

	// Custom set-able by the client for what ever purpose is required.
	//
	Custom any
}