event_notifications

package
v0.0.0-...-50def94 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 2, 2023 License: Apache-2.0 Imports: 6 Imported by: 0

Documentation

Overview

This module contains conceptual YANG specifications for NETCONF Event Notifications.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Active 

type Active struct {
}

func (Active) String 

func (id Active) String() string

type CreateSubscription 

type CreateSubscription struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	Input CreateSubscription_Input
}

CreateSubscription This operation initiates an event notification subscription that will send asynchronous event notifications to the initiator of the command until the association terminates. It is not possible to modify or delete a subscription that was created using this operation. It is included for reasons of backward compatibility with RFC 5277 implementations.

func (*CreateSubscription) GetEntityData 

func (createSubscription *CreateSubscription) GetEntityData() *types.CommonEntityData

type CreateSubscription_Input 

type CreateSubscription_Input struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Indicates which stream of events is of interest. If not present, events in
	// the default NETCONF stream will be sent. The type is one of the following:
	// NETCONFCustomStreamYangPush. The default value is NETCONF.
	Stream interface{}

	// The type of encoding for the subscribed data. Default is XML. The type is
	// one of the following: EncodeJsonEncodeXml. The default value is encode-xml.
	Encoding interface{}

	// Filter per RFC 5277. Notification filter. If a filter element is specified
	// to look for data of a particular value, and the data item is not present
	// within a particular event notification for its value to be checked against,
	// the notification will be filtered out. For example, if one were to check
	// for 'severity=critical' in a configuration event notification where this
	// field was not supported, then the notification would be filtered out. For
	// subtree filtering, a non-empty node set means that the filter matches.  For
	// XPath filtering, the mechanisms defined in [XPATH] should be used to
	// convert the returned value to boolean. The type is string.
	Filter interface{}

	// Used to trigger the replay feature and indicate that the replay should
	// start at the time specified.  If <startTime> is not present, this is not a
	// replay subscription.  It is not valid to specify start times that are later
	// than the current time.  If the <startTime> specified is earlier than the
	// log can support, the replay will begin with the earliest available
	// notification.  This parameter is of type dateTime and compliant to
	// [RFC3339].  Implementations must support time zones. The type is string
	// with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	StartTime interface{}

	// Used with the optional replay feature to indicate the newest notifications
	// of interest.  If <stopTime> is not present, the notifications will continue
	// until the subscription is terminated.  Must be used with and be later than
	// <startTime>.  Values of <stopTime> in the future are valid.  This parameter
	// is of type dateTime and compliant to [RFC3339].  Implementations must
	// support time zones. The type is string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	StopTime interface{}
}

CreateSubscription_Input

func (*CreateSubscription_Input) GetEntityData 

func (input *CreateSubscription_Input) GetEntityData() *types.CommonEntityData

type DeleteSubscription 

type DeleteSubscription struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	Input DeleteSubscription_Input

	Output DeleteSubscription_Output
}

DeleteSubscription This RPC allows a subscriber to delete a subscription that was previously created using establish-subscription.

func (*DeleteSubscription) GetEntityData 

func (deleteSubscription *DeleteSubscription) GetEntityData() *types.CommonEntityData

type DeleteSubscription_Input 

type DeleteSubscription_Input struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Identifier of the subscription that is to be deleted. Only subscriptions
	// that were created using establish-subscription can be deleted via this RPC.
	// The type is interface{} with range: 0..4294967295. This attribute is
	// mandatory.
	SubscriptionId interface{}
}

DeleteSubscription_Input

func (*DeleteSubscription_Input) GetEntityData 

func (input *DeleteSubscription_Input) GetEntityData() *types.CommonEntityData

type DeleteSubscription_Output 

type DeleteSubscription_Output struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Indicates whether subscription is operational, or if a problem was
	// encountered. The type is one of the following:
	// ErrorErrorNoSuchOptionErrorNoSuchSubscriptionErrorOtherErrorInsufficientResourcesErrorConfiguredSubscriptionErrorDataNotAuthorizedOk.
	// This attribute is mandatory.
	SubscriptionResult interface{}
}

DeleteSubscription_Output

func (*DeleteSubscription_Output) GetEntityData 

func (output *DeleteSubscription_Output) GetEntityData() *types.CommonEntityData

type EncodeJson 

type EncodeJson struct {
}

func (EncodeJson) String 

func (id EncodeJson) String() string

type EncodeXml 

type EncodeXml struct {
}

func (EncodeXml) String 

func (id EncodeXml) String() string

type Encodings 

type Encodings struct {
}

func (Encodings) String 

func (id Encodings) String() string

type Error 

type Error struct {
}

func (Error) String 

func (id Error) String() string

type ErrorConfiguredSubscription 

type ErrorConfiguredSubscription struct {
}

func (ErrorConfiguredSubscription) String 

func (id ErrorConfiguredSubscription) String() string

type ErrorInsufficientResources 

type ErrorInsufficientResources struct {
}

func (ErrorInsufficientResources) String 

func (id ErrorInsufficientResources) String() string

type ErrorNoSuchOption 

type ErrorNoSuchOption struct {
}

func (ErrorNoSuchOption) String 

func (id ErrorNoSuchOption) String() string

type ErrorNoSuchSubscription 

type ErrorNoSuchSubscription struct {
}

func (ErrorNoSuchSubscription) String 

func (id ErrorNoSuchSubscription) String() string

type ErrorOther 

type ErrorOther struct {
}

func (ErrorOther) String 

func (id ErrorOther) String() string

type EstablishSubscription 

type EstablishSubscription struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	Input EstablishSubscription_Input

	Output EstablishSubscription_Output
}

