schema

package

Go to main page

Versions in this module

v0

v0.14.2

Jan 8, 2025

v0.14.1

Dec 12, 2024

v0.14.0

Dec 10, 2024

Changes in this version

+ type TypedStringEnumSchema struct

+ func NewTypedStringEnumSchema[T ~string](validValues map[T]*DisplayValue) *TypedStringEnumSchema[T]

+ func (s TypedStringEnumSchema[T]) TypeID() TypeID

+ func (s TypedStringEnumSchema[T]) Unserialize(data any) (any, error)

+ func (s TypedStringEnumSchema[T]) UnserializeType(data any) (string, error)

v0.13.0

Aug 22, 2024

Changes in this version

type AnyTypedObject

+ func (a *AnyTypedObject[T]) IDEnforced() bool

type Object

+ IDUnenforced func() bool

type ObjectSchema

+ IDUnenforcedValue bool

+ func NewUnenforcedIDObjectSchema(id string, properties map[string]*PropertySchema) *ObjectSchema

+ func (o *ObjectSchema) IDUnenforced() bool

type RefSchema

+ func (r *RefSchema) IDUnenforced() bool

type ScopeSchema

+ func (s *ScopeSchema) IDUnenforced() bool

v0.12.5

Jul 31, 2024

v0.12.4

Jul 31, 2024

v0.12.3

Jul 25, 2024

v0.12.2

Jul 9, 2024

v0.12.1

Jun 10, 2024

v0.12.0

May 9, 2024

Changes in this version

+ const SelfNamespace

type AbstractListSchema

+ func (l AbstractListSchema[ItemType]) ApplyNamespace(objects map[string]*ObjectSchema, namespace string)

type MapSchema

+ func (m MapSchema[K, V]) ApplyNamespace(objects map[string]*ObjectSchema, namespace string)

type ObjectSchema

+ func (o *ObjectSchema) ApplyNamespace(objects map[string]*ObjectSchema, namespace string)

type OneOfSchema

+ func (o OneOfSchema[KeyType]) ApplyNamespace(objects map[string]*ObjectSchema, namespace string)

type PropertySchema

+ func (p *PropertySchema) ApplyNamespace(objects map[string]*ObjectSchema, namespace string)

type RefSchema

+ func (r *RefSchema) ApplyNamespace(objects map[string]*ObjectSchema, namespace string)

+ type ScalarType struct

+ func (s *ScalarType) ApplyNamespace(_ map[string]*ObjectSchema, _ string)

+ func (s *ScalarType) ValidateReferences() error

type Scope

+ ApplySelf func()

type ScopeSchema

+ func (s *ScopeSchema) ApplyNamespace(externalObjects map[string]*ObjectSchema, namespace string)

+ func (s *ScopeSchema) ApplySelf()

type Serializable

+ ApplyNamespace func(objects map[string]*ObjectSchema, namespace string)

type StepOutputSchema

+ func (s StepOutputSchema) ApplyNamespace(objects map[string]*ObjectSchema, namespace string)

v0.11.1

Apr 22, 2024

v0.11.0

Apr 19, 2024

Changes in this version

+ const DEFAULT_NAMESPACE

type AbstractListSchema

+ func (l AbstractListSchema[ItemType]) ValidateReferences() error

type AnySchema

+ func (a *AnySchema) ValidateReferences() error

type BoolSchema

+ func (b BoolSchema) ValidateReferences() error

type EnumSchema

+ func (e EnumSchema[T]) ValidateReferences() error

type FloatSchema

+ func (f FloatSchema) ValidateReferences() error

type IntSchema

+ func (i IntSchema) ValidateReferences() error

type MapSchema

+ func (m MapSchema[K, V]) ValidateReferences() error

type Object

+ func ConvertToObjectSchema(typeOrData any) (Object, bool)

type ObjectSchema

+ func (o *ObjectSchema) ValidateReferences() error

type OneOfSchema

+ DiscriminatorInlined bool

+ func (o OneOfSchema[KeyType]) ValidateReferences() error

type PatternSchema

+ func (p PatternSchema) ValidateReferences() error

type PropertySchema

+ func (p *PropertySchema) ValidateReferences() error

type Ref

+ Namespace func() string

+ ObjectReady func() bool

type RefSchema

+ ObjectNamespace string

+ func NewNamespacedRefSchema(id string, namespace string, display Display) *RefSchema

+ func (r *RefSchema) Namespace() string

+ func (r *RefSchema) ObjectReady() bool

+ func (r *RefSchema) ValidateReferences() error

type Scope

+ RootObject func() *ObjectSchema

type ScopeSchema

+ func (s *ScopeSchema) RootObject() *ObjectSchema

+ func (s *ScopeSchema) ValidateReferences() error

type Serializable

+ ValidateReferences func() error

type StepOutputSchema

+ func (s StepOutputSchema) ValidateReferences() error

type StringSchema

