coremlcompiler

type Argument struct {
	Bindings []Binding // field 1
}

type ArrayDataType int32

type ArrayFeatureType struct {
	Shape    []int64
	DataType ArrayDataType
	// contains filtered or unexported fields
}

type Binding struct {
	Name  string // field 1 (oneof)
	Value *Value // field 2 (oneof)
}

type BlobDataType uint32

type BlobEntry struct {
	DType BlobDataType
	Data  []byte

	// NumElements is the logical element count. It is required for sub-byte
	// element types, where the trailing partial byte must be reported in the
	// metadata's padding_size_in_bits; it is ignored for byte-sized types.
	NumElements int
}

type BlobFileValue struct {
	FileName string // field 1
	Offset   uint64 // field 2
}

type Block struct {
	Inputs     []NamedValueType // field 1
	Outputs    []string         // field 2
	Operations []*Operation     // field 3
}

type ColorSpace int32

type CoreMLModel struct{}

type DataType int32

type DictionaryFeatureType struct {
	KeyType string
}

type DictionaryMapEntry struct {
	Key   *Value
	Value *Value
}

type DictionaryType struct {
	KeyType   *ValueType // field 1
	ValueType *ValueType // field 2
}

type DictionaryValue struct {
	Entries []DictionaryMapEntry
}

type Dimension struct {
	Constant uint64 // from ConstantDimension.size (field 1.1)
	Unknown  bool   // true if UnknownDimension
	Variadic bool   // true if UnknownDimension.variadic is true
}

type FeatureDescription struct {
	Name string       // field 1
	Type *FeatureType // field 3
	// contains filtered or unexported fields
}

type FeatureType struct {
	MultiArrayType *ArrayFeatureType
	ImageType      *ImageFeatureType
	StringType     bool
	Int64Type      bool
	DoubleType     bool
	DictionaryType *DictionaryFeatureType
	SequenceType   *SequenceFeatureType
	StateArrayType *ArrayFeatureType
	IsOptional     bool
	// contains filtered or unexported fields
}

type Function struct {
	Inputs               []NamedValueType  // field 1
	OpSet                string            // field 2
	BlockSpecializations map[string]*Block // field 3
	Attributes           map[string]*Value // field 4
}

type FunctionDescription struct {
	Name    string               // field 1
	Inputs  []FeatureDescription // field 2
	Outputs []FeatureDescription // field 3
	States  []FeatureDescription // field 6
	// contains filtered or unexported fields
}

type ImageFeatureType struct {
	Width      int64      // field 1
	Height     int64      // field 2
	ColorSpace ColorSpace // field 3
	// contains filtered or unexported fields
}

type ImmediateValue struct {
	// Exactly one of these is set.
	Tensor     *TensorValue     // field 1
	Tuple      *TupleValue      // field 2
	List       *ListValue       // field 3
	Dictionary *DictionaryValue // field 4
}

type ListType struct {
	ElementType *ValueType // field 1
	Length      int64      // field 2
}

type ListValue struct {
	Values []*Value // field 1
}

type Model struct {
	SpecVersion int32            // field 1
	Description ModelDescription // field 2
	MLProgram   *Program         // field 502 (oneof)
	// contains filtered or unexported fields
}

type ModelDescription struct {
	// Functions and DefaultFunctionName describe multi-function models.
	// When Functions is non-empty the model-level Inputs/Outputs/States
	// must be empty: the proto reserves them for the single-function case.
	Functions           []FunctionDescription // field 20
	DefaultFunctionName string                // field 21

	Inputs  []FeatureDescription // field 1
	Outputs []FeatureDescription // field 10
	States  []FeatureDescription // field 13

	Metadata *ModelMetadata // field 100
	// contains filtered or unexported fields
}

type ModelMetadata struct {
	ShortDescription string            // field 1
	VersionString    string            // field 2
	Author           string            // field 3
	License          string            // field 4
	UserDefined      map[string]string // field 100
}

type NamedValueType struct {
	Name string     // field 1
	Type *ValueType // field 2
}

type Operation struct {
	Type       string               // field 1
	Inputs     map[string]*Argument // field 2
	Outputs    []NamedValueType     // field 3
	Blocks     []*Block             // field 4
	Attributes map[string]*Value    // field 5
}

type PredictInput struct {
	Name    string
	Data    unsafe.Pointer
	Shape   []int
	Strides []int
	DType   coreml.MLMultiArrayDataType
}

type PredictOutput struct {
	Bytes []byte // copied from CoreML output buffer
	Shape []int
	DType coreml.MLMultiArrayDataType
}

type Program struct {
	Version    int64                // field 1
	Functions  map[string]*Function // field 2
	Attributes map[string]*Value    // field 4
}

type SequenceFeatureType struct {
	ElementType *FeatureType
}

type StateType struct {
	WrappedType *ValueType // field 1
}

type TensorType struct {
	DataType   DataType    // field 1
	Rank       int64       // field 2
	Dimensions []Dimension // field 3
}

type TensorValue struct {
	// Exactly one of these is set.
	Floats  []float32 // field 1
	Ints    []int32   // field 2
	Bools   []bool    // field 3
	Strings []string  // field 4
	Longs   []int64   // field 5
	Doubles []float64 // field 6
	Bytes   []byte    // field 7
}

type TensorValueField int

type TupleType struct {
	Types []*ValueType // field 1
}

type TupleValue struct {
	Values []*Value // field 1
}

type Value struct {
	Type *ValueType // field 2

	// Exactly one of these is set.
	Immediate *ImmediateValue // field 3
	BlobFile  *BlobFileValue  // field 5
}

type ValueType struct {
	// Exactly one of these is set.
	TensorType     *TensorType     // field 1
	ListType       *ListType       // field 2
	TupleType      *TupleType      // field 3
	DictionaryType *DictionaryType // field 4
	StateType      *StateType      // field 5
}