EstablishSubscription This RPC allows a subscriber to create (and possibly negotiate) a subscription on its own behalf. If successful, the subscription remains in effect for the duration of the subscriber's association with the publisher, or until the subscription is terminated by virtue of a delete-subscription request. In case an error (as indicated by subscription-result) is returned, the subscription is not created. In that case, the RPC output MAY include suggested parameter settings that would have a high likelihood of succeeding in a subsequent establish-subscription request.

func (*EstablishSubscription) GetEntityData 

func (establishSubscription *EstablishSubscription) GetEntityData() *types.CommonEntityData

type EstablishSubscription_Input 

type EstablishSubscription_Input struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Indicates which stream of events is of interest. If not present, events in
	// the default NETCONF stream will be sent. The type is one of the following:
	// NETCONFCustomStreamYangPush.
	Stream interface{}

	// The type of encoding for the subscribed data. Default is XML. The type is
	// one of the following: EncodeJsonEncodeXml. The default value is encode-xml.
	Encoding interface{}

	// Filter per RFC 5277. Notification filter. If a filter element is specified
	// to look for data of a particular value, and the data item is not present
	// within a particular event notification for its value to be checked against,
	// the notification will be filtered out. For example, if one were to check
	// for 'severity=critical' in a configuration event notification where this
	// field was not supported, then the notification would be filtered out. For
	// subtree filtering, a non-empty node set means that the filter matches.  For
	// XPath filtering, the mechanisms defined in [XPATH] should be used to
	// convert the returned value to boolean. The type is string.
	Filter interface{}

	// References filter which is associated with the subscription. The type is
	// string with range: 0..4294967295. Refers to
	// event_notifications.Filters_Filter_FilterId
	FilterRef interface{}

	// Subtree-filter used to specify the data nodes targeted for subscription
	// within a subtree, or subtrees, of a conceptual YANG datastore.  Objects
	// matching the filter criteria will traverse the filter. The syntax follows
	// the subtree filter syntax specified in RFC 6241, section 6. The type is
	// string.
	SubtreeFilter interface{}

	// Xpath defining the data items of interest. The type is string.
	XpathFilter interface{}

	// Used to trigger the replay feature and indicate that the replay should
	// start at the time specified.  If <startTime> is not present, this is not a
	// replay subscription.  It is not valid to specify start times that are later
	// than the current time.  If the <startTime> specified is earlier than the
	// log can support, the replay will begin with the earliest available
	// notification.  This parameter is of type dateTime and compliant to
	// [RFC3339].  Implementations must support time zones. The type is string
	// with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	StartTime interface{}

	// Used with the optional replay feature to indicate the newest notifications
	// of interest.  If <stopTime> is not present, the notifications will continue
	// until the subscription is terminated.  Must be used with and be later than
	// <startTime>.  Values of <stopTime> in the future are valid.  This parameter
	// is of type dateTime and compliant to [RFC3339].  Implementations must
	// support time zones. The type is string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	StopTime interface{}

	// Duration of time which should occur between periodic push updates.  Where
	// the anchor of a start-time is available, the push will include the objects
	// and their values which exist at an exact multiple of timeticks aligning to
	// this start-time anchor. The type is interface{} with range: 0..4294967295.
	// This attribute is mandatory.
	Period interface{}

	// Designates a timestamp from which the series of periodic push updates are
	// computed. The next update will take place at the next period interval from
	// the anchor time.  For example, for an anchor time at the top of a minute
	// and a period interval of a minute, the next update will be sent at the top
	// of the next minute. The type is string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	AnchorTime interface{}

	// This leaf acts as a flag that determines behavior at the start of the
	// subscription.  When present, synchronization of state at the beginning of
	// the subscription is outside the scope of the subscription. Only updates
	// about changes that are observed from the start time, i.e. only
	// push-change-update notifications are sent. When absent (default behavior),
	// in order to facilitate a receiver's synchronization, a full update is sent
	// when the subscription starts using a push-update notification, just like in
	// the case of a periodic subscription.  After that, push-change-update
	// notifications only are sent unless the Publisher chooses to resynch the
	// subscription again. The type is interface{}.
	NoSynchOnStart interface{}

	// Minimum amount of time that needs to have passed since the last time an
	// update was provided. The type is interface{} with range: 0..4294967295.
	// This attribute is mandatory.
	DampeningPeriod interface{}

	// Use to restrict which changes trigger an update. For example, if modify is
	// excluded, only creation and deletion of objects is reported. The type is
	// slice of ChangeType.
	ExcludedChange []interface{}

	// The push update's IP packet transport priority. This is made visible across
	// network hops to receiver. The transport priority is shared for all
	// receivers of a given subscription. The type is interface{} with range:
	// 0..63. The default value is 0.
	Dscp interface{}

	// Relative priority for a subscription.   Allows an underlying transport
	// layer perform informed load balance allocations between various
	// subscriptions. The type is interface{} with range: 0..255.
	SubscriptionPriority interface{}

	// Provides the Subscription ID of a parent subscription without which this
	// subscription should not exist. In other words, there is no reason to stream
	// these objects if another subscription is missing. The type is string.
	SubscriptionDependency interface{}
}

EstablishSubscription_Input

func (*EstablishSubscription_Input) GetEntityData 

func (input *EstablishSubscription_Input) GetEntityData() *types.CommonEntityData

type EstablishSubscription_Output 