+ func (s StringSchema) ValidateReferences() error

v0.10.0-beta1

Apr 11, 2024

v0.9.0-beta1

Feb 21, 2024

v0.8.0

Jan 30, 2024

v0.7.1

Jan 17, 2024

v0.7.0

Dec 14, 2023

Changes in this version

+ type CallableFunction interface

+ Call func(arguments []any) (any, error)

+ ToFunctionSchema func() (*FunctionSchema, error)

+ func NewCallableFunction(id string, inputs []Type, output Type, outputsError bool, display Display, ...) (CallableFunction, error)

+ func NewDynamicCallableFunction(id string, inputs []Type, display Display, handler any, ...) (CallableFunction, error)

+ type CallableFunctionSchema struct

+ DisplayValue Display

+ DynamicTypeHandler func(inputType []Type) (Type, error)

+ Handler reflect.Value

+ IDValue string

+ InputsValue []Type

+ OutputsError bool

+ StaticOutputValue Type

+ func (f CallableFunctionSchema) Call(arguments []any) (any, error)

+ func (f CallableFunctionSchema) Display() Display

+ func (f CallableFunctionSchema) ID() string

+ func (f CallableFunctionSchema) Output(inputType []Type) (Type, bool, error)

+ func (f CallableFunctionSchema) ParameterTypeNames() []string

+ func (f CallableFunctionSchema) Parameters() []Type

+ func (f CallableFunctionSchema) String() string

+ func (f CallableFunctionSchema) ToFunctionSchema() (*FunctionSchema, error)

+ type Function interface

+ Display func() Display

+ ID func() string

+ Output func([]Type) (Type, bool, error)

+ Parameters func() []Type

+ String func() string

+ type FunctionCallError struct

+ IsFunctionReportedError bool

+ SourceError error

+ func NewFunctionCallError(err error, isFunctionReportedError bool) *FunctionCallError

+ func (e *FunctionCallError) Error() string

+ type FunctionSchema struct

+ DisplayValue Display

+ IDValue string

+ InputsValue []Type

+ OutputValue Type

+ func (f FunctionSchema) Display() Display

+ func (f FunctionSchema) ID() string

+ func (f FunctionSchema) Output(_ []Type) (Type, error)

+ func (f FunctionSchema) ParameterTypeNames() []string

+ func (f FunctionSchema) Parameters() []Type

+ func (f FunctionSchema) String() string

v0.6.0

Dec 6, 2023

v0.5.1

Nov 6, 2023

v0.5.0

Oct 23, 2023

Changes in this version

type Input

+ RunID string

v0.5.0-beta.2

Oct 23, 2023

v0.5.0-beta.1

Oct 20, 2023

v0.4.1

Sep 19, 2023

Changes in this version

type AbstractListSchema

+ func (l AbstractListSchema[ItemType]) ValidateCompatibility(typeOrData any) error

type AnySchema

+ func (a *AnySchema) ValidateCompatibility(typeOrData any) error

type BoolSchema

+ func (b BoolSchema) ValidateCompatibility(typeOrData any) error

type CallableSchema

+ func (s CallableSchema) CallSignal(ctx context.Context, stepID string, signalID string, serializedInputData any) (err error)

+ func (s CallableSchema) CallStep(ctx context.Context, stepID string, serializedInputData any) (outputID string, serializedOutputData any, err error)

+ type CallableSignal interface

+ Call func(ctx context.Context, stepData any, inputData any) (err error)

+ ToSignalSchema func() *SignalSchema

+ func NewCallableSignal(id string, input *ScopeSchema, display Display, ...) CallableSignal

+ func NewCallableSignalFromSchema(s *SignalSchema, handler func(context.Context, StepData, InputType)) CallableSignal

+ type CallableSignalSchema struct

+ DisplayValue Display

+ IDValue string

+ InputValue *ScopeSchema

+ func (s CallableSignalSchema[StepData, InputType]) Call(ctx context.Context, stepData any, input any) error

+ func (s CallableSignalSchema[StepData, InputType]) DataSchema() Scope

+ func (s CallableSignalSchema[StepData, InputType]) Display() Display

+ func (s CallableSignalSchema[StepData, InputType]) ID() string

+ func (s CallableSignalSchema[StepData, InputType]) ToSignalSchema() *SignalSchema

type CallableStep

+ func NewCallableStepWithSignals(id string, input *ScopeSchema, outputs map[string]*StepOutputSchema, ...) CallableStep

+ CallSignal func(ctx context.Context, signalID string, data any) (err error)

type CallableStepSchema

+ SignalEmittersValue map[string]*SignalSchema

+ SignalHandlersValue map[string]CallableSignal

+ func (s *CallableStepSchema[StepData, InputType]) CallSignal(ctx context.Context, signalID string, input any) error

+ func (s *CallableStepSchema[StepData, InputType]) SignalEmitters() map[string]*SignalSchema

