model

type AspectListOptions struct {
	Ids    []string //filter; ignores limit/offset if Ids != nil; ignored if Ids == nil; Ids == []string{} will return an empty list;
	Search string
	Limit  int64  //default 100, will be ignored if 'ids' is set (Ids != nil)
	Offset int64  //default 0, will be ignored if 'ids' is set (Ids != nil)
	SortBy string //default name.asc
}

type AuthAction = models.PermissionFlag

type CharacteristicListOptions struct {
	Ids    []string //filter; ignores limit/offset if Ids != nil; ignored if Ids == nil; Ids == []string{} will return an empty list;
	Search string
	Limit  int64  //default 100, will be ignored if 'ids' is set (Ids != nil)
	Offset int64  //default 0, will be ignored if 'ids' is set (Ids != nil)
	SortBy string //default name.asc
}

type ConceptListOptions struct {
	Ids    []string //filter; ignores limit/offset if Ids != nil; ignored if Ids == nil; Ids == []string{} will return an empty list;
	Search string
	Limit  int64  //default 100, will be ignored if 'ids' is set (Ids != nil)
	Offset int64  //default 0, will be ignored if 'ids' is set (Ids != nil)
	SortBy string //default name.asc
}

type Configurable struct {
	Path             string            `json:"path"`
	CharacteristicId string            `json:"characteristic_id"`
	AspectNode       models.AspectNode `json:"aspect_node"`
	FunctionId       string            `json:"function_id"`
	Value            interface{}       `json:"value,omitempty"`
	Type             models.Type       `json:"type,omitempty"`
}

type DeviceClassListOptions struct {
	Ids                         []string //filter; ignores limit/offset if Ids != nil; ignored if Ids == nil; Ids == []string{} will return an empty list;
	UsedWithControllingFunction bool     //filter; ignore if false; if true, only return device-classes that are used with a controlling function
	Search                      string
	Limit                       int64  //default 100, will be ignored if 'ids' is set (Ids != nil)
	Offset                      int64  //default 0, will be ignored if 'ids' is set (Ids != nil)
	SortBy                      string //default name.asc
}

type DeviceGroupListOptions struct {
	Ids                            []string //filter; ignores limit/offset if Ids != nil; ignored if Ids == nil; Ids == []string{} will return an empty list;
	DeviceIds                      []string //filter; find device-groups with any of the listed devices
	Search                         string
	Limit                          int64                 //default 100, will be ignored if 'ids' is set (Ids != nil)
	Offset                         int64                 //default 0, will be ignored if 'ids' is set (Ids != nil)
	SortBy                         string                //default name.asc
	AttributeKeys                  []string              //filter; ignored if nil; AttributeKeys and AttributeValues are independently evaluated, needs local filtering if a search like "attr1"="value1" is needed
	AttributeValues                []string              //filter; ignored if nil; AttributeKeys and AttributeValues are independently evaluated, needs local filtering if a search like "attr1"="value1" is needed
	Criteria                       []FilterCriteria      //filter; ignored if nil
	Permission                     models.PermissionFlag //defaults to read
	IgnoreGenerated                bool                  //remove generated groups from result
	FilterGenericDuplicateCriteria bool
}

type DeviceListOptions struct {
	Ids                      []string                //filter; ignores limit/offset if Ids != nil; ignored if Ids == nil; Ids == []string{} will return an empty list;
	LocalIds                 []string                //filter; in combination with owner; fills ids filter; comma-seperated list; ignored if LocalIds == nil; LocalIds == []string{} will return an empty list;
	Owner                    string                  //used in combination with local_ids to fill ids filter; defaults to requesting user
	DeviceTypeIds            []string                //filter; ignored if DeviceTypeIds == nil; DeviceTypeIds == []string{} will return an empty list;
	ConnectionState          *models.ConnectionState //filter
	Search                   string
	Limit                    int64                 //default 100, will be ignored if 'ids' is set (Ids != nil)
	Offset                   int64                 //default 0, will be ignored if 'ids' is set (Ids != nil)
	SortBy                   string                //default name.asc
	Permission               models.PermissionFlag //defaults to read
	AttributeKeys            []string              //filter; ignored if nil; AttributeKeys and AttributeValues are independently evaluated, needs local filtering if a search like "attr1"="value1" is needed
	AttributeValues          []string              //filter; ignored if nil; AttributeKeys and AttributeValues are independently evaluated, needs local filtering if a search like "attr1"="value1" is needed
	DeviceAttributeBlacklist []models.Attribute    //filter; attribute value and origin will only be checked if set, otherwise all values or origins will be blacklisted
}