type EstablishSubscription_Output struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Indicates whether subscription is operational, or if a problem was
	// encountered. The type is one of the following:
	// ErrorErrorNoSuchOptionErrorNoSuchSubscriptionErrorOtherErrorInsufficientResourcesErrorConfiguredSubscriptionErrorDataNotAuthorizedOk.
	// This attribute is mandatory.
	SubscriptionResult interface{}

	// Identifier used for this subscription. The type is interface{} with range:
	// 0..4294967295. This attribute is mandatory.
	SubscriptionId interface{}

	// Indicates which stream of events is of interest. If not present, events in
	// the default NETCONF stream will be sent. The type is one of the following:
	// NETCONFCustomStreamYangPush.
	Stream interface{}

	// The type of encoding for the subscribed data. Default is XML. The type is
	// one of the following: EncodeJsonEncodeXml. The default value is encode-xml.
	Encoding interface{}

	// Filter per RFC 5277. Notification filter. If a filter element is specified
	// to look for data of a particular value, and the data item is not present
	// within a particular event notification for its value to be checked against,
	// the notification will be filtered out. For example, if one were to check
	// for 'severity=critical' in a configuration event notification where this
	// field was not supported, then the notification would be filtered out. For
	// subtree filtering, a non-empty node set means that the filter matches.  For
	// XPath filtering, the mechanisms defined in [XPATH] should be used to
	// convert the returned value to boolean. The type is string.
	Filter interface{}

	// References filter which is associated with the subscription. The type is
	// string with range: 0..4294967295. Refers to
	// event_notifications.Filters_Filter_FilterId
	FilterRef interface{}

	// Subtree-filter used to specify the data nodes targeted for subscription
	// within a subtree, or subtrees, of a conceptual YANG datastore.  Objects
	// matching the filter criteria will traverse the filter. The syntax follows
	// the subtree filter syntax specified in RFC 6241, section 6. The type is
	// string.
	SubtreeFilter interface{}

	// Xpath defining the data items of interest. The type is string.
	XpathFilter interface{}

	// Used to trigger the replay feature and indicate that the replay should
	// start at the time specified.  If <startTime> is not present, this is not a
	// replay subscription.  It is not valid to specify start times that are later
	// than the current time.  If the <startTime> specified is earlier than the
	// log can support, the replay will begin with the earliest available
	// notification.  This parameter is of type dateTime and compliant to
	// [RFC3339].  Implementations must support time zones. The type is string
	// with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	StartTime interface{}

	// Used with the optional replay feature to indicate the newest notifications
	// of interest.  If <stopTime> is not present, the notifications will continue
	// until the subscription is terminated.  Must be used with and be later than
	// <startTime>.  Values of <stopTime> in the future are valid.  This parameter
	// is of type dateTime and compliant to [RFC3339].  Implementations must
	// support time zones. The type is string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	StopTime interface{}

	// Duration of time which should occur between periodic push updates.  Where
	// the anchor of a start-time is available, the push will include the objects
	// and their values which exist at an exact multiple of timeticks aligning to
	// this start-time anchor. The type is interface{} with range: 0..4294967295.
	// This attribute is mandatory.
	Period interface{}

	// Designates a timestamp from which the series of periodic push updates are
	// computed. The next update will take place at the next period interval from
	// the anchor time.  For example, for an anchor time at the top of a minute
	// and a period interval of a minute, the next update will be sent at the top
	// of the next minute. The type is string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	AnchorTime interface{}

	// This leaf acts as a flag that determines behavior at the start of the
	// subscription.  When present, synchronization of state at the beginning of
	// the subscription is outside the scope of the subscription. Only updates
	// about changes that are observed from the start time, i.e. only
	// push-change-update notifications are sent. When absent (default behavior),
	// in order to facilitate a receiver's synchronization, a full update is sent
	// when the subscription starts using a push-update notification, just like in
	// the case of a periodic subscription.  After that, push-change-update
	// notifications only are sent unless the Publisher chooses to resynch the
	// subscription again. The type is interface{}.
	NoSynchOnStart interface{}

	// Minimum amount of time that needs to have passed since the last time an
	// update was provided. The type is interface{} with range: 0..4294967295.
	// This attribute is mandatory.
	DampeningPeriod interface{}

	// Use to restrict which changes trigger an update. For example, if modify is
	// excluded, only creation and deletion of objects is reported. The type is
	// slice of ChangeType.
	ExcludedChange []interface{}

	// The push update's IP packet transport priority. This is made visible across
	// network hops to receiver. The transport priority is shared for all
	// receivers of a given subscription. The type is interface{} with range:
	// 0..63. The default value is 0.
	Dscp interface{}

	// Relative priority for a subscription.   Allows an underlying transport
	// layer perform informed load balance allocations between various
	// subscriptions. The type is interface{} with range: 0..255.
	SubscriptionPriority interface{}

	// Provides the Subscription ID of a parent subscription without which this
	// subscription should not exist. In other words, there is no reason to stream
	// these objects if another subscription is missing. The type is string.
	SubscriptionDependency interface{}
}

EstablishSubscription_Output

func (*EstablishSubscription_Output) GetEntityData 

func (output *EstablishSubscription_Output) GetEntityData() *types.CommonEntityData

type Filters 

type Filters struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// A list of configurable filters that can be applied to subscriptions. The
	// type is slice of Filters_Filter.
	Filter []*Filters_Filter
}

Filters This container contains a list of configurable filters that can be applied to subscriptions. This facilitates the reuse of complex filters once defined.

func (*Filters) GetEntityData 

func (filters *Filters) GetEntityData() *types.CommonEntityData

type Filters_Filter 

type Filters_Filter struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. An identifier to differentiate between filters.
	// The type is interface{} with range: 0..4294967295.
	FilterId interface{}

	// Filter per RFC 5277. Notification filter. If a filter element is specified
	// to look for data of a particular value, and the data item is not present
	// within a particular event notification for its value to be checked against,
	// the notification will be filtered out. For example, if one were to check
	// for 'severity=critical' in a configuration event notification where this
	// field was not supported, then the notification would be filtered out. For
	// subtree filtering, a non-empty node set means that the filter matches.  For
	// XPath filtering, the mechanisms defined in [XPATH] should be used to
	// convert the returned value to boolean. The type is string.
	Filter interface{}

	// Subtree-filter used to specify the data nodes targeted for subscription
	// within a subtree, or subtrees, of a conceptual YANG datastore.  Objects
	// matching the filter criteria will traverse the filter. The syntax follows
	// the subtree filter syntax specified in RFC 6241, section 6. The type is
	// string.
	SubtreeFilter interface{}

	// Xpath defining the data items of interest. The type is string.
	XpathFilter interface{}
}