+ func (s *CallableStepSchema[StepData, InputType]) SignalHandlers() map[string]*SignalSchema

type EnumSchema

+ func (s EnumSchema[T]) ValidateCompatibility(typeOrData any) error

type FloatSchema

+ func (f FloatSchema) ValidateCompatibility(typeOrData any) error

+ type IllegalStateError struct

+ Cause error

+ func (i IllegalStateError) Error() string

+ func (i IllegalStateError) Unwrap() error

+ type Input struct

+ ID string

+ InputData any

type IntSchema

+ func (i IntSchema) ValidateCompatibility(typeOrData any) error

type MapSchema

+ func (m MapSchema[K, V]) ValidateCompatibility(typeOrData any) error

type ObjectSchema

+ func (o *ObjectSchema) ValidateCompatibility(typeOrData any) error

type OneOfSchema

+ func (o OneOfSchema[KeyType]) ValidateCompatibility(typeOrData any) error

type PatternSchema

+ func (p PatternSchema) ValidateCompatibility(typeOrData any) error

type PropertySchema

+ Disabled bool

+ DisabledReason *string

+ func (p *PropertySchema) Disable(reason string) *PropertySchema

+ func (p *PropertySchema) ValidateCompatibility(typeOrData any) error

type RefSchema

+ func (r *RefSchema) ValidateCompatibility(typeOrData any) error

type ScopeSchema

+ func NewScopeSchemaFromScope(scope Scope) *ScopeSchema

+ func (s *ScopeSchema) ValidateCompatibility(typeOrData any) error

type Serializable

+ ValidateCompatibility func(typeOrData any) error

+ type Signal interface

+ DataSchema func() Scope

+ Display func() Display

+ ID func() string

+ type SignalSchema struct

+ DataSchemaValue Scope

+ DisplayValue Display

+ IDValue string

+ func NewSignalSchema(id string, dataSchema Scope, display Display) *SignalSchema

+ func (s SignalSchema) DataSchema() Scope

+ func (s SignalSchema) Display() Display

+ func (s SignalSchema) ID() string

type Step

+ SignalEmitters func() map[string]*SignalSchema

+ SignalHandlers func() map[string]*SignalSchema

type StepOutputSchema

+ func (s StepOutputSchema) ValidateCompatibility(data any) error

type StepSchema

+ SignalEmittersValue map[string]*SignalSchema

+ SignalHandlersValue map[string]*SignalSchema

+ func (s StepSchema) SignalEmitters() map[string]*SignalSchema

+ func (s StepSchema) SignalHandlers() map[string]*SignalSchema

type StringSchema

+ func (s StringSchema) ValidateCompatibility(typeOrData any) error

v0.4.0-beta.1

Aug 9, 2023

v0.3.0-beta.1

Jun 1, 2023

v0.2.0

May 31, 2023

v0.1.3

Apr 11, 2023

Changes in this version

type ScopeSchema

+ func DescribeStepOutput() *ScopeSchema

v0.1.2

Mar 17, 2023

Changes in this version

+ type UntypedList = List[Type]

v0.1.1

Mar 3, 2023

v0.1.0

Feb 28, 2023

Changes in this version

+ var UnitBytes = NewUnits(NewUnit("B", "B", "byte", "bytes"), map[int64]*UnitDefinition{ ... })

+ var UnitCharacters = NewUnits(NewUnit("char", "chars", "character", "characters"), nil)

+ var UnitDurationNanoseconds = NewUnits(NewUnit("ns", "ns", "nanosecond", "nanoseconds"), ...)

+ var UnitDurationSeconds = NewUnits(NewUnit("s", "s", "second", "seconds"), map[int64]*UnitDefinition{ ... })

+ var UnitPercentage = NewUnits(NewUnit("%", "%", "percent", "percent"), nil)

+ func ConstraintErrorAddPathSegment(err error, pathSegment string) error

+ func IntPointer(value T) *int64

+ func PointerTo(value T) *T

+ type AbstractListSchema struct

+ ItemsValue ItemType

+ MaxValue *int64

+ MinValue *int64

+ func (l AbstractListSchema[ItemType]) ApplyScope(scope Scope)

+ func (l AbstractListSchema[ItemType]) Items() ItemType

+ func (l AbstractListSchema[ItemType]) Max() *int64

+ func (l AbstractListSchema[ItemType]) Min() *int64

+ func (l AbstractListSchema[ItemType]) ReflectedType() reflect.Type

+ func (l AbstractListSchema[ItemType]) Serialize(data any) (any, error)

+ func (l AbstractListSchema[ItemType]) TypeID() TypeID

+ func (l AbstractListSchema[ItemType]) Unserialize(data any) (any, error)

+ func (l AbstractListSchema[ItemType]) Validate(data any) error

+ type AnySchema struct

+ func NewAnySchema() *AnySchema

+ func (a *AnySchema) ApplyScope(_ Scope)