type DeviceTypeCriteria struct {
	IsIdModified          bool        `json:"is_id_modified"`
	PureDeviceTypeId      string      `json:"pure_device_type_id"`
	DeviceTypeId          string      `json:"device_type_id"`
	ServiceId             string      `json:"service_id"`
	ContentVariableId     string      `json:"content_variable_id"`
	ContentVariablePath   string      `json:"content_variable_path"`
	FunctionId            string      `json:"function_id"`
	Interaction           string      `json:"interaction"`
	IsControllingFunction bool        `json:"controlling_function"`
	DeviceClassId         string      `json:"device_class_id"`
	AspectId              string      `json:"aspect_id"`
	CharacteristicId      string      `json:"characteristic_id"`
	IsVoid                bool        `json:"is_void"`
	Value                 interface{} `json:"value"`
	Type                  models.Type `json:"type"`
	IsLeaf                bool        `json:"is_leaf"`
	IsInput               bool        `json:"is_input"`
}

type DeviceTypeListOptions struct {
	Ids              []string
	Search           string
	Limit            int64            //default 100, will be ignored if 'ids' is set (Ids != nil)
	Offset           int64            //default 0, will be ignored if 'ids' is set (Ids != nil)
	SortBy           string           //default name.asc
	AttributeKeys    []string         //filter; ignored if nil; AttributeKeys and AttributeValues are independently evaluated, needs local filtering if a search like "attr1"="value1" is needed
	AttributeValues  []string         //filter; ignored if nil; AttributeKeys and AttributeValues are independently evaluated, needs local filtering if a search like "attr1"="value1" is needed
	Criteria         []FilterCriteria //filter; ignored if nil
	ProtocolIds      []string
	IncludeModified  bool
	IgnoreUnmodified bool
}

type DeviceTypeReference struct {
	Id     string             `json:"id"`
	Name   string             `json:"name"`
	UsedIn []ServiceReference `json:"used_in,omitempty"`
}

type DeviceTypeSelectable struct {
	DeviceTypeId       string                         `json:"device_type_id,omitempty"`
	Services           []models.Service               `json:"services,omitempty"`
	ServicePathOptions map[string][]ServicePathOption `json:"service_path_options,omitempty"`
}

type DeviceTypeUpdateOptions struct {
	DistinctAttributes []string
}

type DeviceUpdateOptions struct {
	UpdateOnlySameOriginAttributes []string
}

type DeviceWithConnectionState struct {
	models.Device   `bson:",inline"`
	ConnectionState models.ConnectionState `json:"connection_state" bson:"connection_state"`
	DisplayName     string                 `json:"display_name" bson:"display_name"`
}

type ExtendedDeviceListOptions struct {
	Ids                      []string                //filter; ignores limit/offset if Ids != nil; ignored if Ids == nil; Ids == []string{} will return an empty list;
	LocalIds                 []string                //filter; in combination with owner; fills ids filter; comma-seperated list; ignored if LocalIds == nil; LocalIds == []string{} will return an empty list;
	Owner                    string                  //used in combination with local_ids to fill ids filter; defaults to requesting user
	DeviceTypeIds            []string                //filter; ignored if DeviceTypeIds == nil; DeviceTypeIds == []string{} will return an empty list;
	ConnectionState          *models.ConnectionState //filter
	Search                   string
	Limit                    int64                 //default 100, will be ignored if 'ids' is set (Ids != nil)
	Offset                   int64                 //default 0, will be ignored if 'ids' is set (Ids != nil)
	SortBy                   string                //default name.asc
	Permission               models.PermissionFlag //defaults to read
	AttributeKeys            []string              //filter; ignored if nil; AttributeKeys and AttributeValues are independently evaluated, needs local filtering if a search like "attr1"="value1" is needed
	AttributeValues          []string              //filter; ignored if nil; AttributeKeys and AttributeValues are independently evaluated, needs local filtering if a search like "attr1"="value1" is needed
	FullDt                   bool                  //if true, result contains full device-type
	DeviceAttributeBlacklist []models.Attribute    //filter; attribute value and origin will only be checked if set, otherwise all values or origins will be blacklisted
}

type FilterCriteria struct {
	Interaction   models.Interaction `json:"interaction"`
	FunctionId    string             `json:"function_id"`
	DeviceClassId string             `json:"device_class_id"`
	AspectId      string             `json:"aspect_id"`
}

type FunctionList struct {
	Functions  []models.Function `json:"functions"`
	TotalCount int               `json:"total_count"`
}

type FunctionListOptions struct {
	Ids     []string //filter; ignores limit/offset if Ids != nil; ignored if Ids == nil; Ids == []string{} will return an empty list;
	RdfType string   // model.SES_ONTOLOGY_CONTROLLING_FUNCTION || model.SES_ONTOLOGY_MEASURING_FUNCTION
	Search  string
	Limit   int64  //default 100, will be ignored if 'ids' is set (Ids != nil)
	Offset  int64  //default 0, will be ignored if 'ids' is set (Ids != nil)
	SortBy  string //default name.asc
}

type HubListOptions struct {
	Ids             []string                ///filter; ignores limit/offset if Ids != nil; ignored if Ids == nil; Ids == []string{} will return an empty list;
	ConnectionState *models.ConnectionState //filter
	Search          string
	Limit           int64                 //default 100, will be ignored if 'ids' is set (Ids != nil)
	Offset          int64                 //default 0, will be ignored if 'ids' is set (Ids != nil)
	SortBy          string                //default name.asc
	Permission      models.PermissionFlag //defaults to read
	LocalDeviceId   string                //filter; list hubs if they contain the device-id
	OwnerId         string                //only used in combination with LocalDeviceId; defaults to requesting user
}