Filters_Filter A list of configurable filters that can be applied to subscriptions.

func (*Filters_Filter) GetEntityData 

func (filter *Filters_Filter) GetEntityData() *types.CommonEntityData

type InError 

type InError struct {
}

func (InError) String 

func (id InError) String() string

type Inactive 

type Inactive struct {
}

func (Inactive) String 

func (id Inactive) String() string

type InternalError 

type InternalError struct {
}

func (InternalError) String 

func (id InternalError) String() string

type ModifySubscription 

type ModifySubscription struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	Input ModifySubscription_Input

	Output ModifySubscription_Output
}

ModifySubscription This RPC allows a subscriber to modify a subscription that was previously created using establish-subscription. If successful, the subscription remains in effect for the duration of the subscriber's association with the publisher, or until the subscription is terminated by virtue of a delete-subscription request. In case an error is returned (as indicated by subscription-result), the subscription is not modified and the original subscription parameters remain in effect. In that case, the rpc error response MAY include suggested parameter settings that would have a high likelihood of succeeding in a subsequent modify-subscription request.

func (*ModifySubscription) GetEntityData 

func (modifySubscription *ModifySubscription) GetEntityData() *types.CommonEntityData

type ModifySubscription_Input 

type ModifySubscription_Input struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Identifier to use for this subscription. The type is interface{} with
	// range: 0..4294967295.
	SubscriptionId interface{}

	// Filter per RFC 5277. Notification filter. If a filter element is specified
	// to look for data of a particular value, and the data item is not present
	// within a particular event notification for its value to be checked against,
	// the notification will be filtered out. For example, if one were to check
	// for 'severity=critical' in a configuration event notification where this
	// field was not supported, then the notification would be filtered out. For
	// subtree filtering, a non-empty node set means that the filter matches.  For
	// XPath filtering, the mechanisms defined in [XPATH] should be used to
	// convert the returned value to boolean. The type is string.
	Filter interface{}

	// References filter which is associated with the subscription. The type is
	// string with range: 0..4294967295. Refers to
	// event_notifications.Filters_Filter_FilterId
	FilterRef interface{}

	// Subtree-filter used to specify the data nodes targeted for subscription
	// within a subtree, or subtrees, of a conceptual YANG datastore.  Objects
	// matching the filter criteria will traverse the filter. The syntax follows
	// the subtree filter syntax specified in RFC 6241, section 6. The type is
	// string.
	SubtreeFilter interface{}

	// Xpath defining the data items of interest. The type is string.
	XpathFilter interface{}

	// Used to trigger the replay feature and indicate that the replay should
	// start at the time specified.  If <startTime> is not present, this is not a
	// replay subscription.  It is not valid to specify start times that are later
	// than the current time.  If the <startTime> specified is earlier than the
	// log can support, the replay will begin with the earliest available
	// notification.  This parameter is of type dateTime and compliant to
	// [RFC3339].  Implementations must support time zones. The type is string
	// with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	StartTime interface{}

	// Used with the optional replay feature to indicate the newest notifications
	// of interest.  If <stopTime> is not present, the notifications will continue
	// until the subscription is terminated.  Must be used with and be later than
	// <startTime>.  Values of <stopTime> in the future are valid.  This parameter
	// is of type dateTime and compliant to [RFC3339].  Implementations must
	// support time zones. The type is string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	StopTime interface{}

	// Duration of time which should occur between periodic push updates.  Where
	// the anchor of a start-time is available, the push will include the objects
	// and their values which exist at an exact multiple of timeticks aligning to
	// this start-time anchor. The type is interface{} with range: 0..4294967295.
	// This attribute is mandatory.
	Period interface{}

	// Designates a timestamp from which the series of periodic push updates are
	// computed. The next update will take place at the next period interval from
	// the anchor time.  For example, for an anchor time at the top of a minute
	// and a period interval of a minute, the next update will be sent at the top
	// of the next minute. The type is string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	AnchorTime interface{}

	// This leaf acts as a flag that determines behavior at the start of the
	// subscription.  When present, synchronization of state at the beginning of
	// the subscription is outside the scope of the subscription. Only updates
	// about changes that are observed from the start time, i.e. only
	// push-change-update notifications are sent. When absent (default behavior),
	// in order to facilitate a receiver's synchronization, a full update is sent
	// when the subscription starts using a push-update notification, just like in
	// the case of a periodic subscription.  After that, push-change-update
	// notifications only are sent unless the Publisher chooses to resynch the
	// subscription again. The type is interface{}.
	NoSynchOnStart interface{}

	// Minimum amount of time that needs to have passed since the last time an
	// update was provided. The type is interface{} with range: 0..4294967295.
	// This attribute is mandatory.
	DampeningPeriod interface{}

	// Use to restrict which changes trigger an update. For example, if modify is
	// excluded, only creation and deletion of objects is reported. The type is
	// slice of ChangeType.
	ExcludedChange []interface{}
}

ModifySubscription_Input

func (*ModifySubscription_Input) GetEntityData 

func (input *ModifySubscription_Input) GetEntityData() *types.CommonEntityData

type ModifySubscription_Output 