+ func (a *AnySchema) ReflectedType() reflect.Type

+ func (a *AnySchema) Serialize(data any) (any, error)

+ func (a *AnySchema) TypeID() TypeID

+ func (a *AnySchema) Unserialize(data any) (any, error)

+ func (a *AnySchema) Validate(data any) error

+ type AnyTypedObject struct

+ func (a *AnyTypedObject[T]) Any() TypedObject[any]

+ func (a *AnyTypedObject[T]) SerializeType(data any) (any, error)

+ func (a *AnyTypedObject[T]) UnserializeType(data any) (any, error)

+ func (a *AnyTypedObject[T]) ValidateType(data any) error

+ type BadArgumentError struct

+ Cause error

+ Message string

+ func (b BadArgumentError) Error() string

+ func (b BadArgumentError) Unwrap() error

+ type Bool interface

+ type BoolSchema struct

+ func NewBoolSchema() *BoolSchema

+ func (b BoolSchema) ApplyScope(scope Scope)

+ func (b BoolSchema) ReflectedType() reflect.Type

+ func (b BoolSchema) Serialize(d any) (any, error)

+ func (b BoolSchema) SerializeType(data bool) (any, error)

+ func (b BoolSchema) TypeID() TypeID

+ func (b BoolSchema) Unserialize(data any) (any, error)

+ func (b BoolSchema) UnserializeType(data any) (bool, error)

+ func (b BoolSchema) Validate(data any) error

+ func (b BoolSchema) ValidateType(data bool) error

+ type CallableSchema struct

+ StepsValue map[string]CallableStep

+ func NewCallableSchema(steps ...CallableStep) *CallableSchema

+ func (s CallableSchema) Call(stepID string, serializedInputData any) (outputID string, serializedOutputData any, err error)

+ func (s CallableSchema) SelfSerialize() (any, error)

+ type CallableStep interface

+ Call func(data any) (outputID string, outputData any, err error)

+ ToStepSchema func() *StepSchema

+ func NewCallableStep(id string, input *ScopeSchema, outputs map[string]*StepOutputSchema, ...) CallableStep

+ type CallableStepSchema struct

+ DisplayValue Display

+ IDValue string

+ InputValue *ScopeSchema

+ OutputsValue map[string]*StepOutputSchema

+ func (s CallableStepSchema[InputType]) Call(input any) (string, any, error)

+ func (s CallableStepSchema[InputType]) Display() Display

+ func (s CallableStepSchema[InputType]) ID() string

+ func (s CallableStepSchema[InputType]) Input() Scope

+ func (s CallableStepSchema[InputType]) Outputs() map[string]*StepOutputSchema

+ func (s CallableStepSchema[InputType]) ToStepSchema() *StepSchema

+ type ConstraintError struct

+ Cause error

+ Message string

+ Path []string

+ func (c *ConstraintError) AddPathSegment(pathSegment string) error

+ func (c *ConstraintError) Error() string

+ func (c *ConstraintError) Unwrap() error

+ type Display interface

+ Description func() *string

+ Icon func() *string

+ Name func() *string

+ type DisplayValue struct

+ DescriptionValue *string

+ IconValue *string

+ NameValue *string

+ func NewDisplayValue(name *string, description *string, icon *string) *DisplayValue

+ func (d DisplayValue) Description() *string

+ func (d DisplayValue) Icon() *string

+ func (d DisplayValue) Name() *string

+ type Enum interface

+ ValidValues func() map[T]*DisplayValue

+ type EnumSchema struct

+ ValidValuesMap map[T]*DisplayValue

+ func (e EnumSchema[T]) ApplyScope(scope Scope)

+ func (e EnumSchema[T]) ReflectedType() reflect.Type

+ func (e EnumSchema[T]) Serialize(d any) (any, error)

+ func (e EnumSchema[T]) SerializeType(data T) (any, error)

+ func (e EnumSchema[T]) ValidValues() map[T]*DisplayValue

+ func (e EnumSchema[T]) Validate(d any) error

+ func (e EnumSchema[T]) ValidateType(data T) error

+ type Float interface

+ Max func() *float64

+ Min func() *float64

+ Units func() *UnitsDefinition

+ type FloatSchema struct

+ MaxValue *float64

+ MinValue *float64

+ UnitsValue *UnitsDefinition

+ func NewFloatSchema(min *float64, max *float64, units *UnitsDefinition) *FloatSchema

+ func (f FloatSchema) ApplyScope(scope Scope)

+ func (f FloatSchema) Max() *float64

+ func (f FloatSchema) Min() *float64

+ func (f FloatSchema) ReflectedType() reflect.Type

+ func (f FloatSchema) Serialize(d any) (any, error)

+ func (f FloatSchema) SerializeType(data float64) (any, error)

+ func (f FloatSchema) TypeID() TypeID

+ func (f FloatSchema) Units() *UnitsDefinition

+ func (f FloatSchema) Unserialize(data any) (any, error)