type HubWithConnectionState struct {
	models.Hub      `bson:",inline"`
	ConnectionState models.ConnectionState `json:"connection_state"`
}

type ImportExport struct {
	Protocols       []models.Protocol       `json:"protocols,omitempty"`
	Functions       []models.Function       `json:"functions,omitempty"`
	Aspects         []models.Aspect         `json:"aspects,omitempty"`
	Concepts        []models.Concept        `json:"concepts,omitempty"`
	Characteristics []models.Characteristic `json:"characteristics,omitempty"`
	DeviceClasses   []models.DeviceClass    `json:"device_classes,omitempty"`
	DeviceTypes     []models.DeviceType     `json:"device_types,omitempty"`

	//include_owned_information == true
	Devices      []models.Device        `json:"devices,omitempty"`
	DeviceGroups []models.DeviceGroup   `json:"device_groups,omitempty"`
	Hubs         []models.Hub           `json:"hubs,omitempty"`
	Locations    []models.Location      `json:"locations,omitempty"`
	Permissions  []permissions.Resource `json:"permissions,omitempty"`
}

type ImportExportOptions struct {
	IncludeOwnedInformation bool     `json:"include_owned_information"`
	FilterResourceTypes     []string `json:"filter_resource_types,omitempty"` //ref resource types-like 'device-types' similar to http-endpoints; null->all; []->none
	FilterIds               []string `json:"filter_ids,omitempty"`            //ref ids of any resource-type; null->all; []->none
}

type ImportFromOptions struct {
	FilterResourceTypes    []string `json:"filter_resource_types,omitempty"` //ref resource types-like 'device-types' similar to http-endpoints; null->all; []->none
	FilterIds              []string `json:"filter_ids,omitempty"`            //ref ids of any resource-type; null->all; []->none
	RemoteDeviceRepository string   `json:"remote_device_repository"`        //address of a remote device-repository, where the data is imported from
	RemoteAuthToken        string   `json:"remote_auth_token"`               //auth token used for requests to the remote device-repository
}

type LocationListOptions struct {
	Ids        []string //filter; ignores limit/offset if Ids != nil; ignored if Ids == nil; Ids == []string{} will return an empty list;
	Search     string
	Limit      int64                 //default 100, will be ignored if 'ids' is set (Ids != nil)
	Offset     int64                 //default 0, will be ignored if 'ids' is set (Ids != nil)
	SortBy     string                //default name.asc
	Permission models.PermissionFlag //defaults to read
}

type RefInDeviceTypeResponseElement struct {
	Count  int                   `json:"count"`
	UsedIn []DeviceTypeReference `json:"used_in"`
}

type ResourceRights struct {
	UserRights           map[string]Right `json:"user_rights"`
	GroupRights          map[string]Right `json:"group_rights"`
	KeycloakGroupsRights map[string]Right `json:"keycloak_groups_rights"`
}

type Right struct {
	Read         bool `json:"read"`
	Write        bool `json:"write"`
	Execute      bool `json:"execute"`
	Administrate bool `json:"administrate"`
}

type ServicePathOption struct {
	ServiceId             string             `json:"service_id"`
	Path                  string             `json:"path"`
	CharacteristicId      string             `json:"characteristic_id"`
	AspectNode            models.AspectNode  `json:"aspect_node"`
	FunctionId            string             `json:"function_id"`
	IsVoid                bool               `json:"is_void"`
	Value                 interface{}        `json:"value,omitempty"`
	IsControllingFunction bool               `json:"is_controlling_function"`
	Configurables         []Configurable     `json:"configurables,omitempty"`
	Type                  models.Type        `json:"type,omitempty"`
	Interaction           models.Interaction `json:"interaction"`
}

type ServiceReference struct {
	Id     string              `json:"id"`
	Name   string              `json:"name"`
	UsedIn []VariableReference `json:"used_in,omitempty"`
}

type TotalCount struct {
	TotalCount int `json:"total_count"`
}

type UsedInDeviceTypeQuery struct {
	Resource string                    `json:"resource"`           // "aspects"|"functions"|"device-classes"|"characteristics"
	With     string                    `json:"with,omitempty"`     // ""|"device-type"|"service"|"variable": selects how deep the result "used_in" is set; defaults to "device-type"
	CountBy  string                    `json:"count_by,omitempty"` // ""|"device-type"|"service"|"variable": selects what is counted; defaults to "device-type"
	Ids      []UsedInDeviceTypeQueryId `json:"ids"`
}

type UsedInDeviceTypeQueryId = string

type UsedInDeviceTypeResponse = map[UsedInDeviceTypeQueryId]RefInDeviceTypeResponseElement

type ValidationOptions struct {
	AllowNoneLeafAspectNodesInDeviceTypes *bool
}

type VariableReference struct {
	Id   string `json:"id"`
	Path string `json:"path"`
}