type ModifySubscription_Output struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Indicates whether subscription is operational, or if a problem was
	// encountered. The type is one of the following:
	// ErrorErrorNoSuchOptionErrorNoSuchSubscriptionErrorOtherErrorInsufficientResourcesErrorConfiguredSubscriptionErrorDataNotAuthorizedOk.
	// This attribute is mandatory.
	SubscriptionResult interface{}

	// Identifier used for this subscription. The type is interface{} with range:
	// 0..4294967295. This attribute is mandatory.
	SubscriptionId interface{}

	// Indicates which stream of events is of interest. If not present, events in
	// the default NETCONF stream will be sent. The type is one of the following:
	// NETCONFCustomStreamYangPush.
	Stream interface{}

	// The type of encoding for the subscribed data. Default is XML. The type is
	// one of the following: EncodeJsonEncodeXml. The default value is encode-xml.
	Encoding interface{}

	// Filter per RFC 5277. Notification filter. If a filter element is specified
	// to look for data of a particular value, and the data item is not present
	// within a particular event notification for its value to be checked against,
	// the notification will be filtered out. For example, if one were to check
	// for 'severity=critical' in a configuration event notification where this
	// field was not supported, then the notification would be filtered out. For
	// subtree filtering, a non-empty node set means that the filter matches.  For
	// XPath filtering, the mechanisms defined in [XPATH] should be used to
	// convert the returned value to boolean. The type is string.
	Filter interface{}

	// References filter which is associated with the subscription. The type is
	// string with range: 0..4294967295. Refers to
	// event_notifications.Filters_Filter_FilterId
	FilterRef interface{}

	// Subtree-filter used to specify the data nodes targeted for subscription
	// within a subtree, or subtrees, of a conceptual YANG datastore.  Objects
	// matching the filter criteria will traverse the filter. The syntax follows
	// the subtree filter syntax specified in RFC 6241, section 6. The type is
	// string.
	SubtreeFilter interface{}

	// Xpath defining the data items of interest. The type is string.
	XpathFilter interface{}

	// Used to trigger the replay feature and indicate that the replay should
	// start at the time specified.  If <startTime> is not present, this is not a
	// replay subscription.  It is not valid to specify start times that are later
	// than the current time.  If the <startTime> specified is earlier than the
	// log can support, the replay will begin with the earliest available
	// notification.  This parameter is of type dateTime and compliant to
	// [RFC3339].  Implementations must support time zones. The type is string
	// with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	StartTime interface{}

	// Used with the optional replay feature to indicate the newest notifications
	// of interest.  If <stopTime> is not present, the notifications will continue
	// until the subscription is terminated.  Must be used with and be later than
	// <startTime>.  Values of <stopTime> in the future are valid.  This parameter
	// is of type dateTime and compliant to [RFC3339].  Implementations must
	// support time zones. The type is string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	StopTime interface{}

	// Duration of time which should occur between periodic push updates.  Where
	// the anchor of a start-time is available, the push will include the objects
	// and their values which exist at an exact multiple of timeticks aligning to
	// this start-time anchor. The type is interface{} with range: 0..4294967295.
	// This attribute is mandatory.
	Period interface{}

	// Designates a timestamp from which the series of periodic push updates are
	// computed. The next update will take place at the next period interval from
	// the anchor time.  For example, for an anchor time at the top of a minute
	// and a period interval of a minute, the next update will be sent at the top
	// of the next minute. The type is string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	AnchorTime interface{}

	// This leaf acts as a flag that determines behavior at the start of the
	// subscription.  When present, synchronization of state at the beginning of
	// the subscription is outside the scope of the subscription. Only updates
	// about changes that are observed from the start time, i.e. only
	// push-change-update notifications are sent. When absent (default behavior),
	// in order to facilitate a receiver's synchronization, a full update is sent
	// when the subscription starts using a push-update notification, just like in
	// the case of a periodic subscription.  After that, push-change-update
	// notifications only are sent unless the Publisher chooses to resynch the
	// subscription again. The type is interface{}.
	NoSynchOnStart interface{}

	// Minimum amount of time that needs to have passed since the last time an
	// update was provided. The type is interface{} with range: 0..4294967295.
	// This attribute is mandatory.
	DampeningPeriod interface{}

	// Use to restrict which changes trigger an update. For example, if modify is
	// excluded, only creation and deletion of objects is reported. The type is
	// slice of ChangeType.
	ExcludedChange []interface{}

	// The push update's IP packet transport priority. This is made visible across
	// network hops to receiver. The transport priority is shared for all
	// receivers of a given subscription. The type is interface{} with range:
	// 0..63. The default value is 0.
	Dscp interface{}

	// Relative priority for a subscription.   Allows an underlying transport
	// layer perform informed load balance allocations between various
	// subscriptions. The type is interface{} with range: 0..255.
	SubscriptionPriority interface{}

	// Provides the Subscription ID of a parent subscription without which this
	// subscription should not exist. In other words, there is no reason to stream
	// these objects if another subscription is missing. The type is string.
	SubscriptionDependency interface{}
}

ModifySubscription_Output

func (*ModifySubscription_Output) GetEntityData 

func (output *ModifySubscription_Output) GetEntityData() *types.CommonEntityData

type NETCONF 

type NETCONF struct {
}

func (NETCONF) String 

func (id NETCONF) String() string

type Netconf 

type Netconf struct {
}

func (Netconf) String 

func (id Netconf) String() string

type NoResources 

type NoResources struct {
}

func (NoResources) String 

func (id NoResources) String() string

type Ok 

type Ok struct {
}

func (Ok) String 

func (id Ok) String() string

type Other 

type Other struct {
}

func (Other) String 

func (id Other) String() string

type PushSource 

type PushSource string

PushSource represents being sent by the publisher. 

const (
	// Notifications will be sent from a specific interface on
	// a publisher
	PushSource_interface_originated PushSource = "interface-originated"

	// Notifications will be sent from a specific address on a
	// publisher
	PushSource_address_originated PushSource = "address-originated"
)

type Stream 

type Stream struct {
}

func (Stream) String 

func (id Stream) String() string

type Streams 

type Streams struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Identifies the built-in streams that are supported by the system.  Built-in
	// streams are associated with their own identities, each of which carries a
	// special semantics. In case configurable custom streams are supported, as
	// indicated by the custom-stream identity, the configuration of those custom
	// streams is provided         separately. The type is slice of [u'NETCONF',
	// 'CustomStream', 'YangPush'].
	Stream []interface{}
}