+ func (f FloatSchema) UnserializeType(data any) (float64, error)

+ func (f FloatSchema) Validate(d any) error

+ func (f FloatSchema) ValidateType(data float64) error

+ type Int interface

+ Max func() *int64

+ Min func() *int64

+ Units func() *UnitsDefinition

+ type IntEnum interface

+ Units func() *UnitsDefinition

+ type IntEnumSchema struct

+ IntUnits *UnitsDefinition

+ func NewIntEnumSchema(validValues map[int64]*DisplayValue, units *UnitsDefinition) *IntEnumSchema

+ func (e IntEnumSchema) UnserializeType(data any) (int64, error)

+ func (i IntEnumSchema) TypeID() TypeID

+ func (i IntEnumSchema) Units() *UnitsDefinition

+ func (i IntEnumSchema) Unserialize(data any) (any, error)

+ type IntSchema struct

+ MaxValue *int64

+ MinValue *int64

+ UnitsValue *UnitsDefinition

+ func NewIntSchema(min *int64, max *int64, units *UnitsDefinition) *IntSchema

+ func (i IntSchema) ApplyScope(scope Scope)

+ func (i IntSchema) Max() *int64

+ func (i IntSchema) Min() *int64

+ func (i IntSchema) ReflectedType() reflect.Type

+ func (i IntSchema) Serialize(d any) (any, error)

+ func (i IntSchema) SerializeType(data int64) (any, error)

+ func (i IntSchema) TypeID() TypeID

+ func (i IntSchema) Units() *UnitsDefinition

+ func (i IntSchema) Unserialize(data any) (any, error)

+ func (i IntSchema) UnserializeType(data any) (int64, error)

+ func (i IntSchema) Validate(d any) error

+ func (i IntSchema) ValidateType(data int64) error

+ type InvalidInputError struct

+ Cause error

+ func (i InvalidInputError) Error() string

+ func (i InvalidInputError) Unwrap() error

+ type InvalidOutputError struct

+ Cause error

+ func (i InvalidOutputError) Error() string

+ func (i InvalidOutputError) Unwrap() error

+ type List interface

+ Items func() ItemType

+ Max func() *int64

+ Min func() *int64

+ type ListSchema struct

+ func NewListSchema(items Type, min *int64, max *int64) *ListSchema

+ type Map interface

+ Keys func() KeyType

+ Max func() *int64

+ Min func() *int64

+ Values func() ValueType

+ type MapKeyType interface

+ type MapSchema struct

+ KeysValue K

+ MaxValue *int64

+ MinValue *int64

+ ValuesValue V

+ func NewMapSchema(keys Type, values Type, min *int64, max *int64) *MapSchema[Type, Type]

+ func (m MapSchema[K, V]) ApplyScope(scope Scope)

+ func (m MapSchema[K, V]) Keys() K

+ func (m MapSchema[K, V]) Max() *int64

+ func (m MapSchema[K, V]) Min() *int64

+ func (m MapSchema[K, V]) ReflectedType() reflect.Type

+ func (m MapSchema[K, V]) Serialize(data any) (any, error)

+ func (m MapSchema[K, V]) TypeID() TypeID

+ func (m MapSchema[K, V]) Unserialize(data any) (any, error)

+ func (m MapSchema[K, V]) Validate(data any) error

+ func (m MapSchema[K, V]) Values() V

+ type NoSuchStepError struct

+ Step string

+ func (n NoSuchStepError) Error() string

+ type NumberType interface

+ type Object interface

+ GetDefaults func() map[string]any

+ ID func() string

+ Properties func() map[string]*PropertySchema

+ type ObjectSchema struct

+ IDValue string

+ PropertiesValue map[string]*PropertySchema

+ func NewObjectSchema(id string, properties map[string]*PropertySchema) *ObjectSchema

+ func NewStructMappedObjectSchema(id string, properties map[string]*PropertySchema) *ObjectSchema

+ func (o *ObjectSchema) ApplyScope(scope Scope)

+ func (o *ObjectSchema) GetDefaults() map[string]any

+ func (o *ObjectSchema) ID() string

+ func (o *ObjectSchema) Properties() map[string]*PropertySchema

+ func (o *ObjectSchema) ReflectedType() reflect.Type

+ func (o *ObjectSchema) Serialize(data any) (any, error)

+ func (o *ObjectSchema) TypeID() TypeID

+ func (o *ObjectSchema) Unserialize(data any) (result any, err error)

+ func (o *ObjectSchema) Validate(data any) error

+ type OneOf interface

+ DiscriminatorFieldName func() string

+ Types func() map[KeyType]Object

+ type OneOfInt interface

+ type OneOfSchema struct

+ DiscriminatorFieldNameValue string

+ TypesValue map[KeyType]Object

+ func NewOneOfIntSchema(types map[int64]Object, discriminatorFieldName string) *OneOfSchema[int64]