Streams This container contains a leaf list of built-in streams that are provided by the system.

func (*Streams) GetEntityData 

func (streams *Streams) GetEntityData() *types.CommonEntityData

type SubscriptionConfig 

type SubscriptionConfig struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Content of a subscription. The type is slice of
	// SubscriptionConfig_Subscription.
	Subscription []*SubscriptionConfig_Subscription
}

SubscriptionConfig Contains the list of subscriptions that are configured, as opposed to established via RPC or other means.

func (*SubscriptionConfig) GetEntityData 

func (subscriptionConfig *SubscriptionConfig) GetEntityData() *types.CommonEntityData

type SubscriptionConfig_Subscription 

type SubscriptionConfig_Subscription struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. Identifier to use for this subscription. The type
	// is interface{} with range: 0..4294967295.
	SubscriptionId interface{}

	// Indicates which stream of events is of interest. If not present, events in
	// the default NETCONF stream will be sent. The type is one of the following:
	// NETCONFCustomStreamYangPush.
	Stream interface{}

	// The type of encoding for the subscribed data. Default is XML. The type is
	// one of the following: EncodeJsonEncodeXml. The default value is encode-xml.
	Encoding interface{}

	// Filter per RFC 5277. Notification filter. If a filter element is specified
	// to look for data of a particular value, and the data item is not present
	// within a particular event notification for its value to be checked against,
	// the notification will be filtered out. For example, if one were to check
	// for 'severity=critical' in a configuration event notification where this
	// field was not supported, then the notification would be filtered out. For
	// subtree filtering, a non-empty node set means that the filter matches.  For
	// XPath filtering, the mechanisms defined in [XPATH] should be used to
	// convert the returned value to boolean. The type is string.
	Filter interface{}

	// References filter which is associated with the subscription. The type is
	// string with range: 0..4294967295. Refers to
	// event_notifications.Filters_Filter_FilterId
	FilterRef interface{}

	// Subtree-filter used to specify the data nodes targeted for subscription
	// within a subtree, or subtrees, of a conceptual YANG datastore.  Objects
	// matching the filter criteria will traverse the filter. The syntax follows
	// the subtree filter syntax specified in RFC 6241, section 6. The type is
	// string.
	SubtreeFilter interface{}

	// Xpath defining the data items of interest. The type is string.
	XpathFilter interface{}

	// Used to trigger the replay feature and indicate that the replay should
	// start at the time specified.  If <startTime> is not present, this is not a
	// replay subscription.  It is not valid to specify start times that are later
	// than the current time.  If the <startTime> specified is earlier than the
	// log can support, the replay will begin with the earliest available
	// notification.  This parameter is of type dateTime and compliant to
	// [RFC3339].  Implementations must support time zones. The type is string
	// with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	StartTime interface{}

	// Used with the optional replay feature to indicate the newest notifications
	// of interest.  If <stopTime> is not present, the notifications will continue
	// until the subscription is terminated.  Must be used with and be later than
	// <startTime>.  Values of <stopTime> in the future are valid.  This parameter
	// is of type dateTime and compliant to [RFC3339].  Implementations must
	// support time zones. The type is string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	StopTime interface{}

	// References the interface for notifications. The type is string. Refers to
	// interfaces.Interfaces_Interface_Name
	SourceInterface interface{}

	// Label of the vrf. The type is interface{} with range: 16..1048574.
	SourceVrf interface{}

	// The source address for the notifications. The type is one of the following
	// types: string with pattern:
	// (([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\p{N}\p{L}]+)?
	// This attribute is mandatory., or string with pattern:
	// ((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\p{N}\p{L}]+)?
	// This attribute is mandatory..
	SourceAddress interface{}

	// Duration of time which should occur between periodic push updates.  Where
	// the anchor of a start-time is available, the push will include the objects
	// and their values which exist at an exact multiple of timeticks aligning to
	// this start-time anchor. The type is interface{} with range: 0..4294967295.
	// This attribute is mandatory.
	Period interface{}

	// Designates a timestamp from which the series of periodic push updates are
	// computed. The next update will take place at the next period interval from
	// the anchor time.  For example, for an anchor time at the top of a minute
	// and a period interval of a minute, the next update will be sent at the top
	// of the next minute. The type is string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	AnchorTime interface{}

	// This leaf acts as a flag that determines behavior at the start of the
	// subscription.  When present, synchronization of state at the beginning of
	// the subscription is outside the scope of the subscription. Only updates
	// about changes that are observed from the start time, i.e. only
	// push-change-update notifications are sent. When absent (default behavior),
	// in order to facilitate a receiver's synchronization, a full update is sent
	// when the subscription starts using a push-update notification, just like in
	// the case of a periodic subscription.  After that, push-change-update
	// notifications only are sent unless the Publisher chooses to resynch the
	// subscription again. The type is interface{}.
	NoSynchOnStart interface{}

	// Minimum amount of time that needs to have passed since the last time an
	// update was provided. The type is interface{} with range: 0..4294967295.
	// This attribute is mandatory.
	DampeningPeriod interface{}

	// Use to restrict which changes trigger an update. For example, if modify is
	// excluded, only creation and deletion of objects is reported. The type is
	// slice of ChangeType.
	ExcludedChange []interface{}

	// The push update's IP packet transport priority. This is made visible across
	// network hops to receiver. The transport priority is shared for all
	// receivers of a given subscription. The type is interface{} with range:
	// 0..63. The default value is 0.
	Dscp interface{}

	// Relative priority for a subscription.   Allows an underlying transport
	// layer perform informed load balance allocations between various
	// subscriptions. The type is interface{} with range: 0..255.
	SubscriptionPriority interface{}

	// Provides the Subscription ID of a parent subscription without which this
	// subscription should not exist. In other words, there is no reason to stream
	// these objects if another subscription is missing. The type is string.
	SubscriptionDependency interface{}

	// Set of receivers in a subscription.
	Receivers SubscriptionConfig_Subscription_Receivers
}