+ func NewOneOfStringSchema(types map[string]Object, discriminatorFieldName string) *OneOfSchema[string]

+ func (o OneOfSchema[KeyType]) ApplyScope(scope Scope)

+ func (o OneOfSchema[KeyType]) DiscriminatorFieldName() string

+ func (o OneOfSchema[KeyType]) ReflectedType() reflect.Type

+ func (o OneOfSchema[KeyType]) Serialize(data any) (result any, err error)

+ func (o OneOfSchema[KeyType]) SerializeType(data any) (any, error)

+ func (o OneOfSchema[KeyType]) TypeID() TypeID

+ func (o OneOfSchema[KeyType]) Types() map[KeyType]Object

+ func (o OneOfSchema[KeyType]) Unserialize(data any) (any, error)

+ func (o OneOfSchema[KeyType]) UnserializeType(data any) (result any, err error)

+ func (o OneOfSchema[KeyType]) Validate(data any) error

+ func (o OneOfSchema[KeyType]) ValidateType(data any) error

+ type OneOfString interface

+ type Pattern interface

+ type PatternSchema struct

+ func NewPatternSchema() *PatternSchema

+ func (p PatternSchema) ApplyScope(scope Scope)

+ func (p PatternSchema) ReflectedType() reflect.Type

+ func (p PatternSchema) Serialize(data any) (any, error)

+ func (p PatternSchema) SerializeType(data *regexp.Regexp) (any, error)

+ func (p PatternSchema) TypeID() TypeID

+ func (p PatternSchema) Unserialize(data any) (any, error)

+ func (p PatternSchema) UnserializeType(data any) (*regexp.Regexp, error)

+ func (p PatternSchema) Validate(d any) error

+ func (p PatternSchema) ValidateType(data *regexp.Regexp) error

+ type Property interface

+ Conflicts func() []string

+ Default func() *string

+ Display func() Display

+ Examples func() []string

+ Required func() bool

+ RequiredIf func() []string

+ RequiredIfNot func() []string

+ Type func() Type

+ type PropertySchema struct

+ ConflictsValue []string

+ DefaultValue *string

+ DisplayValue Display

+ ExamplesValue []string

+ RequiredIfNotValue []string

+ RequiredIfValue []string

+ RequiredValue bool

+ TypeValue Type

+ func NewPropertySchema(t Type, displayValue Display, required bool, requiredIf []string, ...) *PropertySchema

+ func (p *PropertySchema) ApplyScope(scope Scope)

+ func (p *PropertySchema) Conflicts() []string

+ func (p *PropertySchema) Default() *string

+ func (p *PropertySchema) Display() Display

+ func (p *PropertySchema) Examples() []string

+ func (p *PropertySchema) ReflectedType() reflect.Type

+ func (p *PropertySchema) Required() bool

+ func (p *PropertySchema) RequiredIf() []string

+ func (p *PropertySchema) RequiredIfNot() []string

+ func (p *PropertySchema) Serialize(data any) (any, error)

+ func (p *PropertySchema) TreatEmptyAsDefaultValue() *PropertySchema

+ func (p *PropertySchema) Type() Type

+ func (p *PropertySchema) TypeID() TypeID

+ func (p *PropertySchema) Unserialize(data any) (any, error)

+ func (p *PropertySchema) Validate(data any) error

+ type Ref interface

+ Display func() Display

+ GetObject func() Object

+ ID func() string

+ type RefSchema struct

+ DisplayValue Display

+ IDValue string

+ func NewRefSchema(id string, display Display) *RefSchema

+ func (r *RefSchema) ApplyScope(scope Scope)

+ func (r *RefSchema) Display() Display

+ func (r *RefSchema) GetDefaults() map[string]any

+ func (r *RefSchema) GetObject() Object

+ func (r *RefSchema) ID() string

+ func (r *RefSchema) Properties() map[string]*PropertySchema

+ func (r *RefSchema) ReflectedType() reflect.Type

+ func (r *RefSchema) Serialize(data any) (any, error)

+ func (r *RefSchema) TypeID() TypeID

+ func (r *RefSchema) Unserialize(data any) (any, error)

+ func (r *RefSchema) Validate(data any) error

+ type Schema interface

+ SelfSerialize func() (any, error)

+ Steps func() map[string]S

+ func NewSchema(steps map[string]*StepSchema) Schema[Step]

+ type SchemaSchema struct

+ StepsValue map[string]*StepSchema

+ func UnserializeSchema(data any) (*SchemaSchema, error)

+ func (s SchemaSchema) SelfSerialize() (any, error)

+ func (s SchemaSchema) Steps() map[string]Step

+ type Scope interface

+ Objects func() map[string]*ObjectSchema

+ Root func() string

+ SelfSerialize func() (any, error)

+ type ScopeSchema struct

+ ObjectsValue map[string]*ObjectSchema

+ RootValue string

+ func DescribeSchema() *ScopeSchema

+ func DescribeScope() *ScopeSchema

+ func NewScopeSchema(rootObject *ObjectSchema, objects ...*ObjectSchema) *ScopeSchema

+ func UnserializeScope(data any) (*ScopeSchema, error)

+ func (s *ScopeSchema) ApplyScope(_ Scope)

+ func (s *ScopeSchema) GetDefaults() map[string]any

+ func (s *ScopeSchema) ID() string

+ func (s *ScopeSchema) Objects() map[string]*ObjectSchema

+ func (s *ScopeSchema) Properties() map[string]*PropertySchema

+ func (s *ScopeSchema) ReflectedType() reflect.Type

+ func (s *ScopeSchema) Root() string

+ func (s *ScopeSchema) SelfSerialize() (any, error)

+ func (s *ScopeSchema) Serialize(data any) (any, error)

+ func (s *ScopeSchema) TypeID() TypeID

+ func (s *ScopeSchema) Unserialize(data any) (any, error)

+ func (s *ScopeSchema) Validate(data any) error

+ type Serializable interface

+ ApplyScope func(scope Scope)

+ ReflectedType func() reflect.Type

+ Serialize func(data any) (any, error)

+ Unserialize func(data any) (any, error)

+ Validate func(data any) error

+ type Step interface

+ Display func() Display

+ ID func() string

+ Input func() Scope

+ Outputs func() map[string]*StepOutputSchema

+ type StepOutput interface

+ Display func() *DisplayValue

+ Error func() bool

+ Schema func() Scope

+ type StepOutputSchema struct

+ DisplayValue *DisplayValue

+ ErrorValue bool

+ SchemaValue Scope

+ func NewStepOutputSchema(schema Scope, display *DisplayValue, error bool) *StepOutputSchema

+ func (s StepOutputSchema) ApplyScope(scope Scope)

+ func (s StepOutputSchema) Display() *DisplayValue

+ func (s StepOutputSchema) Error() bool

+ func (s StepOutputSchema) ReflectedType() reflect.Type

+ func (s StepOutputSchema) Schema() Scope

+ func (s StepOutputSchema) Serialize(data any) (any, error)

+ func (s StepOutputSchema) Unserialize(data any) (any, error)

+ func (s StepOutputSchema) Validate(data any) error

+ type StepSchema struct

+ DisplayValue Display

+ IDValue string

+ InputValue Scope

+ OutputsValue map[string]*StepOutputSchema

+ func NewStepSchema(id string, input Scope, outputs map[string]*StepOutputSchema, display Display) *StepSchema

+ func (s StepSchema) Display() Display

+ func (s StepSchema) ID() string

+ func (s StepSchema) Input() Scope

+ func (s StepSchema) Outputs() map[string]*StepOutputSchema

+ type String interface

+ Max func() *int64

+ Min func() *int64

+ Pattern func() *regexp.Regexp

+ type StringEnum interface

+ type StringEnumSchema struct

+ func NewStringEnumSchema(validValues map[string]*DisplayValue) *StringEnumSchema

+ func (s StringEnumSchema) TypeID() TypeID

+ func (s StringEnumSchema) Unserialize(data any) (any, error)

+ func (s StringEnumSchema) UnserializeType(data any) (string, error)

+ type StringSchema struct

+ MaxValue *int64

+ MinValue *int64

+ PatternValue *regexp.Regexp

+ func NewStringSchema(min *int64, max *int64, pattern *regexp.Regexp) *StringSchema

+ func (s StringSchema) ApplyScope(scope Scope)

+ func (s StringSchema) Max() *int64

+ func (s StringSchema) Min() *int64

+ func (s StringSchema) Pattern() *regexp.Regexp

+ func (s StringSchema) ReflectedType() reflect.Type

+ func (s StringSchema) Serialize(d any) (any, error)

+ func (s StringSchema) SerializeType(data string) (any, error)

+ func (s StringSchema) TypeID() TypeID

+ func (s StringSchema) Unserialize(data any) (any, error)

+ func (s StringSchema) UnserializeType(data any) (string, error)

+ func (s StringSchema) Validate(d any) error

+ func (s StringSchema) ValidateType(data string) error

+ type Type interface

+ TypeID func() TypeID

+ type TypeID string

+ const TypeIDAny

+ const TypeIDBool

+ const TypeIDFloat

+ const TypeIDInt

+ const TypeIDIntEnum

+ const TypeIDList

+ const TypeIDMap

+ const TypeIDObject

+ const TypeIDOneOfInt

+ const TypeIDOneOfString

+ const TypeIDPattern

+ const TypeIDRef

+ const TypeIDScope

+ const TypeIDString

+ const TypeIDStringEnum

+ type TypedList interface

+ type TypedListSchema struct

+ func NewTypedListSchema(items TypedType[UnserializedType], min *int64, max *int64) *TypedListSchema[UnserializedType, TypedType[UnserializedType]]