SubscriptionConfig_Subscription Content of a subscription.

func (*SubscriptionConfig_Subscription) GetEntityData 

func (subscription *SubscriptionConfig_Subscription) GetEntityData() *types.CommonEntityData

type SubscriptionConfig_Subscription_Receivers 

type SubscriptionConfig_Subscription_Receivers struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// A single host or multipoint address intended as a target for the
	// notifications for a subscription. The type is slice of
	// SubscriptionConfig_Subscription_Receivers_Receiver.
	Receiver []*SubscriptionConfig_Subscription_Receivers_Receiver
}

SubscriptionConfig_Subscription_Receivers Set of receivers in a subscription.

func (*SubscriptionConfig_Subscription_Receivers) GetEntityData 

func (receivers *SubscriptionConfig_Subscription_Receivers) GetEntityData() *types.CommonEntityData

type SubscriptionConfig_Subscription_Receivers_Receiver 

type SubscriptionConfig_Subscription_Receivers_Receiver struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. Specifies the address for the traffic to reach a
	// remote host. One of the following must be specified: an ipv4 address, an
	// ipv6 address, or a host name. The type is one of the following types:
	// string with pattern:
	// (([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\p{N}\p{L}]+)?
	// This attribute is mandatory., or string with pattern:
	// ((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\p{N}\p{L}]+)?
	// This attribute is mandatory.., or string with length: 1..253 This attribute
	// is mandatory..
	Address interface{}

	// This leaf specifies the port number to use for messages destined for a
	// receiver. The type is interface{} with range: 0..65535. This attribute is
	// mandatory.
	Port interface{}

	// This leaf specifies the transport protocol used to deliver messages
	// destined for the receiver. The type is one of the following: NetconfHttp2.
	// The default value is netconf.
	Protocol interface{}
}

SubscriptionConfig_Subscription_Receivers_Receiver A single host or multipoint address intended as a target for the notifications for a subscription.

func (*SubscriptionConfig_Subscription_Receivers_Receiver) GetEntityData 

func (receiver *SubscriptionConfig_Subscription_Receivers_Receiver) GetEntityData() *types.CommonEntityData

type SubscriptionDeleted 

type SubscriptionDeleted struct {
}

func (SubscriptionDeleted) String 

func (id SubscriptionDeleted) String() string

type SubscriptionErrors 

type SubscriptionErrors struct {
}

func (SubscriptionErrors) String 

func (id SubscriptionErrors) String() string

type SubscriptionResult 

type SubscriptionResult struct {
}

func (SubscriptionResult) String 

func (id SubscriptionResult) String() string

type SubscriptionStreamStatus 

type SubscriptionStreamStatus struct {
}

func (SubscriptionStreamStatus) String 

func (id SubscriptionStreamStatus) String() string

type Subscriptions 

type Subscriptions struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Content of a subscription. Subscriptions can be created using a control
	// channel or RPC, or be established through configuration. The type is slice
	// of Subscriptions_Subscription.
	Subscription []*Subscriptions_Subscription
}

Subscriptions Contains the list of currently active subscriptions, i.e. subscriptions that are currently in effect, used for subscription management and monitoring purposes. This includes subscriptions that have been setup via RPC primitives, e.g. create-subscription, establish- subscription, and modify-subscription, as well as subscriptions that have been established via 

configuration.

func (*Subscriptions) GetEntityData 

func (subscriptions *Subscriptions) GetEntityData() *types.CommonEntityData

type Subscriptions_Subscription 

type Subscriptions_Subscription struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. Identifier of this subscription. The type is
	// interface{} with range: 0..4294967295.
	SubscriptionId interface{}

	// The presence of this leaf indicates that the subscription originated from
	// configuration, not through a control channel or RPC. The type is
	// interface{}.
	ConfiguredSubscription interface{}

	// The status of the subscription. The type is one of the following:
	// InactiveSuspendedInErrorActive.
	SubscriptionStatus interface{}

	// Indicates which stream of events is of interest. If not present, events in
	// the default NETCONF stream will be sent. The type is one of the following:
	// NETCONFCustomStreamYangPush.
	Stream interface{}

	// The type of encoding for the subscribed data. Default is XML. The type is
	// one of the following: EncodeJsonEncodeXml. The default value is encode-xml.
	Encoding interface{}

	// Filter per RFC 5277. Notification filter. If a filter element is specified
	// to look for data of a particular value, and the data item is not present
	// within a particular event notification for its value to be checked against,
	// the notification will be filtered out. For example, if one were to check
	// for 'severity=critical' in a configuration event notification where this
	// field was not supported, then the notification would be filtered out. For
	// subtree filtering, a non-empty node set means that the filter matches.  For
	// XPath filtering, the mechanisms defined in [XPATH] should be used to
	// convert the returned value to boolean. The type is string.
	Filter interface{}

	// References filter which is associated with the subscription. The type is
	// string with range: 0..4294967295. Refers to
	// event_notifications.Filters_Filter_FilterId
	FilterRef interface{}

	// Subtree-filter used to specify the data nodes targeted for subscription
	// within a subtree, or subtrees, of a conceptual YANG datastore.  Objects
	// matching the filter criteria will traverse the filter. The syntax follows
	// the subtree filter syntax specified in RFC 6241, section 6. The type is
	// string.
	SubtreeFilter interface{}

	// Xpath defining the data items of interest. The type is string.
	XpathFilter interface{}

	// Used to trigger the replay feature and indicate that the replay should
	// start at the time specified.  If <startTime> is not present, this is not a
	// replay subscription.  It is not valid to specify start times that are later
	// than the current time.  If the <startTime> specified is earlier than the
	// log can support, the replay will begin with the earliest available
	// notification.  This parameter is of type dateTime and compliant to
	// [RFC3339].  Implementations must support time zones. The type is string
	// with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	StartTime interface{}

	// Used with the optional replay feature to indicate the newest notifications
	// of interest.  If <stopTime> is not present, the notifications will continue
	// until the subscription is terminated.  Must be used with and be later than
	// <startTime>.  Values of <stopTime> in the future are valid.  This parameter
	// is of type dateTime and compliant to [RFC3339].  Implementations must
	// support time zones. The type is string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	StopTime interface{}

	// References the interface for notifications. The type is string. Refers to
	// interfaces.Interfaces_Interface_Name
	SourceInterface interface{}

	// Label of the vrf. The type is interface{} with range: 16..1048574.
	SourceVrf interface{}

	// The source address for the notifications. The type is one of the following
	// types: string with pattern:
	// (([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\p{N}\p{L}]+)?
	// This attribute is mandatory., or string with pattern:
	// ((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\p{N}\p{L}]+)?
	// This attribute is mandatory..
	SourceAddress interface{}

	// Duration of time which should occur between periodic push updates.  Where
	// the anchor of a start-time is available, the push will include the objects
	// and their values which exist at an exact multiple of timeticks aligning to
	// this start-time anchor. The type is interface{} with range: 0..4294967295.
	// This attribute is mandatory.
	Period interface{}

	// Designates a timestamp from which the series of periodic push updates are
	// computed. The next update will take place at the next period interval from
	// the anchor time.  For example, for an anchor time at the top of a minute
	// and a period interval of a minute, the next update will be sent at the top
	// of the next minute. The type is string with pattern:
	// \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-]\d{2}:\d{2}).
	AnchorTime interface{}

	// This leaf acts as a flag that determines behavior at the start of the
	// subscription.  When present, synchronization of state at the beginning of
	// the subscription is outside the scope of the subscription. Only updates
	// about changes that are observed from the start time, i.e. only
	// push-change-update notifications are sent. When absent (default behavior),
	// in order to facilitate a receiver's synchronization, a full update is sent
	// when the subscription starts using a push-update notification, just like in
	// the case of a periodic subscription.  After that, push-change-update
	// notifications only are sent unless the Publisher chooses to resynch the
	// subscription again. The type is interface{}.
	NoSynchOnStart interface{}

	// Minimum amount of time that needs to have passed since the last time an
	// update was provided. The type is interface{} with range: 0..4294967295.
	// This attribute is mandatory.
	DampeningPeriod interface{}

	// Use to restrict which changes trigger an update. For example, if modify is
	// excluded, only creation and deletion of objects is reported. The type is
	// slice of ChangeType.
	ExcludedChange []interface{}

	// The push update's IP packet transport priority. This is made visible across
	// network hops to receiver. The transport priority is shared for all
	// receivers of a given subscription. The type is interface{} with range:
	// 0..63. The default value is 0.
	Dscp interface{}

	// Relative priority for a subscription.   Allows an underlying transport
	// layer perform informed load balance allocations between various
	// subscriptions. The type is interface{} with range: 0..255.
	SubscriptionPriority interface{}

	// Provides the Subscription ID of a parent subscription without which this
	// subscription should not exist. In other words, there is no reason to stream
	// these objects if another subscription is missing. The type is string.
	SubscriptionDependency interface{}

	// Set of receivers in a subscription.
	Receivers Subscriptions_Subscription_Receivers
}

Subscriptions_Subscription Content of a subscription. Subscriptions can be created using a control channel or RPC, or be established through configuration.

func (*Subscriptions_Subscription) GetEntityData 

func (subscription *Subscriptions_Subscription) GetEntityData() *types.CommonEntityData

type Subscriptions_Subscription_Receivers 

type Subscriptions_Subscription_Receivers struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// A single host or multipoint address intended as a target for the
	// notifications for a subscription. The type is slice of
	// Subscriptions_Subscription_Receivers_Receiver.
	Receiver []*Subscriptions_Subscription_Receivers_Receiver
}

Subscriptions_Subscription_Receivers Set of receivers in a subscription.

func (*Subscriptions_Subscription_Receivers) GetEntityData 

func (receivers *Subscriptions_Subscription_Receivers) GetEntityData() *types.CommonEntityData

type Subscriptions_Subscription_Receivers_Receiver 

type Subscriptions_Subscription_Receivers_Receiver struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. Specifies the address for the traffic to reach a
	// remote host. One of the following must be specified: an ipv4 address, an
	// ipv6 address, or a host name. The type is one of the following types:
	// string with pattern:
	// (([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\p{N}\p{L}]+)?
	// This attribute is mandatory., or string with pattern:
	// ((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\p{N}\p{L}]+)?
	// This attribute is mandatory.., or string with length: 1..253 This attribute
	// is mandatory..
	Address interface{}

	// This leaf specifies the port number to use for messages destined for a
	// receiver. The type is interface{} with range: 0..65535. This attribute is
	// mandatory.
	Port interface{}

	// This leaf specifies the transport protocol used to deliver messages
	// destined for the receiver. The type is one of the following: NetconfHttp2.
	// The default value is netconf.
	Protocol interface{}
}

Subscriptions_Subscription_Receivers_Receiver A single host or multipoint address intended as a target for the notifications for a subscription.

func (*Subscriptions_Subscription_Receivers_Receiver) GetEntityData 

func (receiver *Subscriptions_Subscription_Receivers_Receiver) GetEntityData() *types.CommonEntityData

type Suspended 

type Suspended struct {
}

func (Suspended) String 

func (id Suspended) String() string

type Transport 

type Transport struct {
}

func (Transport) String 

func (id Transport) String() string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.