+ func (t TypedListSchema[UnserializedType, ItemType]) SerializeType(data []UnserializedType) (any, error)

+ func (t TypedListSchema[UnserializedType, ItemType]) UnserializeType(data any) (result []UnserializedType, err error)

+ func (t TypedListSchema[UnserializedType, ItemType]) ValidateType(data []UnserializedType) error

+ type TypedMap interface

+ type TypedMapSchema struct

+ func NewTypedMapSchema(keys TypedType[KeyType], values TypedType[ValueType], min *int64, max *int64) *TypedMapSchema[KeyType, ValueType]

+ func (m TypedMapSchema[KeyType, ValueType]) SerializeType(data map[KeyType]ValueType) (any, error)

+ func (m TypedMapSchema[KeyType, ValueType]) UnserializeType(data any) (result map[KeyType]ValueType, err error)

+ func (m TypedMapSchema[KeyType, ValueType]) ValidateType(data map[KeyType]ValueType) error

+ type TypedObject interface

+ Any func() TypedObject[any]

+ type TypedObjectSchema struct

+ func NewTypedObject(id string, properties map[string]*PropertySchema) *TypedObjectSchema[T]

+ func (t TypedObjectSchema[T]) Any() TypedObject[any]

+ func (t TypedObjectSchema[T]) SerializeType(data T) (any, error)

+ func (t TypedObjectSchema[T]) UnserializeType(data any) (T, error)

+ func (t TypedObjectSchema[T]) ValidateType(data T) error

+ type TypedScopeSchema struct

+ func NewTypedScopeSchema(rootObject *ObjectSchema, objects ...*ObjectSchema) *TypedScopeSchema[T]

+ func (t TypedScopeSchema[T]) SerializeType(data T) (any, error)

+ func (t TypedScopeSchema[T]) UnserializeType(data any) (result T, err error)

+ func (t TypedScopeSchema[T]) ValidateType(data T) error

+ type TypedType interface

+ SerializeType func(data T) (any, error)

+ UnserializeType func(data any) (T, error)

+ ValidateType func(data T) error

+ type Unit interface

+ FormatLongFloat func(amount float64, displayZero bool) string

+ FormatLongInt func(amount int64, displayZero bool) string

+ FormatShortFloat func(amount float64, displayZero bool) string

+ FormatShortInt func(amount int64, displayZero bool) string

+ NameLongPlural func() string

+ NameLongSingular func() string

+ NameShortPlural func() string

+ NameShortSingular func() string

+ type UnitDefinition struct

+ NameLongPluralValue string

+ NameLongSingularValue string

+ NameShortPluralValue string

+ NameShortSingularValue string

+ func NewUnit(nameSortSingular string, nameShortPlural string, nameLongSingular string, ...) *UnitDefinition

+ func (u *UnitDefinition) FormatLongFloat(amount float64, displayZero bool) string

+ func (u *UnitDefinition) FormatLongInt(amount int64, displayZero bool) string

+ func (u *UnitDefinition) FormatShortFloat(amount float64, displayZero bool) string

+ func (u *UnitDefinition) FormatShortInt(amount int64, displayZero bool) string

+ func (u *UnitDefinition) NameLongPlural() string

+ func (u *UnitDefinition) NameLongSingular() string

+ func (u *UnitDefinition) NameShortPlural() string

+ func (u *UnitDefinition) NameShortSingular() string

+ type UnitParseError struct

+ Cause error

+ Message string

+ func (u UnitParseError) Error() string

+ func (u UnitParseError) Unwrap() error

+ type Units interface

+ BaseUnit func() *UnitDefinition

+ FormatLongFloat func(data float64) string

+ FormatLongInt func(data int64) string

+ FormatShortFloat func(data float64) string

+ FormatShortInt func(data int64) string

+ Multipliers func() map[int64]*UnitDefinition

+ ParseFloat func(data string) (float64, error)

+ ParseInt func(data string) (int64, error)

+ type UnitsDefinition struct

+ BaseUnitValue *UnitDefinition

+ MultipliersValue map[int64]*UnitDefinition

+ func NewUnits(baseUnit *UnitDefinition, multipliers map[int64]*UnitDefinition) *UnitsDefinition

+ func (u *UnitsDefinition) BaseUnit() *UnitDefinition

+ func (u *UnitsDefinition) FormatLongFloat(data float64) string

+ func (u *UnitsDefinition) FormatLongInt(data int64) string

+ func (u *UnitsDefinition) FormatShortFloat(data float64) string

+ func (u *UnitsDefinition) FormatShortInt(data int64) string

+ func (u *UnitsDefinition) Multipliers() map[int64]*UnitDefinition

+ func (u *UnitsDefinition) ParseFloat(data string) (float64, error)

+ func (u *UnitsDefinition) ParseInt(data string) (int64, error)

+ type UntypedMap = Map[Type, Type]

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL