models.go

package timeseriesinsights

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
//
// Code generated by Microsoft (R) AutoRest Code Generator.
// Changes may cause incorrect behavior and will be lost if the code is regenerated.

import (
	"context"
	"encoding/json"
	"github.com/Azure/go-autorest/autorest"
	"github.com/Azure/go-autorest/autorest/azure"
	"github.com/Azure/go-autorest/autorest/date"
	"github.com/Azure/go-autorest/autorest/to"
	"github.com/Azure/go-autorest/tracing"
	"github.com/gofrs/uuid"
	"net/http"
)

// The package's fully qualified name.
const fqdn = "github.com/Azure/azure-sdk-for-go/services/preview/timeseriesinsights/mgmt/2018-08-15-preview/timeseriesinsights"

// AccessPolicyCreateOrUpdateParameters ...
type AccessPolicyCreateOrUpdateParameters struct {
	*AccessPolicyResourceProperties `json:"properties,omitempty"`
}

// MarshalJSON is the custom marshaler for AccessPolicyCreateOrUpdateParameters.
func (apcoup AccessPolicyCreateOrUpdateParameters) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if apcoup.AccessPolicyResourceProperties != nil {
		objectMap["properties"] = apcoup.AccessPolicyResourceProperties
	}
	return json.Marshal(objectMap)
}

// UnmarshalJSON is the custom unmarshaler for AccessPolicyCreateOrUpdateParameters struct.
func (apcoup *AccessPolicyCreateOrUpdateParameters) UnmarshalJSON(body []byte) error {
	var m map[string]*json.RawMessage
	err := json.Unmarshal(body, &m)
	if err != nil {
		return err
	}
	for k, v := range m {
		switch k {
		case "properties":
			if v != nil {
				var accessPolicyResourceProperties AccessPolicyResourceProperties
				err = json.Unmarshal(*v, &accessPolicyResourceProperties)
				if err != nil {
					return err
				}
				apcoup.AccessPolicyResourceProperties = &accessPolicyResourceProperties
			}
		}
	}

	return nil
}

// AccessPolicyListResponse the response of the List access policies operation.
type AccessPolicyListResponse struct {
	autorest.Response `json:"-"`
	// Value - Result of the List access policies operation.
	Value *[]AccessPolicyResource `json:"value,omitempty"`
}

// AccessPolicyMutableProperties an object that represents a set of mutable access policy resource
// properties.
type AccessPolicyMutableProperties struct {
	// Description - An description of the access policy.
	Description *string `json:"description,omitempty"`
	// Roles - The list of roles the principal is assigned on the environment.
	Roles *[]AccessPolicyRole `json:"roles,omitempty"`
}

// AccessPolicyResource an access policy is used to grant users and applications access to the environment.
// Roles are assigned to service principals in Azure Active Directory. These roles define the actions the
// principal can perform through the Time Series Insights data plane APIs.
type AccessPolicyResource struct {
	autorest.Response               `json:"-"`
	*AccessPolicyResourceProperties `json:"properties,omitempty"`
	// ID - READ-ONLY; Resource Id
	ID *string `json:"id,omitempty"`
	// Name - READ-ONLY; Resource name
	Name *string `json:"name,omitempty"`
	// Type - READ-ONLY; Resource type
	Type *string `json:"type,omitempty"`
}

// MarshalJSON is the custom marshaler for AccessPolicyResource.
func (apr AccessPolicyResource) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if apr.AccessPolicyResourceProperties != nil {
		objectMap["properties"] = apr.AccessPolicyResourceProperties
	}
	return json.Marshal(objectMap)
}

// UnmarshalJSON is the custom unmarshaler for AccessPolicyResource struct.
func (apr *AccessPolicyResource) UnmarshalJSON(body []byte) error {
	var m map[string]*json.RawMessage
	err := json.Unmarshal(body, &m)
	if err != nil {
		return err
	}
	for k, v := range m {
		switch k {
		case "properties":
			if v != nil {
				var accessPolicyResourceProperties AccessPolicyResourceProperties
				err = json.Unmarshal(*v, &accessPolicyResourceProperties)
				if err != nil {
					return err
				}
				apr.AccessPolicyResourceProperties = &accessPolicyResourceProperties
			}
		case "id":
			if v != nil {
				var ID string
				err = json.Unmarshal(*v, &ID)
				if err != nil {
					return err
				}
				apr.ID = &ID
			}
		case "name":
			if v != nil {
				var name string
				err = json.Unmarshal(*v, &name)
				if err != nil {
					return err
				}
				apr.Name = &name
			}
		case "type":
			if v != nil {
				var typeVar string
				err = json.Unmarshal(*v, &typeVar)
				if err != nil {
					return err
				}
				apr.Type = &typeVar
			}
		}
	}

	return nil
}

// AccessPolicyResourceProperties ...
type AccessPolicyResourceProperties struct {
	// PrincipalObjectID - The objectId of the principal in Azure Active Directory.
	PrincipalObjectID *string `json:"principalObjectId,omitempty"`
	// Description - An description of the access policy.
	Description *string `json:"description,omitempty"`
	// Roles - The list of roles the principal is assigned on the environment.
	Roles *[]AccessPolicyRole `json:"roles,omitempty"`
}

// AccessPolicyUpdateParameters ...
type AccessPolicyUpdateParameters struct {
	*AccessPolicyMutableProperties `json:"properties,omitempty"`
}

// MarshalJSON is the custom marshaler for AccessPolicyUpdateParameters.
func (apup AccessPolicyUpdateParameters) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if apup.AccessPolicyMutableProperties != nil {
		objectMap["properties"] = apup.AccessPolicyMutableProperties
	}
	return json.Marshal(objectMap)
}

// UnmarshalJSON is the custom unmarshaler for AccessPolicyUpdateParameters struct.
func (apup *AccessPolicyUpdateParameters) UnmarshalJSON(body []byte) error {
	var m map[string]*json.RawMessage
	err := json.Unmarshal(body, &m)
	if err != nil {
		return err
	}
	for k, v := range m {
		switch k {
		case "properties":
			if v != nil {
				var accessPolicyMutableProperties AccessPolicyMutableProperties
				err = json.Unmarshal(*v, &accessPolicyMutableProperties)
				if err != nil {
					return err
				}
				apup.AccessPolicyMutableProperties = &accessPolicyMutableProperties
			}
		}
	}

	return nil
}

// AzureEventSourceProperties properties of an event source that reads events from an event broker in
// Azure.
type AzureEventSourceProperties struct {
	// EventSourceResourceID - The resource id of the event source in Azure Resource Manager.
	EventSourceResourceID *string `json:"eventSourceResourceId,omitempty"`
	// TimestampPropertyName - The event property that will be used as the event source's timestamp. If a value isn't specified for timestampPropertyName, or if null or empty-string is specified, the event creation time will be used.
	TimestampPropertyName *string `json:"timestampPropertyName,omitempty"`
	// ProvisioningState - Provisioning state of the resource. Possible values include: 'Accepted', 'Creating', 'Updating', 'Succeeded', 'Failed', 'Deleting'
	ProvisioningState ProvisioningState `json:"provisioningState,omitempty"`
	// CreationTime - READ-ONLY; The time the resource was created.
	CreationTime *date.Time `json:"creationTime,omitempty"`
}

// MarshalJSON is the custom marshaler for AzureEventSourceProperties.
func (aesp AzureEventSourceProperties) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if aesp.EventSourceResourceID != nil {
		objectMap["eventSourceResourceId"] = aesp.EventSourceResourceID
	}
	if aesp.TimestampPropertyName != nil {
		objectMap["timestampPropertyName"] = aesp.TimestampPropertyName
	}
	if aesp.ProvisioningState != "" {
		objectMap["provisioningState"] = aesp.ProvisioningState
	}
	return json.Marshal(objectMap)
}

// CloudError contains information about an API error.
type CloudError struct {
	// Error - Describes a particular API error with an error code and a message.
	Error *CloudErrorBody `json:"error,omitempty"`
}

// CloudErrorBody describes a particular API error with an error code and a message.
type CloudErrorBody struct {
	// Code - An error code that describes the error condition more precisely than an HTTP status code. Can be used to programmatically handle specific error cases.
	Code *string `json:"code,omitempty"`
	// Message - A message that describes the error in detail and provides debugging information.
	Message *string `json:"message,omitempty"`
	// Target - The target of the particular error (for example, the name of the property in error).
	Target *string `json:"target,omitempty"`
	// Details - Contains nested errors that are related to this error.
	Details *[]CloudErrorBody `json:"details,omitempty"`
}

// CreateOrUpdateTrackedResourceProperties properties required to create any resource tracked by Azure
// Resource Manager.
type CreateOrUpdateTrackedResourceProperties struct {
	// Location - The location of the resource.
	Location *string `json:"location,omitempty"`
	// Tags - Key-value pairs of additional properties for the resource.
	Tags map[string]*string `json:"tags"`
}

// MarshalJSON is the custom marshaler for CreateOrUpdateTrackedResourceProperties.
func (coutrp CreateOrUpdateTrackedResourceProperties) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if coutrp.Location != nil {
		objectMap["location"] = coutrp.Location
	}
	if coutrp.Tags != nil {
		objectMap["tags"] = coutrp.Tags
	}
	return json.Marshal(objectMap)
}

// BasicEnvironmentCreateOrUpdateParameters parameters supplied to the CreateOrUpdate Environment operation.
type BasicEnvironmentCreateOrUpdateParameters interface {
	AsStandardEnvironmentCreateOrUpdateParameters() (*StandardEnvironmentCreateOrUpdateParameters, bool)
	AsLongTermEnvironmentCreateOrUpdateParameters() (*LongTermEnvironmentCreateOrUpdateParameters, bool)
	AsEnvironmentCreateOrUpdateParameters() (*EnvironmentCreateOrUpdateParameters, bool)
}

// EnvironmentCreateOrUpdateParameters parameters supplied to the CreateOrUpdate Environment operation.
type EnvironmentCreateOrUpdateParameters struct {
	// Sku - The sku determines the type of environment, either standard (S1 or S2) or long-term (L1). For standard environments the sku determines the capacity of the environment, the ingress rate, and the billing rate.
	Sku *Sku `json:"sku,omitempty"`
	// Kind - Possible values include: 'KindEnvironmentCreateOrUpdateParameters', 'KindStandard', 'KindLongTerm'
	Kind Kind `json:"kind,omitempty"`
	// Location - The location of the resource.
	Location *string `json:"location,omitempty"`
	// Tags - Key-value pairs of additional properties for the resource.
	Tags map[string]*string `json:"tags"`
}

func unmarshalBasicEnvironmentCreateOrUpdateParameters(body []byte) (BasicEnvironmentCreateOrUpdateParameters, error) {
	var m map[string]interface{}
	err := json.Unmarshal(body, &m)
	if err != nil {
		return nil, err
	}

	switch m["kind"] {
	case string(KindStandard):
		var secoup StandardEnvironmentCreateOrUpdateParameters
		err := json.Unmarshal(body, &secoup)
		return secoup, err
	case string(KindLongTerm):
		var ltecoup LongTermEnvironmentCreateOrUpdateParameters
		err := json.Unmarshal(body, &ltecoup)
		return ltecoup, err
	default:
		var ecoup EnvironmentCreateOrUpdateParameters
		err := json.Unmarshal(body, &ecoup)
		return ecoup, err
	}
}
func unmarshalBasicEnvironmentCreateOrUpdateParametersArray(body []byte) ([]BasicEnvironmentCreateOrUpdateParameters, error) {
	var rawMessages []*json.RawMessage
	err := json.Unmarshal(body, &rawMessages)
	if err != nil {
		return nil, err
	}

	ecoupArray := make([]BasicEnvironmentCreateOrUpdateParameters, len(rawMessages))

	for index, rawMessage := range rawMessages {
		ecoup, err := unmarshalBasicEnvironmentCreateOrUpdateParameters(*rawMessage)
		if err != nil {
			return nil, err
		}
		ecoupArray[index] = ecoup
	}
	return ecoupArray, nil
}

// MarshalJSON is the custom marshaler for EnvironmentCreateOrUpdateParameters.
func (ecoup EnvironmentCreateOrUpdateParameters) MarshalJSON() ([]byte, error) {
	ecoup.Kind = KindEnvironmentCreateOrUpdateParameters
	objectMap := make(map[string]interface{})
	if ecoup.Sku != nil {
		objectMap["sku"] = ecoup.Sku
	}
	if ecoup.Kind != "" {
		objectMap["kind"] = ecoup.Kind
	}
	if ecoup.Location != nil {
		objectMap["location"] = ecoup.Location
	}
	if ecoup.Tags != nil {
		objectMap["tags"] = ecoup.Tags
	}
	return json.Marshal(objectMap)
}

// AsStandardEnvironmentCreateOrUpdateParameters is the BasicEnvironmentCreateOrUpdateParameters implementation for EnvironmentCreateOrUpdateParameters.
func (ecoup EnvironmentCreateOrUpdateParameters) AsStandardEnvironmentCreateOrUpdateParameters() (*StandardEnvironmentCreateOrUpdateParameters, bool) {
	return nil, false
}

// AsLongTermEnvironmentCreateOrUpdateParameters is the BasicEnvironmentCreateOrUpdateParameters implementation for EnvironmentCreateOrUpdateParameters.
func (ecoup EnvironmentCreateOrUpdateParameters) AsLongTermEnvironmentCreateOrUpdateParameters() (*LongTermEnvironmentCreateOrUpdateParameters, bool) {
	return nil, false
}

// AsEnvironmentCreateOrUpdateParameters is the BasicEnvironmentCreateOrUpdateParameters implementation for EnvironmentCreateOrUpdateParameters.
func (ecoup EnvironmentCreateOrUpdateParameters) AsEnvironmentCreateOrUpdateParameters() (*EnvironmentCreateOrUpdateParameters, bool) {
	return &ecoup, true
}

// AsBasicEnvironmentCreateOrUpdateParameters is the BasicEnvironmentCreateOrUpdateParameters implementation for EnvironmentCreateOrUpdateParameters.
func (ecoup EnvironmentCreateOrUpdateParameters) AsBasicEnvironmentCreateOrUpdateParameters() (BasicEnvironmentCreateOrUpdateParameters, bool) {
	return &ecoup, true
}

// EnvironmentListResponse the response of the List Environments operation.
type EnvironmentListResponse struct {
	autorest.Response `json:"-"`
	// Value - Result of the List Environments operation.
	Value *[]BasicEnvironmentResource `json:"value,omitempty"`
}

// UnmarshalJSON is the custom unmarshaler for EnvironmentListResponse struct.
func (elr *EnvironmentListResponse) UnmarshalJSON(body []byte) error {
	var m map[string]*json.RawMessage
	err := json.Unmarshal(body, &m)
	if err != nil {
		return err
	}
	for k, v := range m {
		switch k {
		case "value":
			if v != nil {
				value, err := unmarshalBasicEnvironmentResourceArray(*v)
				if err != nil {
					return err
				}
				elr.Value = &value
			}
		}
	}

	return nil
}

// BasicEnvironmentResource an environment is a set of time-series data available for query, and is the top level Azure
// Time Series Insights resource.
type BasicEnvironmentResource interface {
	AsStandardEnvironmentResource() (*StandardEnvironmentResource, bool)
	AsLongTermEnvironmentResource() (*LongTermEnvironmentResource, bool)
	AsEnvironmentResource() (*EnvironmentResource, bool)
}

// EnvironmentResource an environment is a set of time-series data available for query, and is the top level
// Azure Time Series Insights resource.
type EnvironmentResource struct {
	autorest.Response `json:"-"`
	// Sku - The sku determines the type of environment, either standard (S1 or S2) or long-term (L1). For standard environments the sku determines the capacity of the environment, the ingress rate, and the billing rate.
	Sku *Sku `json:"sku,omitempty"`
	// Kind - Possible values include: 'KindBasicEnvironmentResourceKindEnvironmentResource', 'KindBasicEnvironmentResourceKindStandard', 'KindBasicEnvironmentResourceKindLongTerm'
	Kind KindBasicEnvironmentResource `json:"kind,omitempty"`
	// Location - Resource location
	Location *string `json:"location,omitempty"`
	// Tags - Resource tags
	Tags map[string]*string `json:"tags"`
	// ID - READ-ONLY; Resource Id
	ID *string `json:"id,omitempty"`
	// Name - READ-ONLY; Resource name
	Name *string `json:"name,omitempty"`
	// Type - READ-ONLY; Resource type
	Type *string `json:"type,omitempty"`
}

func unmarshalBasicEnvironmentResource(body []byte) (BasicEnvironmentResource, error) {
	var m map[string]interface{}
	err := json.Unmarshal(body, &m)
	if err != nil {
		return nil, err
	}

	switch m["kind"] {
	case string(KindBasicEnvironmentResourceKindStandard):
		var ser StandardEnvironmentResource
		err := json.Unmarshal(body, &ser)
		return ser, err
	case string(KindBasicEnvironmentResourceKindLongTerm):
		var lter LongTermEnvironmentResource
		err := json.Unmarshal(body, &lter)
		return lter, err
	default:
		var er EnvironmentResource
		err := json.Unmarshal(body, &er)
		return er, err
	}
}
func unmarshalBasicEnvironmentResourceArray(body []byte) ([]BasicEnvironmentResource, error) {
	var rawMessages []*json.RawMessage
	err := json.Unmarshal(body, &rawMessages)
	if err != nil {
		return nil, err
	}

	erArray := make([]BasicEnvironmentResource, len(rawMessages))

	for index, rawMessage := range rawMessages {
		er, err := unmarshalBasicEnvironmentResource(*rawMessage)
		if err != nil {
			return nil, err
		}
		erArray[index] = er
	}
	return erArray, nil
}

// MarshalJSON is the custom marshaler for EnvironmentResource.
func (er EnvironmentResource) MarshalJSON() ([]byte, error) {
	er.Kind = KindBasicEnvironmentResourceKindEnvironmentResource
	objectMap := make(map[string]interface{})
	if er.Sku != nil {
		objectMap["sku"] = er.Sku
	}
	if er.Kind != "" {
		objectMap["kind"] = er.Kind
	}
	if er.Location != nil {
		objectMap["location"] = er.Location
	}
	if er.Tags != nil {
		objectMap["tags"] = er.Tags
	}
	return json.Marshal(objectMap)
}

// AsStandardEnvironmentResource is the BasicEnvironmentResource implementation for EnvironmentResource.
func (er EnvironmentResource) AsStandardEnvironmentResource() (*StandardEnvironmentResource, bool) {
	return nil, false
}

// AsLongTermEnvironmentResource is the BasicEnvironmentResource implementation for EnvironmentResource.
func (er EnvironmentResource) AsLongTermEnvironmentResource() (*LongTermEnvironmentResource, bool) {
	return nil, false
}

// AsEnvironmentResource is the BasicEnvironmentResource implementation for EnvironmentResource.
func (er EnvironmentResource) AsEnvironmentResource() (*EnvironmentResource, bool) {
	return &er, true
}

// AsBasicEnvironmentResource is the BasicEnvironmentResource implementation for EnvironmentResource.
func (er EnvironmentResource) AsBasicEnvironmentResource() (BasicEnvironmentResource, bool) {
	return &er, true
}

// EnvironmentResourceModel ...
type EnvironmentResourceModel struct {
	autorest.Response `json:"-"`
	Value             BasicEnvironmentResource `json:"value,omitempty"`
}

// UnmarshalJSON is the custom unmarshaler for EnvironmentResourceModel struct.
func (erm *EnvironmentResourceModel) UnmarshalJSON(body []byte) error {
	er, err := unmarshalBasicEnvironmentResource(body)
	if err != nil {
		return err
	}
	erm.Value = er

	return nil
}

// EnvironmentResourceProperties properties of the environment.
type EnvironmentResourceProperties struct {
	// DataAccessID - READ-ONLY; An id used to access the environment data, e.g. to query the environment's events or upload reference data for the environment.
	DataAccessID *uuid.UUID `json:"dataAccessId,omitempty"`
	// DataAccessFqdn - READ-ONLY; The fully qualified domain name used to access the environment data, e.g. to query the environment's events or upload reference data for the environment.
	DataAccessFqdn *string `json:"dataAccessFqdn,omitempty"`
	// Status - An object that represents the status of the environment, and its internal state in the Time Series Insights service.
	Status *EnvironmentStatus `json:"status,omitempty"`
	// ProvisioningState - Provisioning state of the resource. Possible values include: 'Accepted', 'Creating', 'Updating', 'Succeeded', 'Failed', 'Deleting'
	ProvisioningState ProvisioningState `json:"provisioningState,omitempty"`
	// CreationTime - READ-ONLY; The time the resource was created.
	CreationTime *date.Time `json:"creationTime,omitempty"`
}

// MarshalJSON is the custom marshaler for EnvironmentResourceProperties.
func (erp EnvironmentResourceProperties) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if erp.Status != nil {
		objectMap["status"] = erp.Status
	}
	if erp.ProvisioningState != "" {
		objectMap["provisioningState"] = erp.ProvisioningState
	}
	return json.Marshal(objectMap)
}

// EnvironmentsCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a
// long-running operation.
type EnvironmentsCreateOrUpdateFuture struct {
	azure.FutureAPI
	// Result returns the result of the asynchronous operation.
	// If the operation has not completed it will return an error.
	Result func(EnvironmentsClient) (EnvironmentResourceModel, error)
}

// UnmarshalJSON is the custom unmarshaller for CreateFuture.
func (future *EnvironmentsCreateOrUpdateFuture) UnmarshalJSON(body []byte) error {
	var azFuture azure.Future
	if err := json.Unmarshal(body, &azFuture); err != nil {
		return err
	}
	future.FutureAPI = &azFuture
	future.Result = future.result
	return nil
}

// result is the default implementation for EnvironmentsCreateOrUpdateFuture.Result.
func (future *EnvironmentsCreateOrUpdateFuture) result(client EnvironmentsClient) (erm EnvironmentResourceModel, err error) {
	var done bool
	done, err = future.DoneWithContext(context.Background(), client)
	if err != nil {
		err = autorest.NewErrorWithError(err, "timeseriesinsights.EnvironmentsCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
		return
	}
	if !done {
		erm.Response.Response = future.Response()
		err = azure.NewAsyncOpIncompleteError("timeseriesinsights.EnvironmentsCreateOrUpdateFuture")
		return
	}
	sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
	if erm.Response.Response, err = future.GetResult(sender); err == nil && erm.Response.Response.StatusCode != http.StatusNoContent {
		erm, err = client.CreateOrUpdateResponder(erm.Response.Response)
		if err != nil {
			err = autorest.NewErrorWithError(err, "timeseriesinsights.EnvironmentsCreateOrUpdateFuture", "Result", erm.Response.Response, "Failure responding to request")
		}
	}
	return
}

// EnvironmentStateDetails an object that contains the details about an environment's state.
type EnvironmentStateDetails struct {
	// Code - Contains the code that represents the reason of an environment being in a particular state. Can be used to programmatically handle specific cases.
	Code *string `json:"code,omitempty"`
	// Message - A message that describes the state in detail.
	Message *string `json:"message,omitempty"`
}

// EnvironmentStatus an object that represents the status of the environment, and its internal state in the
// Time Series Insights service.
type EnvironmentStatus struct {
	// Ingress - An object that represents the status of ingress on an environment.
	Ingress *IngressEnvironmentStatus `json:"ingress,omitempty"`
	// WarmStorage - An object that represents the status of warm storage on an environment.
	WarmStorage *WarmStorageEnvironmentStatus `json:"warmStorage,omitempty"`
}

// EnvironmentsUpdateFuture an abstraction for monitoring and retrieving the results of a long-running
// operation.
type EnvironmentsUpdateFuture struct {
	azure.FutureAPI
	// Result returns the result of the asynchronous operation.
	// If the operation has not completed it will return an error.
	Result func(EnvironmentsClient) (EnvironmentResourceModel, error)
}

// UnmarshalJSON is the custom unmarshaller for CreateFuture.
func (future *EnvironmentsUpdateFuture) UnmarshalJSON(body []byte) error {
	var azFuture azure.Future
	if err := json.Unmarshal(body, &azFuture); err != nil {
		return err
	}
	future.FutureAPI = &azFuture
	future.Result = future.result
	return nil
}

// result is the default implementation for EnvironmentsUpdateFuture.Result.
func (future *EnvironmentsUpdateFuture) result(client EnvironmentsClient) (erm EnvironmentResourceModel, err error) {
	var done bool
	done, err = future.DoneWithContext(context.Background(), client)
	if err != nil {
		err = autorest.NewErrorWithError(err, "timeseriesinsights.EnvironmentsUpdateFuture", "Result", future.Response(), "Polling failure")
		return
	}
	if !done {
		erm.Response.Response = future.Response()
		err = azure.NewAsyncOpIncompleteError("timeseriesinsights.EnvironmentsUpdateFuture")
		return
	}
	sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
	if erm.Response.Response, err = future.GetResult(sender); err == nil && erm.Response.Response.StatusCode != http.StatusNoContent {
		erm, err = client.UpdateResponder(erm.Response.Response)
		if err != nil {
			err = autorest.NewErrorWithError(err, "timeseriesinsights.EnvironmentsUpdateFuture", "Result", erm.Response.Response, "Failure responding to request")
		}
	}
	return
}

// EnvironmentUpdateParameters parameters supplied to the Update Environment operation.
type EnvironmentUpdateParameters struct {
	// Tags - Key-value pairs of additional properties for the environment.
	Tags map[string]*string `json:"tags"`
}

// MarshalJSON is the custom marshaler for EnvironmentUpdateParameters.
func (eup EnvironmentUpdateParameters) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if eup.Tags != nil {
		objectMap["tags"] = eup.Tags
	}
	return json.Marshal(objectMap)
}

// EventHubEventSourceCommonProperties properties of the EventHub event source.
type EventHubEventSourceCommonProperties struct {
	// ServiceBusNamespace - The name of the service bus that contains the event hub.
	ServiceBusNamespace *string `json:"serviceBusNamespace,omitempty"`
	// EventHubName - The name of the event hub.
	EventHubName *string `json:"eventHubName,omitempty"`
	// ConsumerGroupName - The name of the event hub's consumer group that holds the partitions from which events will be read.
	ConsumerGroupName *string `json:"consumerGroupName,omitempty"`
	// KeyName - The name of the SAS key that grants the Time Series Insights service access to the event hub. The shared access policies for this key must grant 'Listen' permissions to the event hub.
	KeyName *string `json:"keyName,omitempty"`
	// EventSourceResourceID - The resource id of the event source in Azure Resource Manager.
	EventSourceResourceID *string `json:"eventSourceResourceId,omitempty"`
	// TimestampPropertyName - The event property that will be used as the event source's timestamp. If a value isn't specified for timestampPropertyName, or if null or empty-string is specified, the event creation time will be used.
	TimestampPropertyName *string `json:"timestampPropertyName,omitempty"`
	// ProvisioningState - Provisioning state of the resource. Possible values include: 'Accepted', 'Creating', 'Updating', 'Succeeded', 'Failed', 'Deleting'
	ProvisioningState ProvisioningState `json:"provisioningState,omitempty"`
	// CreationTime - READ-ONLY; The time the resource was created.
	CreationTime *date.Time `json:"creationTime,omitempty"`
}

// MarshalJSON is the custom marshaler for EventHubEventSourceCommonProperties.
func (ehescp EventHubEventSourceCommonProperties) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if ehescp.ServiceBusNamespace != nil {
		objectMap["serviceBusNamespace"] = ehescp.ServiceBusNamespace
	}
	if ehescp.EventHubName != nil {
		objectMap["eventHubName"] = ehescp.EventHubName
	}
	if ehescp.ConsumerGroupName != nil {
		objectMap["consumerGroupName"] = ehescp.ConsumerGroupName
	}
	if ehescp.KeyName != nil {
		objectMap["keyName"] = ehescp.KeyName
	}
	if ehescp.EventSourceResourceID != nil {
		objectMap["eventSourceResourceId"] = ehescp.EventSourceResourceID
	}
	if ehescp.TimestampPropertyName != nil {
		objectMap["timestampPropertyName"] = ehescp.TimestampPropertyName
	}
	if ehescp.ProvisioningState != "" {
		objectMap["provisioningState"] = ehescp.ProvisioningState
	}
	return json.Marshal(objectMap)
}

// EventHubEventSourceCreateOrUpdateParameters parameters supplied to the Create or Update Event Source
// operation for an EventHub event source.
type EventHubEventSourceCreateOrUpdateParameters struct {
	*EventHubEventSourceCreationProperties `json:"properties,omitempty"`
	// LocalTimestamp - An object that represents the local timestamp property. It contains the format of local timestamp that needs to be used and the corresponding timezone offset information. If a value isn't specified for localTimestamp, or if null, then the local timestamp will not be ingressed with the events.
	LocalTimestamp *LocalTimestamp `json:"localTimestamp,omitempty"`
	// Location - The location of the resource.
	Location *string `json:"location,omitempty"`
	// Tags - Key-value pairs of additional properties for the resource.
	Tags map[string]*string `json:"tags"`
	// Kind - Possible values include: 'KindEventSourceCreateOrUpdateParameters', 'KindMicrosoftEventHub', 'KindMicrosoftIoTHub'
	Kind KindBasicEventSourceCreateOrUpdateParameters `json:"kind,omitempty"`
}

// MarshalJSON is the custom marshaler for EventHubEventSourceCreateOrUpdateParameters.
func (ehescoup EventHubEventSourceCreateOrUpdateParameters) MarshalJSON() ([]byte, error) {
	ehescoup.Kind = KindMicrosoftEventHub
	objectMap := make(map[string]interface{})
	if ehescoup.EventHubEventSourceCreationProperties != nil {
		objectMap["properties"] = ehescoup.EventHubEventSourceCreationProperties
	}
	if ehescoup.LocalTimestamp != nil {
		objectMap["localTimestamp"] = ehescoup.LocalTimestamp
	}
	if ehescoup.Kind != "" {
		objectMap["kind"] = ehescoup.Kind
	}
	if ehescoup.Location != nil {
		objectMap["location"] = ehescoup.Location
	}
	if ehescoup.Tags != nil {
		objectMap["tags"] = ehescoup.Tags
	}
	return json.Marshal(objectMap)
}

// AsEventHubEventSourceCreateOrUpdateParameters is the BasicEventSourceCreateOrUpdateParameters implementation for EventHubEventSourceCreateOrUpdateParameters.
func (ehescoup EventHubEventSourceCreateOrUpdateParameters) AsEventHubEventSourceCreateOrUpdateParameters() (*EventHubEventSourceCreateOrUpdateParameters, bool) {
	return &ehescoup, true
}

// AsIoTHubEventSourceCreateOrUpdateParameters is the BasicEventSourceCreateOrUpdateParameters implementation for EventHubEventSourceCreateOrUpdateParameters.
func (ehescoup EventHubEventSourceCreateOrUpdateParameters) AsIoTHubEventSourceCreateOrUpdateParameters() (*IoTHubEventSourceCreateOrUpdateParameters, bool) {
	return nil, false
}

// AsEventSourceCreateOrUpdateParameters is the BasicEventSourceCreateOrUpdateParameters implementation for EventHubEventSourceCreateOrUpdateParameters.
func (ehescoup EventHubEventSourceCreateOrUpdateParameters) AsEventSourceCreateOrUpdateParameters() (*EventSourceCreateOrUpdateParameters, bool) {
	return nil, false
}

// AsBasicEventSourceCreateOrUpdateParameters is the BasicEventSourceCreateOrUpdateParameters implementation for EventHubEventSourceCreateOrUpdateParameters.
func (ehescoup EventHubEventSourceCreateOrUpdateParameters) AsBasicEventSourceCreateOrUpdateParameters() (BasicEventSourceCreateOrUpdateParameters, bool) {
	return &ehescoup, true
}

// UnmarshalJSON is the custom unmarshaler for EventHubEventSourceCreateOrUpdateParameters struct.
func (ehescoup *EventHubEventSourceCreateOrUpdateParameters) UnmarshalJSON(body []byte) error {
	var m map[string]*json.RawMessage
	err := json.Unmarshal(body, &m)
	if err != nil {
		return err
	}
	for k, v := range m {
		switch k {
		case "properties":
			if v != nil {
				var eventHubEventSourceCreationProperties EventHubEventSourceCreationProperties
				err = json.Unmarshal(*v, &eventHubEventSourceCreationProperties)
				if err != nil {
					return err
				}
				ehescoup.EventHubEventSourceCreationProperties = &eventHubEventSourceCreationProperties
			}
		case "localTimestamp":
			if v != nil {
				var localTimestamp LocalTimestamp
				err = json.Unmarshal(*v, &localTimestamp)
				if err != nil {
					return err
				}
				ehescoup.LocalTimestamp = &localTimestamp
			}
		case "kind":
			if v != nil {
				var kind KindBasicEventSourceCreateOrUpdateParameters
				err = json.Unmarshal(*v, &kind)
				if err != nil {
					return err
				}
				ehescoup.Kind = kind
			}
		case "location":
			if v != nil {
				var location string
				err = json.Unmarshal(*v, &location)
				if err != nil {
					return err
				}
				ehescoup.Location = &location
			}
		case "tags":
			if v != nil {
				var tags map[string]*string
				err = json.Unmarshal(*v, &tags)
				if err != nil {
					return err
				}
				ehescoup.Tags = tags
			}
		}
	}

	return nil
}

// EventHubEventSourceCreationProperties properties of the EventHub event source that are required on
// create or update requests.
type EventHubEventSourceCreationProperties struct {
	// SharedAccessKey - The value of the shared access key that grants the Time Series Insights service read access to the event hub. This property is not shown in event source responses.
	SharedAccessKey *string `json:"sharedAccessKey,omitempty"`
	// ServiceBusNamespace - The name of the service bus that contains the event hub.
	ServiceBusNamespace *string `json:"serviceBusNamespace,omitempty"`
	// EventHubName - The name of the event hub.
	EventHubName *string `json:"eventHubName,omitempty"`
	// ConsumerGroupName - The name of the event hub's consumer group that holds the partitions from which events will be read.
	ConsumerGroupName *string `json:"consumerGroupName,omitempty"`
	// KeyName - The name of the SAS key that grants the Time Series Insights service access to the event hub. The shared access policies for this key must grant 'Listen' permissions to the event hub.
	KeyName *string `json:"keyName,omitempty"`
	// EventSourceResourceID - The resource id of the event source in Azure Resource Manager.
	EventSourceResourceID *string `json:"eventSourceResourceId,omitempty"`
	// TimestampPropertyName - The event property that will be used as the event source's timestamp. If a value isn't specified for timestampPropertyName, or if null or empty-string is specified, the event creation time will be used.
	TimestampPropertyName *string `json:"timestampPropertyName,omitempty"`
	// ProvisioningState - Provisioning state of the resource. Possible values include: 'Accepted', 'Creating', 'Updating', 'Succeeded', 'Failed', 'Deleting'
	ProvisioningState ProvisioningState `json:"provisioningState,omitempty"`
	// CreationTime - READ-ONLY; The time the resource was created.
	CreationTime *date.Time `json:"creationTime,omitempty"`
}

// MarshalJSON is the custom marshaler for EventHubEventSourceCreationProperties.
func (ehescp EventHubEventSourceCreationProperties) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if ehescp.SharedAccessKey != nil {
		objectMap["sharedAccessKey"] = ehescp.SharedAccessKey
	}
	if ehescp.ServiceBusNamespace != nil {
		objectMap["serviceBusNamespace"] = ehescp.ServiceBusNamespace
	}
	if ehescp.EventHubName != nil {
		objectMap["eventHubName"] = ehescp.EventHubName
	}
	if ehescp.ConsumerGroupName != nil {
		objectMap["consumerGroupName"] = ehescp.ConsumerGroupName
	}
	if ehescp.KeyName != nil {
		objectMap["keyName"] = ehescp.KeyName
	}
	if ehescp.EventSourceResourceID != nil {
		objectMap["eventSourceResourceId"] = ehescp.EventSourceResourceID
	}
	if ehescp.TimestampPropertyName != nil {
		objectMap["timestampPropertyName"] = ehescp.TimestampPropertyName
	}
	if ehescp.ProvisioningState != "" {
		objectMap["provisioningState"] = ehescp.ProvisioningState
	}
	return json.Marshal(objectMap)
}

// EventHubEventSourceMutableProperties an object that represents a set of mutable EventHub event source
// resource properties.
type EventHubEventSourceMutableProperties struct {
	// SharedAccessKey - The value of the shared access key that grants the Time Series Insights service read access to the event hub. This property is not shown in event source responses.
	SharedAccessKey *string `json:"sharedAccessKey,omitempty"`
	// TimestampPropertyName - The event property that will be used as the event source's timestamp. If a value isn't specified for timestampPropertyName, or if null or empty-string is specified, the event creation time will be used.
	TimestampPropertyName *string `json:"timestampPropertyName,omitempty"`
	// LocalTimestamp - An object that represents the local timestamp property. It contains the format of local timestamp that needs to be used and the corresponding timezone offset information. If a value isn't specified for localTimestamp, or if null, then the local timestamp will not be ingressed with the events.
	LocalTimestamp *LocalTimestamp `json:"localTimestamp,omitempty"`
}

// EventHubEventSourceResource an event source that receives its data from an Azure EventHub.
type EventHubEventSourceResource struct {
	*EventHubEventSourceResourceProperties `json:"properties,omitempty"`
	// Location - Resource location
	Location *string `json:"location,omitempty"`
	// Tags - Resource tags
	Tags map[string]*string `json:"tags"`
	// ID - READ-ONLY; Resource Id
	ID *string `json:"id,omitempty"`
	// Name - READ-ONLY; Resource name
	Name *string `json:"name,omitempty"`
	// Type - READ-ONLY; Resource type
	Type *string `json:"type,omitempty"`
	// Kind - Possible values include: 'KindBasicEventSourceResourceKindEventSourceResource', 'KindBasicEventSourceResourceKindMicrosoftEventHub', 'KindBasicEventSourceResourceKindMicrosoftIoTHub'
	Kind KindBasicEventSourceResource `json:"kind,omitempty"`
}

// MarshalJSON is the custom marshaler for EventHubEventSourceResource.
func (ehesr EventHubEventSourceResource) MarshalJSON() ([]byte, error) {
	ehesr.Kind = KindBasicEventSourceResourceKindMicrosoftEventHub
	objectMap := make(map[string]interface{})
	if ehesr.EventHubEventSourceResourceProperties != nil {
		objectMap["properties"] = ehesr.EventHubEventSourceResourceProperties
	}
	if ehesr.Kind != "" {
		objectMap["kind"] = ehesr.Kind
	}
	if ehesr.Location != nil {
		objectMap["location"] = ehesr.Location
	}
	if ehesr.Tags != nil {
		objectMap["tags"] = ehesr.Tags
	}
	return json.Marshal(objectMap)
}

// AsEventHubEventSourceResource is the BasicEventSourceResource implementation for EventHubEventSourceResource.
func (ehesr EventHubEventSourceResource) AsEventHubEventSourceResource() (*EventHubEventSourceResource, bool) {
	return &ehesr, true
}

// AsIoTHubEventSourceResource is the BasicEventSourceResource implementation for EventHubEventSourceResource.
func (ehesr EventHubEventSourceResource) AsIoTHubEventSourceResource() (*IoTHubEventSourceResource, bool) {
	return nil, false
}

// AsEventSourceResource is the BasicEventSourceResource implementation for EventHubEventSourceResource.
func (ehesr EventHubEventSourceResource) AsEventSourceResource() (*EventSourceResource, bool) {
	return nil, false
}

// AsBasicEventSourceResource is the BasicEventSourceResource implementation for EventHubEventSourceResource.
func (ehesr EventHubEventSourceResource) AsBasicEventSourceResource() (BasicEventSourceResource, bool) {
	return &ehesr, true
}

// UnmarshalJSON is the custom unmarshaler for EventHubEventSourceResource struct.
func (ehesr *EventHubEventSourceResource) UnmarshalJSON(body []byte) error {
	var m map[string]*json.RawMessage
	err := json.Unmarshal(body, &m)
	if err != nil {
		return err
	}
	for k, v := range m {
		switch k {
		case "properties":
			if v != nil {
				var eventHubEventSourceResourceProperties EventHubEventSourceResourceProperties
				err = json.Unmarshal(*v, &eventHubEventSourceResourceProperties)
				if err != nil {
					return err
				}
				ehesr.EventHubEventSourceResourceProperties = &eventHubEventSourceResourceProperties
			}
		case "kind":
			if v != nil {
				var kind KindBasicEventSourceResource
				err = json.Unmarshal(*v, &kind)
				if err != nil {
					return err
				}
				ehesr.Kind = kind
			}
		case "location":
			if v != nil {
				var location string
				err = json.Unmarshal(*v, &location)
				if err != nil {
					return err
				}
				ehesr.Location = &location
			}
		case "tags":
			if v != nil {
				var tags map[string]*string
				err = json.Unmarshal(*v, &tags)
				if err != nil {
					return err
				}
				ehesr.Tags = tags
			}
		case "id":
			if v != nil {
				var ID string
				err = json.Unmarshal(*v, &ID)
				if err != nil {
					return err
				}
				ehesr.ID = &ID
			}
		case "name":
			if v != nil {
				var name string
				err = json.Unmarshal(*v, &name)
				if err != nil {
					return err
				}
				ehesr.Name = &name
			}
		case "type":
			if v != nil {
				var typeVar string
				err = json.Unmarshal(*v, &typeVar)
				if err != nil {
					return err
				}
				ehesr.Type = &typeVar
			}
		}
	}

	return nil
}

// EventHubEventSourceResourceProperties properties of the EventHub event source resource.
type EventHubEventSourceResourceProperties struct {
	// ServiceBusNamespace - The name of the service bus that contains the event hub.
	ServiceBusNamespace *string `json:"serviceBusNamespace,omitempty"`
	// EventHubName - The name of the event hub.
	EventHubName *string `json:"eventHubName,omitempty"`
	// ConsumerGroupName - The name of the event hub's consumer group that holds the partitions from which events will be read.
	ConsumerGroupName *string `json:"consumerGroupName,omitempty"`
	// KeyName - The name of the SAS key that grants the Time Series Insights service access to the event hub. The shared access policies for this key must grant 'Listen' permissions to the event hub.
	KeyName *string `json:"keyName,omitempty"`
	// EventSourceResourceID - The resource id of the event source in Azure Resource Manager.
	EventSourceResourceID *string `json:"eventSourceResourceId,omitempty"`
	// TimestampPropertyName - The event property that will be used as the event source's timestamp. If a value isn't specified for timestampPropertyName, or if null or empty-string is specified, the event creation time will be used.
	TimestampPropertyName *string `json:"timestampPropertyName,omitempty"`
	// ProvisioningState - Provisioning state of the resource. Possible values include: 'Accepted', 'Creating', 'Updating', 'Succeeded', 'Failed', 'Deleting'
	ProvisioningState ProvisioningState `json:"provisioningState,omitempty"`
	// CreationTime - READ-ONLY; The time the resource was created.
	CreationTime *date.Time `json:"creationTime,omitempty"`
}

// MarshalJSON is the custom marshaler for EventHubEventSourceResourceProperties.
func (ehesrp EventHubEventSourceResourceProperties) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if ehesrp.ServiceBusNamespace != nil {
		objectMap["serviceBusNamespace"] = ehesrp.ServiceBusNamespace
	}
	if ehesrp.EventHubName != nil {
		objectMap["eventHubName"] = ehesrp.EventHubName
	}
	if ehesrp.ConsumerGroupName != nil {
		objectMap["consumerGroupName"] = ehesrp.ConsumerGroupName
	}
	if ehesrp.KeyName != nil {
		objectMap["keyName"] = ehesrp.KeyName
	}
	if ehesrp.EventSourceResourceID != nil {
		objectMap["eventSourceResourceId"] = ehesrp.EventSourceResourceID
	}
	if ehesrp.TimestampPropertyName != nil {
		objectMap["timestampPropertyName"] = ehesrp.TimestampPropertyName
	}
	if ehesrp.ProvisioningState != "" {
		objectMap["provisioningState"] = ehesrp.ProvisioningState
	}
	return json.Marshal(objectMap)
}

// EventHubEventSourceUpdateParameters parameters supplied to the Update Event Source operation to update
// an EventHub event source.
type EventHubEventSourceUpdateParameters struct {
	// EventHubEventSourceMutableProperties - Properties of the EventHub event source.
	*EventHubEventSourceMutableProperties `json:"properties,omitempty"`
	// Tags - Key-value pairs of additional properties for the event source.
	Tags map[string]*string `json:"tags"`
}

// MarshalJSON is the custom marshaler for EventHubEventSourceUpdateParameters.
func (ehesup EventHubEventSourceUpdateParameters) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if ehesup.EventHubEventSourceMutableProperties != nil {
		objectMap["properties"] = ehesup.EventHubEventSourceMutableProperties
	}
	if ehesup.Tags != nil {
		objectMap["tags"] = ehesup.Tags
	}
	return json.Marshal(objectMap)
}

// UnmarshalJSON is the custom unmarshaler for EventHubEventSourceUpdateParameters struct.
func (ehesup *EventHubEventSourceUpdateParameters) UnmarshalJSON(body []byte) error {
	var m map[string]*json.RawMessage
	err := json.Unmarshal(body, &m)
	if err != nil {
		return err
	}
	for k, v := range m {
		switch k {
		case "properties":
			if v != nil {
				var eventHubEventSourceMutableProperties EventHubEventSourceMutableProperties
				err = json.Unmarshal(*v, &eventHubEventSourceMutableProperties)
				if err != nil {
					return err
				}
				ehesup.EventHubEventSourceMutableProperties = &eventHubEventSourceMutableProperties
			}
		case "tags":
			if v != nil {
				var tags map[string]*string
				err = json.Unmarshal(*v, &tags)
				if err != nil {
					return err
				}
				ehesup.Tags = tags
			}
		}
	}

	return nil
}

// EventSourceCommonProperties properties of the event source.
type EventSourceCommonProperties struct {
	// TimestampPropertyName - The event property that will be used as the event source's timestamp. If a value isn't specified for timestampPropertyName, or if null or empty-string is specified, the event creation time will be used.
	TimestampPropertyName *string `json:"timestampPropertyName,omitempty"`
	// ProvisioningState - Provisioning state of the resource. Possible values include: 'Accepted', 'Creating', 'Updating', 'Succeeded', 'Failed', 'Deleting'
	ProvisioningState ProvisioningState `json:"provisioningState,omitempty"`
	// CreationTime - READ-ONLY; The time the resource was created.
	CreationTime *date.Time `json:"creationTime,omitempty"`
}

// MarshalJSON is the custom marshaler for EventSourceCommonProperties.
func (escp EventSourceCommonProperties) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if escp.TimestampPropertyName != nil {
		objectMap["timestampPropertyName"] = escp.TimestampPropertyName
	}
	if escp.ProvisioningState != "" {
		objectMap["provisioningState"] = escp.ProvisioningState
	}
	return json.Marshal(objectMap)
}

// BasicEventSourceCreateOrUpdateParameters parameters supplied to the Create or Update Event Source operation.
type BasicEventSourceCreateOrUpdateParameters interface {
	AsEventHubEventSourceCreateOrUpdateParameters() (*EventHubEventSourceCreateOrUpdateParameters, bool)
	AsIoTHubEventSourceCreateOrUpdateParameters() (*IoTHubEventSourceCreateOrUpdateParameters, bool)
	AsEventSourceCreateOrUpdateParameters() (*EventSourceCreateOrUpdateParameters, bool)
}

// EventSourceCreateOrUpdateParameters parameters supplied to the Create or Update Event Source operation.
type EventSourceCreateOrUpdateParameters struct {
	// LocalTimestamp - An object that represents the local timestamp property. It contains the format of local timestamp that needs to be used and the corresponding timezone offset information. If a value isn't specified for localTimestamp, or if null, then the local timestamp will not be ingressed with the events.
	LocalTimestamp *LocalTimestamp `json:"localTimestamp,omitempty"`
	// Kind - Possible values include: 'KindEventSourceCreateOrUpdateParameters', 'KindMicrosoftEventHub', 'KindMicrosoftIoTHub'
	Kind KindBasicEventSourceCreateOrUpdateParameters `json:"kind,omitempty"`
	// Location - The location of the resource.
	Location *string `json:"location,omitempty"`
	// Tags - Key-value pairs of additional properties for the resource.
	Tags map[string]*string `json:"tags"`
}

func unmarshalBasicEventSourceCreateOrUpdateParameters(body []byte) (BasicEventSourceCreateOrUpdateParameters, error) {
	var m map[string]interface{}
	err := json.Unmarshal(body, &m)
	if err != nil {
		return nil, err
	}

	switch m["kind"] {
	case string(KindMicrosoftEventHub):
		var ehescoup EventHubEventSourceCreateOrUpdateParameters
		err := json.Unmarshal(body, &ehescoup)
		return ehescoup, err
	case string(KindMicrosoftIoTHub):
		var ithescoup IoTHubEventSourceCreateOrUpdateParameters
		err := json.Unmarshal(body, &ithescoup)
		return ithescoup, err
	default:
		var escoup EventSourceCreateOrUpdateParameters
		err := json.Unmarshal(body, &escoup)
		return escoup, err
	}
}
func unmarshalBasicEventSourceCreateOrUpdateParametersArray(body []byte) ([]BasicEventSourceCreateOrUpdateParameters, error) {
	var rawMessages []*json.RawMessage
	err := json.Unmarshal(body, &rawMessages)
	if err != nil {
		return nil, err
	}

	escoupArray := make([]BasicEventSourceCreateOrUpdateParameters, len(rawMessages))

	for index, rawMessage := range rawMessages {
		escoup, err := unmarshalBasicEventSourceCreateOrUpdateParameters(*rawMessage)
		if err != nil {
			return nil, err
		}
		escoupArray[index] = escoup
	}
	return escoupArray, nil
}

// MarshalJSON is the custom marshaler for EventSourceCreateOrUpdateParameters.
func (escoup EventSourceCreateOrUpdateParameters) MarshalJSON() ([]byte, error) {
	escoup.Kind = KindEventSourceCreateOrUpdateParameters
	objectMap := make(map[string]interface{})
	if escoup.LocalTimestamp != nil {
		objectMap["localTimestamp"] = escoup.LocalTimestamp
	}
	if escoup.Kind != "" {
		objectMap["kind"] = escoup.Kind
	}
	if escoup.Location != nil {
		objectMap["location"] = escoup.Location
	}
	if escoup.Tags != nil {
		objectMap["tags"] = escoup.Tags
	}
	return json.Marshal(objectMap)
}

// AsEventHubEventSourceCreateOrUpdateParameters is the BasicEventSourceCreateOrUpdateParameters implementation for EventSourceCreateOrUpdateParameters.
func (escoup EventSourceCreateOrUpdateParameters) AsEventHubEventSourceCreateOrUpdateParameters() (*EventHubEventSourceCreateOrUpdateParameters, bool) {
	return nil, false
}

// AsIoTHubEventSourceCreateOrUpdateParameters is the BasicEventSourceCreateOrUpdateParameters implementation for EventSourceCreateOrUpdateParameters.
func (escoup EventSourceCreateOrUpdateParameters) AsIoTHubEventSourceCreateOrUpdateParameters() (*IoTHubEventSourceCreateOrUpdateParameters, bool) {
	return nil, false
}

// AsEventSourceCreateOrUpdateParameters is the BasicEventSourceCreateOrUpdateParameters implementation for EventSourceCreateOrUpdateParameters.
func (escoup EventSourceCreateOrUpdateParameters) AsEventSourceCreateOrUpdateParameters() (*EventSourceCreateOrUpdateParameters, bool) {
	return &escoup, true
}

// AsBasicEventSourceCreateOrUpdateParameters is the BasicEventSourceCreateOrUpdateParameters implementation for EventSourceCreateOrUpdateParameters.
func (escoup EventSourceCreateOrUpdateParameters) AsBasicEventSourceCreateOrUpdateParameters() (BasicEventSourceCreateOrUpdateParameters, bool) {
	return &escoup, true
}

// EventSourceListResponse the response of the List EventSources operation.
type EventSourceListResponse struct {
	autorest.Response `json:"-"`
	// Value - Result of the List EventSources operation.
	Value *[]BasicEventSourceResource `json:"value,omitempty"`
}

// UnmarshalJSON is the custom unmarshaler for EventSourceListResponse struct.
func (eslr *EventSourceListResponse) UnmarshalJSON(body []byte) error {
	var m map[string]*json.RawMessage
	err := json.Unmarshal(body, &m)
	if err != nil {
		return err
	}
	for k, v := range m {
		switch k {
		case "value":
			if v != nil {
				value, err := unmarshalBasicEventSourceResourceArray(*v)
				if err != nil {
					return err
				}
				eslr.Value = &value
			}
		}
	}

	return nil
}

// EventSourceMutableProperties an object that represents a set of mutable event source resource
// properties.
type EventSourceMutableProperties struct {
	// TimestampPropertyName - The event property that will be used as the event source's timestamp. If a value isn't specified for timestampPropertyName, or if null or empty-string is specified, the event creation time will be used.
	TimestampPropertyName *string `json:"timestampPropertyName,omitempty"`
	// LocalTimestamp - An object that represents the local timestamp property. It contains the format of local timestamp that needs to be used and the corresponding timezone offset information. If a value isn't specified for localTimestamp, or if null, then the local timestamp will not be ingressed with the events.
	LocalTimestamp *LocalTimestamp `json:"localTimestamp,omitempty"`
}

// BasicEventSourceResource an environment receives data from one or more event sources. Each event source has
// associated connection info that allows the Time Series Insights ingress pipeline to connect to and pull data from
// the event source
type BasicEventSourceResource interface {
	AsEventHubEventSourceResource() (*EventHubEventSourceResource, bool)
	AsIoTHubEventSourceResource() (*IoTHubEventSourceResource, bool)
	AsEventSourceResource() (*EventSourceResource, bool)
}

// EventSourceResource an environment receives data from one or more event sources. Each event source has
// associated connection info that allows the Time Series Insights ingress pipeline to connect to and pull data
// from the event source
type EventSourceResource struct {
	autorest.Response `json:"-"`
	// Kind - Possible values include: 'KindBasicEventSourceResourceKindEventSourceResource', 'KindBasicEventSourceResourceKindMicrosoftEventHub', 'KindBasicEventSourceResourceKindMicrosoftIoTHub'
	Kind KindBasicEventSourceResource `json:"kind,omitempty"`
	// Location - Resource location
	Location *string `json:"location,omitempty"`
	// Tags - Resource tags
	Tags map[string]*string `json:"tags"`
	// ID - READ-ONLY; Resource Id
	ID *string `json:"id,omitempty"`
	// Name - READ-ONLY; Resource name
	Name *string `json:"name,omitempty"`
	// Type - READ-ONLY; Resource type
	Type *string `json:"type,omitempty"`
}

func unmarshalBasicEventSourceResource(body []byte) (BasicEventSourceResource, error) {
	var m map[string]interface{}
	err := json.Unmarshal(body, &m)
	if err != nil {
		return nil, err
	}

	switch m["kind"] {
	case string(KindBasicEventSourceResourceKindMicrosoftEventHub):
		var ehesr EventHubEventSourceResource
		err := json.Unmarshal(body, &ehesr)
		return ehesr, err
	case string(KindBasicEventSourceResourceKindMicrosoftIoTHub):
		var ithesr IoTHubEventSourceResource
		err := json.Unmarshal(body, &ithesr)
		return ithesr, err
	default:
		var esr EventSourceResource
		err := json.Unmarshal(body, &esr)
		return esr, err
	}
}
func unmarshalBasicEventSourceResourceArray(body []byte) ([]BasicEventSourceResource, error) {
	var rawMessages []*json.RawMessage
	err := json.Unmarshal(body, &rawMessages)
	if err != nil {
		return nil, err
	}

	esrArray := make([]BasicEventSourceResource, len(rawMessages))

	for index, rawMessage := range rawMessages {
		esr, err := unmarshalBasicEventSourceResource(*rawMessage)
		if err != nil {
			return nil, err
		}
		esrArray[index] = esr
	}
	return esrArray, nil
}

// MarshalJSON is the custom marshaler for EventSourceResource.
func (esr EventSourceResource) MarshalJSON() ([]byte, error) {
	esr.Kind = KindBasicEventSourceResourceKindEventSourceResource
	objectMap := make(map[string]interface{})
	if esr.Kind != "" {
		objectMap["kind"] = esr.Kind
	}
	if esr.Location != nil {
		objectMap["location"] = esr.Location
	}
	if esr.Tags != nil {
		objectMap["tags"] = esr.Tags
	}
	return json.Marshal(objectMap)
}

// AsEventHubEventSourceResource is the BasicEventSourceResource implementation for EventSourceResource.
func (esr EventSourceResource) AsEventHubEventSourceResource() (*EventHubEventSourceResource, bool) {
	return nil, false
}

// AsIoTHubEventSourceResource is the BasicEventSourceResource implementation for EventSourceResource.
func (esr EventSourceResource) AsIoTHubEventSourceResource() (*IoTHubEventSourceResource, bool) {
	return nil, false
}

// AsEventSourceResource is the BasicEventSourceResource implementation for EventSourceResource.
func (esr EventSourceResource) AsEventSourceResource() (*EventSourceResource, bool) {
	return &esr, true
}

// AsBasicEventSourceResource is the BasicEventSourceResource implementation for EventSourceResource.
func (esr EventSourceResource) AsBasicEventSourceResource() (BasicEventSourceResource, bool) {
	return &esr, true
}

// EventSourceResourceModel ...
type EventSourceResourceModel struct {
	autorest.Response `json:"-"`
	Value             BasicEventSourceResource `json:"value,omitempty"`
}

// UnmarshalJSON is the custom unmarshaler for EventSourceResourceModel struct.
func (esrm *EventSourceResourceModel) UnmarshalJSON(body []byte) error {
	esr, err := unmarshalBasicEventSourceResource(body)
	if err != nil {
		return err
	}
	esrm.Value = esr

	return nil
}

// EventSourceUpdateParameters parameters supplied to the Update Event Source operation.
type EventSourceUpdateParameters struct {
	// Tags - Key-value pairs of additional properties for the event source.
	Tags map[string]*string `json:"tags"`
}

// MarshalJSON is the custom marshaler for EventSourceUpdateParameters.
func (esup EventSourceUpdateParameters) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if esup.Tags != nil {
		objectMap["tags"] = esup.Tags
	}
	return json.Marshal(objectMap)
}

// IngressEnvironmentStatus an object that represents the status of ingress on an environment.
type IngressEnvironmentStatus struct {
	// State - This string represents the state of ingress operations on an environment. It can be "Disabled", "Ready", "Running", "Paused" or "Unknown". Possible values include: 'Disabled', 'Ready', 'Running', 'Paused', 'Unknown'
	State IngressState `json:"state,omitempty"`
	// StateDetails - An object that contains the details about an environment's state.
	StateDetails *EnvironmentStateDetails `json:"stateDetails,omitempty"`
}

// IoTHubEventSourceCommonProperties properties of the IoTHub event source.
type IoTHubEventSourceCommonProperties struct {
	// IotHubName - The name of the iot hub.
	IotHubName *string `json:"iotHubName,omitempty"`
	// ConsumerGroupName - The name of the iot hub's consumer group that holds the partitions from which events will be read.
	ConsumerGroupName *string `json:"consumerGroupName,omitempty"`
	// KeyName - The name of the Shared Access Policy key that grants the Time Series Insights service access to the iot hub. This shared access policy key must grant 'service connect' permissions to the iot hub.
	KeyName *string `json:"keyName,omitempty"`
	// EventSourceResourceID - The resource id of the event source in Azure Resource Manager.
	EventSourceResourceID *string `json:"eventSourceResourceId,omitempty"`
	// TimestampPropertyName - The event property that will be used as the event source's timestamp. If a value isn't specified for timestampPropertyName, or if null or empty-string is specified, the event creation time will be used.
	TimestampPropertyName *string `json:"timestampPropertyName,omitempty"`
	// ProvisioningState - Provisioning state of the resource. Possible values include: 'Accepted', 'Creating', 'Updating', 'Succeeded', 'Failed', 'Deleting'
	ProvisioningState ProvisioningState `json:"provisioningState,omitempty"`
	// CreationTime - READ-ONLY; The time the resource was created.
	CreationTime *date.Time `json:"creationTime,omitempty"`
}

// MarshalJSON is the custom marshaler for IoTHubEventSourceCommonProperties.
func (ithescp IoTHubEventSourceCommonProperties) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if ithescp.IotHubName != nil {
		objectMap["iotHubName"] = ithescp.IotHubName
	}
	if ithescp.ConsumerGroupName != nil {
		objectMap["consumerGroupName"] = ithescp.ConsumerGroupName
	}
	if ithescp.KeyName != nil {
		objectMap["keyName"] = ithescp.KeyName
	}
	if ithescp.EventSourceResourceID != nil {
		objectMap["eventSourceResourceId"] = ithescp.EventSourceResourceID
	}
	if ithescp.TimestampPropertyName != nil {
		objectMap["timestampPropertyName"] = ithescp.TimestampPropertyName
	}
	if ithescp.ProvisioningState != "" {
		objectMap["provisioningState"] = ithescp.ProvisioningState
	}
	return json.Marshal(objectMap)
}

// IoTHubEventSourceCreateOrUpdateParameters parameters supplied to the Create or Update Event Source
// operation for an IoTHub event source.
type IoTHubEventSourceCreateOrUpdateParameters struct {
	*IoTHubEventSourceCreationProperties `json:"properties,omitempty"`
	// LocalTimestamp - An object that represents the local timestamp property. It contains the format of local timestamp that needs to be used and the corresponding timezone offset information. If a value isn't specified for localTimestamp, or if null, then the local timestamp will not be ingressed with the events.
	LocalTimestamp *LocalTimestamp `json:"localTimestamp,omitempty"`
	// Kind - Possible values include: 'KindEventSourceCreateOrUpdateParameters', 'KindMicrosoftEventHub', 'KindMicrosoftIoTHub'
	Kind KindBasicEventSourceCreateOrUpdateParameters `json:"kind,omitempty"`
	// Location - The location of the resource.
	Location *string `json:"location,omitempty"`
	// Tags - Key-value pairs of additional properties for the resource.
	Tags map[string]*string `json:"tags"`
}

// MarshalJSON is the custom marshaler for IoTHubEventSourceCreateOrUpdateParameters.
func (ithescoup IoTHubEventSourceCreateOrUpdateParameters) MarshalJSON() ([]byte, error) {
	ithescoup.Kind = KindMicrosoftIoTHub
	objectMap := make(map[string]interface{})
	if ithescoup.IoTHubEventSourceCreationProperties != nil {
		objectMap["properties"] = ithescoup.IoTHubEventSourceCreationProperties
	}
	if ithescoup.LocalTimestamp != nil {
		objectMap["localTimestamp"] = ithescoup.LocalTimestamp
	}
	if ithescoup.Kind != "" {
		objectMap["kind"] = ithescoup.Kind
	}
	if ithescoup.Location != nil {
		objectMap["location"] = ithescoup.Location
	}
	if ithescoup.Tags != nil {
		objectMap["tags"] = ithescoup.Tags
	}
	return json.Marshal(objectMap)
}

// AsEventHubEventSourceCreateOrUpdateParameters is the BasicEventSourceCreateOrUpdateParameters implementation for IoTHubEventSourceCreateOrUpdateParameters.
func (ithescoup IoTHubEventSourceCreateOrUpdateParameters) AsEventHubEventSourceCreateOrUpdateParameters() (*EventHubEventSourceCreateOrUpdateParameters, bool) {
	return nil, false
}

// AsIoTHubEventSourceCreateOrUpdateParameters is the BasicEventSourceCreateOrUpdateParameters implementation for IoTHubEventSourceCreateOrUpdateParameters.
func (ithescoup IoTHubEventSourceCreateOrUpdateParameters) AsIoTHubEventSourceCreateOrUpdateParameters() (*IoTHubEventSourceCreateOrUpdateParameters, bool) {
	return &ithescoup, true
}

// AsEventSourceCreateOrUpdateParameters is the BasicEventSourceCreateOrUpdateParameters implementation for IoTHubEventSourceCreateOrUpdateParameters.
func (ithescoup IoTHubEventSourceCreateOrUpdateParameters) AsEventSourceCreateOrUpdateParameters() (*EventSourceCreateOrUpdateParameters, bool) {
	return nil, false
}

// AsBasicEventSourceCreateOrUpdateParameters is the BasicEventSourceCreateOrUpdateParameters implementation for IoTHubEventSourceCreateOrUpdateParameters.
func (ithescoup IoTHubEventSourceCreateOrUpdateParameters) AsBasicEventSourceCreateOrUpdateParameters() (BasicEventSourceCreateOrUpdateParameters, bool) {
	return &ithescoup, true
}

// UnmarshalJSON is the custom unmarshaler for IoTHubEventSourceCreateOrUpdateParameters struct.
func (ithescoup *IoTHubEventSourceCreateOrUpdateParameters) UnmarshalJSON(body []byte) error {
	var m map[string]*json.RawMessage
	err := json.Unmarshal(body, &m)
	if err != nil {
		return err
	}
	for k, v := range m {
		switch k {
		case "properties":
			if v != nil {
				var ioTHubEventSourceCreationProperties IoTHubEventSourceCreationProperties
				err = json.Unmarshal(*v, &ioTHubEventSourceCreationProperties)
				if err != nil {
					return err
				}
				ithescoup.IoTHubEventSourceCreationProperties = &ioTHubEventSourceCreationProperties
			}
		case "localTimestamp":
			if v != nil {
				var localTimestamp LocalTimestamp
				err = json.Unmarshal(*v, &localTimestamp)
				if err != nil {
					return err
				}
				ithescoup.LocalTimestamp = &localTimestamp
			}
		case "kind":
			if v != nil {
				var kind KindBasicEventSourceCreateOrUpdateParameters
				err = json.Unmarshal(*v, &kind)
				if err != nil {
					return err
				}
				ithescoup.Kind = kind
			}
		case "location":
			if v != nil {
				var location string
				err = json.Unmarshal(*v, &location)
				if err != nil {
					return err
				}
				ithescoup.Location = &location
			}
		case "tags":
			if v != nil {
				var tags map[string]*string
				err = json.Unmarshal(*v, &tags)
				if err != nil {
					return err
				}
				ithescoup.Tags = tags
			}
		}
	}

	return nil
}

// IoTHubEventSourceCreationProperties properties of the IoTHub event source that are required on create or
// update requests.
type IoTHubEventSourceCreationProperties struct {
	// SharedAccessKey - The value of the Shared Access Policy key that grants the Time Series Insights service read access to the iot hub. This property is not shown in event source responses.
	SharedAccessKey *string `json:"sharedAccessKey,omitempty"`
	// IotHubName - The name of the iot hub.
	IotHubName *string `json:"iotHubName,omitempty"`
	// ConsumerGroupName - The name of the iot hub's consumer group that holds the partitions from which events will be read.
	ConsumerGroupName *string `json:"consumerGroupName,omitempty"`
	// KeyName - The name of the Shared Access Policy key that grants the Time Series Insights service access to the iot hub. This shared access policy key must grant 'service connect' permissions to the iot hub.
	KeyName *string `json:"keyName,omitempty"`
	// EventSourceResourceID - The resource id of the event source in Azure Resource Manager.
	EventSourceResourceID *string `json:"eventSourceResourceId,omitempty"`
	// TimestampPropertyName - The event property that will be used as the event source's timestamp. If a value isn't specified for timestampPropertyName, or if null or empty-string is specified, the event creation time will be used.
	TimestampPropertyName *string `json:"timestampPropertyName,omitempty"`
	// ProvisioningState - Provisioning state of the resource. Possible values include: 'Accepted', 'Creating', 'Updating', 'Succeeded', 'Failed', 'Deleting'
	ProvisioningState ProvisioningState `json:"provisioningState,omitempty"`
	// CreationTime - READ-ONLY; The time the resource was created.
	CreationTime *date.Time `json:"creationTime,omitempty"`
}

// MarshalJSON is the custom marshaler for IoTHubEventSourceCreationProperties.
func (ithescp IoTHubEventSourceCreationProperties) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if ithescp.SharedAccessKey != nil {
		objectMap["sharedAccessKey"] = ithescp.SharedAccessKey
	}
	if ithescp.IotHubName != nil {
		objectMap["iotHubName"] = ithescp.IotHubName
	}
	if ithescp.ConsumerGroupName != nil {
		objectMap["consumerGroupName"] = ithescp.ConsumerGroupName
	}
	if ithescp.KeyName != nil {
		objectMap["keyName"] = ithescp.KeyName
	}
	if ithescp.EventSourceResourceID != nil {
		objectMap["eventSourceResourceId"] = ithescp.EventSourceResourceID
	}
	if ithescp.TimestampPropertyName != nil {
		objectMap["timestampPropertyName"] = ithescp.TimestampPropertyName
	}
	if ithescp.ProvisioningState != "" {
		objectMap["provisioningState"] = ithescp.ProvisioningState
	}
	return json.Marshal(objectMap)
}

// IoTHubEventSourceMutableProperties an object that represents a set of mutable IoTHub event source
// resource properties.
type IoTHubEventSourceMutableProperties struct {
	// SharedAccessKey - The value of the shared access key that grants the Time Series Insights service read access to the iot hub. This property is not shown in event source responses.
	SharedAccessKey *string `json:"sharedAccessKey,omitempty"`
	// TimestampPropertyName - The event property that will be used as the event source's timestamp. If a value isn't specified for timestampPropertyName, or if null or empty-string is specified, the event creation time will be used.
	TimestampPropertyName *string `json:"timestampPropertyName,omitempty"`
	// LocalTimestamp - An object that represents the local timestamp property. It contains the format of local timestamp that needs to be used and the corresponding timezone offset information. If a value isn't specified for localTimestamp, or if null, then the local timestamp will not be ingressed with the events.
	LocalTimestamp *LocalTimestamp `json:"localTimestamp,omitempty"`
}

// IoTHubEventSourceResource an event source that receives its data from an Azure IoTHub.
type IoTHubEventSourceResource struct {
	*IoTHubEventSourceResourceProperties `json:"properties,omitempty"`
	// Kind - Possible values include: 'KindBasicEventSourceResourceKindEventSourceResource', 'KindBasicEventSourceResourceKindMicrosoftEventHub', 'KindBasicEventSourceResourceKindMicrosoftIoTHub'
	Kind KindBasicEventSourceResource `json:"kind,omitempty"`
	// Location - Resource location
	Location *string `json:"location,omitempty"`
	// Tags - Resource tags
	Tags map[string]*string `json:"tags"`
	// ID - READ-ONLY; Resource Id
	ID *string `json:"id,omitempty"`
	// Name - READ-ONLY; Resource name
	Name *string `json:"name,omitempty"`
	// Type - READ-ONLY; Resource type
	Type *string `json:"type,omitempty"`
}

// MarshalJSON is the custom marshaler for IoTHubEventSourceResource.
func (ithesr IoTHubEventSourceResource) MarshalJSON() ([]byte, error) {
	ithesr.Kind = KindBasicEventSourceResourceKindMicrosoftIoTHub
	objectMap := make(map[string]interface{})
	if ithesr.IoTHubEventSourceResourceProperties != nil {
		objectMap["properties"] = ithesr.IoTHubEventSourceResourceProperties
	}
	if ithesr.Kind != "" {
		objectMap["kind"] = ithesr.Kind
	}
	if ithesr.Location != nil {
		objectMap["location"] = ithesr.Location
	}
	if ithesr.Tags != nil {
		objectMap["tags"] = ithesr.Tags
	}
	return json.Marshal(objectMap)
}

// AsEventHubEventSourceResource is the BasicEventSourceResource implementation for IoTHubEventSourceResource.
func (ithesr IoTHubEventSourceResource) AsEventHubEventSourceResource() (*EventHubEventSourceResource, bool) {
	return nil, false
}

// AsIoTHubEventSourceResource is the BasicEventSourceResource implementation for IoTHubEventSourceResource.
func (ithesr IoTHubEventSourceResource) AsIoTHubEventSourceResource() (*IoTHubEventSourceResource, bool) {
	return &ithesr, true
}

// AsEventSourceResource is the BasicEventSourceResource implementation for IoTHubEventSourceResource.
func (ithesr IoTHubEventSourceResource) AsEventSourceResource() (*EventSourceResource, bool) {
	return nil, false
}

// AsBasicEventSourceResource is the BasicEventSourceResource implementation for IoTHubEventSourceResource.
func (ithesr IoTHubEventSourceResource) AsBasicEventSourceResource() (BasicEventSourceResource, bool) {
	return &ithesr, true
}

// UnmarshalJSON is the custom unmarshaler for IoTHubEventSourceResource struct.
func (ithesr *IoTHubEventSourceResource) UnmarshalJSON(body []byte) error {
	var m map[string]*json.RawMessage
	err := json.Unmarshal(body, &m)
	if err != nil {
		return err
	}
	for k, v := range m {
		switch k {
		case "properties":
			if v != nil {
				var ioTHubEventSourceResourceProperties IoTHubEventSourceResourceProperties
				err = json.Unmarshal(*v, &ioTHubEventSourceResourceProperties)
				if err != nil {
					return err
				}
				ithesr.IoTHubEventSourceResourceProperties = &ioTHubEventSourceResourceProperties
			}
		case "kind":
			if v != nil {
				var kind KindBasicEventSourceResource
				err = json.Unmarshal(*v, &kind)
				if err != nil {
					return err
				}
				ithesr.Kind = kind
			}
		case "location":
			if v != nil {
				var location string
				err = json.Unmarshal(*v, &location)
				if err != nil {
					return err
				}
				ithesr.Location = &location
			}
		case "tags":
			if v != nil {
				var tags map[string]*string
				err = json.Unmarshal(*v, &tags)
				if err != nil {
					return err
				}
				ithesr.Tags = tags
			}
		case "id":
			if v != nil {
				var ID string
				err = json.Unmarshal(*v, &ID)
				if err != nil {
					return err
				}
				ithesr.ID = &ID
			}
		case "name":
			if v != nil {
				var name string
				err = json.Unmarshal(*v, &name)
				if err != nil {
					return err
				}
				ithesr.Name = &name
			}
		case "type":
			if v != nil {
				var typeVar string
				err = json.Unmarshal(*v, &typeVar)
				if err != nil {
					return err
				}
				ithesr.Type = &typeVar
			}
		}
	}

	return nil
}

// IoTHubEventSourceResourceProperties properties of the IoTHub event source resource.
type IoTHubEventSourceResourceProperties struct {
	// IotHubName - The name of the iot hub.
	IotHubName *string `json:"iotHubName,omitempty"`
	// ConsumerGroupName - The name of the iot hub's consumer group that holds the partitions from which events will be read.
	ConsumerGroupName *string `json:"consumerGroupName,omitempty"`
	// KeyName - The name of the Shared Access Policy key that grants the Time Series Insights service access to the iot hub. This shared access policy key must grant 'service connect' permissions to the iot hub.
	KeyName *string `json:"keyName,omitempty"`
	// EventSourceResourceID - The resource id of the event source in Azure Resource Manager.
	EventSourceResourceID *string `json:"eventSourceResourceId,omitempty"`
	// TimestampPropertyName - The event property that will be used as the event source's timestamp. If a value isn't specified for timestampPropertyName, or if null or empty-string is specified, the event creation time will be used.
	TimestampPropertyName *string `json:"timestampPropertyName,omitempty"`
	// ProvisioningState - Provisioning state of the resource. Possible values include: 'Accepted', 'Creating', 'Updating', 'Succeeded', 'Failed', 'Deleting'
	ProvisioningState ProvisioningState `json:"provisioningState,omitempty"`
	// CreationTime - READ-ONLY; The time the resource was created.
	CreationTime *date.Time `json:"creationTime,omitempty"`
}

// MarshalJSON is the custom marshaler for IoTHubEventSourceResourceProperties.
func (ithesrp IoTHubEventSourceResourceProperties) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if ithesrp.IotHubName != nil {
		objectMap["iotHubName"] = ithesrp.IotHubName
	}
	if ithesrp.ConsumerGroupName != nil {
		objectMap["consumerGroupName"] = ithesrp.ConsumerGroupName
	}
	if ithesrp.KeyName != nil {
		objectMap["keyName"] = ithesrp.KeyName
	}
	if ithesrp.EventSourceResourceID != nil {
		objectMap["eventSourceResourceId"] = ithesrp.EventSourceResourceID
	}
	if ithesrp.TimestampPropertyName != nil {
		objectMap["timestampPropertyName"] = ithesrp.TimestampPropertyName
	}
	if ithesrp.ProvisioningState != "" {
		objectMap["provisioningState"] = ithesrp.ProvisioningState
	}
	return json.Marshal(objectMap)
}

// IoTHubEventSourceUpdateParameters parameters supplied to the Update Event Source operation to update an
// IoTHub event source.
type IoTHubEventSourceUpdateParameters struct {
	// IoTHubEventSourceMutableProperties - Properties of the IoTHub event source.
	*IoTHubEventSourceMutableProperties `json:"properties,omitempty"`
	// Tags - Key-value pairs of additional properties for the event source.
	Tags map[string]*string `json:"tags"`
}

// MarshalJSON is the custom marshaler for IoTHubEventSourceUpdateParameters.
func (ithesup IoTHubEventSourceUpdateParameters) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if ithesup.IoTHubEventSourceMutableProperties != nil {
		objectMap["properties"] = ithesup.IoTHubEventSourceMutableProperties
	}
	if ithesup.Tags != nil {
		objectMap["tags"] = ithesup.Tags
	}
	return json.Marshal(objectMap)
}

// UnmarshalJSON is the custom unmarshaler for IoTHubEventSourceUpdateParameters struct.
func (ithesup *IoTHubEventSourceUpdateParameters) UnmarshalJSON(body []byte) error {
	var m map[string]*json.RawMessage
	err := json.Unmarshal(body, &m)
	if err != nil {
		return err
	}
	for k, v := range m {
		switch k {
		case "properties":
			if v != nil {
				var ioTHubEventSourceMutableProperties IoTHubEventSourceMutableProperties
				err = json.Unmarshal(*v, &ioTHubEventSourceMutableProperties)
				if err != nil {
					return err
				}
				ithesup.IoTHubEventSourceMutableProperties = &ioTHubEventSourceMutableProperties
			}
		case "tags":
			if v != nil {
				var tags map[string]*string
				err = json.Unmarshal(*v, &tags)
				if err != nil {
					return err
				}
				ithesup.Tags = tags
			}
		}
	}

	return nil
}

// LocalTimestamp an object that represents the local timestamp property. It contains the format of local
// timestamp that needs to be used and the corresponding timezone offset information. If a value isn't
// specified for localTimestamp, or if null, then the local timestamp will not be ingressed with the
// events.
type LocalTimestamp struct {
	// Format - An enum that represents the format of the local timestamp property that needs to be set. Possible values include: 'Embedded'
	Format LocalTimestampFormat `json:"format,omitempty"`
	// TimeZoneOffset - An object that represents the offset information for the local timestamp format specified. Should not be specified for LocalTimestampFormat - Embedded.
	TimeZoneOffset *LocalTimestampTimeZoneOffset `json:"timeZoneOffset,omitempty"`
}

// LocalTimestampTimeZoneOffset an object that represents the offset information for the local timestamp
// format specified. Should not be specified for LocalTimestampFormat - Embedded.
type LocalTimestampTimeZoneOffset struct {
	// PropertyName - The event property that will be contain the offset information to calculate the local timestamp. When the LocalTimestampFormat is Iana, the property name will contain the name of the column which contains IANA Timezone Name (eg: Americas/Los Angeles). When LocalTimestampFormat is Timespan, it contains the name of property which contains values representing the offset (eg: P1D or 1.00:00:00)
	PropertyName *string `json:"propertyName,omitempty"`
}

// LongTermEnvironmentCreateOrUpdateParameters parameters supplied to the Create or Update Environment
// operation for a long-term environment.
type LongTermEnvironmentCreateOrUpdateParameters struct {
	*LongTermEnvironmentCreationProperties `json:"properties,omitempty"`
	// Sku - The sku determines the type of environment, either standard (S1 or S2) or long-term (L1). For standard environments the sku determines the capacity of the environment, the ingress rate, and the billing rate.
	Sku *Sku `json:"sku,omitempty"`
	// Kind - Possible values include: 'KindEnvironmentCreateOrUpdateParameters', 'KindStandard', 'KindLongTerm'
	Kind Kind `json:"kind,omitempty"`
	// Location - The location of the resource.
	Location *string `json:"location,omitempty"`
	// Tags - Key-value pairs of additional properties for the resource.
	Tags map[string]*string `json:"tags"`
}

// MarshalJSON is the custom marshaler for LongTermEnvironmentCreateOrUpdateParameters.
func (ltecoup LongTermEnvironmentCreateOrUpdateParameters) MarshalJSON() ([]byte, error) {
	ltecoup.Kind = KindLongTerm
	objectMap := make(map[string]interface{})
	if ltecoup.LongTermEnvironmentCreationProperties != nil {
		objectMap["properties"] = ltecoup.LongTermEnvironmentCreationProperties
	}
	if ltecoup.Sku != nil {
		objectMap["sku"] = ltecoup.Sku
	}
	if ltecoup.Kind != "" {
		objectMap["kind"] = ltecoup.Kind
	}
	if ltecoup.Location != nil {
		objectMap["location"] = ltecoup.Location
	}
	if ltecoup.Tags != nil {
		objectMap["tags"] = ltecoup.Tags
	}
	return json.Marshal(objectMap)
}

// AsStandardEnvironmentCreateOrUpdateParameters is the BasicEnvironmentCreateOrUpdateParameters implementation for LongTermEnvironmentCreateOrUpdateParameters.
func (ltecoup LongTermEnvironmentCreateOrUpdateParameters) AsStandardEnvironmentCreateOrUpdateParameters() (*StandardEnvironmentCreateOrUpdateParameters, bool) {
	return nil, false
}

// AsLongTermEnvironmentCreateOrUpdateParameters is the BasicEnvironmentCreateOrUpdateParameters implementation for LongTermEnvironmentCreateOrUpdateParameters.
func (ltecoup LongTermEnvironmentCreateOrUpdateParameters) AsLongTermEnvironmentCreateOrUpdateParameters() (*LongTermEnvironmentCreateOrUpdateParameters, bool) {
	return &ltecoup, true
}

// AsEnvironmentCreateOrUpdateParameters is the BasicEnvironmentCreateOrUpdateParameters implementation for LongTermEnvironmentCreateOrUpdateParameters.
func (ltecoup LongTermEnvironmentCreateOrUpdateParameters) AsEnvironmentCreateOrUpdateParameters() (*EnvironmentCreateOrUpdateParameters, bool) {
	return nil, false
}

// AsBasicEnvironmentCreateOrUpdateParameters is the BasicEnvironmentCreateOrUpdateParameters implementation for LongTermEnvironmentCreateOrUpdateParameters.
func (ltecoup LongTermEnvironmentCreateOrUpdateParameters) AsBasicEnvironmentCreateOrUpdateParameters() (BasicEnvironmentCreateOrUpdateParameters, bool) {
	return &ltecoup, true
}

// UnmarshalJSON is the custom unmarshaler for LongTermEnvironmentCreateOrUpdateParameters struct.
func (ltecoup *LongTermEnvironmentCreateOrUpdateParameters) UnmarshalJSON(body []byte) error {
	var m map[string]*json.RawMessage
	err := json.Unmarshal(body, &m)
	if err != nil {
		return err
	}
	for k, v := range m {
		switch k {
		case "properties":
			if v != nil {
				var longTermEnvironmentCreationProperties LongTermEnvironmentCreationProperties
				err = json.Unmarshal(*v, &longTermEnvironmentCreationProperties)
				if err != nil {
					return err
				}
				ltecoup.LongTermEnvironmentCreationProperties = &longTermEnvironmentCreationProperties
			}
		case "sku":
			if v != nil {
				var sku Sku
				err = json.Unmarshal(*v, &sku)
				if err != nil {
					return err
				}
				ltecoup.Sku = &sku
			}
		case "kind":
			if v != nil {
				var kind Kind
				err = json.Unmarshal(*v, &kind)
				if err != nil {
					return err
				}
				ltecoup.Kind = kind
			}
		case "location":
			if v != nil {
				var location string
				err = json.Unmarshal(*v, &location)
				if err != nil {
					return err
				}
				ltecoup.Location = &location
			}
		case "tags":
			if v != nil {
				var tags map[string]*string
				err = json.Unmarshal(*v, &tags)
				if err != nil {
					return err
				}
				ltecoup.Tags = tags
			}
		}
	}

	return nil
}

// LongTermEnvironmentCreationProperties properties used to create a long-term environment.
type LongTermEnvironmentCreationProperties struct {
	// TimeSeriesIDProperties - The list of event properties which will be used to define the environment's time series id.
	TimeSeriesIDProperties *[]TimeSeriesIDProperty `json:"timeSeriesIdProperties,omitempty"`
	// StorageConfiguration - The storage configuration provides the connection details that allows the Time Series Insights service to connect to the customer storage account that is used to store the environment's data.
	StorageConfiguration *LongTermStorageConfigurationInput `json:"storageConfiguration,omitempty"`
	// WarmStoreConfiguration - The warm store configuration provides the details to create a warm store cache that will retain a copy of the environment's data available for faster query.
	WarmStoreConfiguration *WarmStoreConfigurationProperties `json:"warmStoreConfiguration,omitempty"`
}

// LongTermEnvironmentMutableProperties an object that represents a set of mutable long-term environment
// resource properties.
type LongTermEnvironmentMutableProperties struct {
	// StorageConfiguration - The storage configuration provides the connection details that allows the Time Series Insights service to connect to the customer storage account that is used to store the environment's data.
	StorageConfiguration *LongTermStorageConfigurationMutableProperties `json:"storageConfiguration,omitempty"`
	// WarmStoreConfiguration - The warm store configuration provides the details to create a warm store cache that will retain a copy of the environment's data available for faster query.
	WarmStoreConfiguration *WarmStoreConfigurationProperties `json:"warmStoreConfiguration,omitempty"`
}

// LongTermEnvironmentResource an environment is a set of time-series data available for query, and is the
// top level Azure Time Series Insights resource. LongTerm environments do not have set data retention
// limits.
type LongTermEnvironmentResource struct {
	*LongTermEnvironmentResourceProperties `json:"properties,omitempty"`
	// Sku - The sku determines the type of environment, either standard (S1 or S2) or long-term (L1). For standard environments the sku determines the capacity of the environment, the ingress rate, and the billing rate.
	Sku *Sku `json:"sku,omitempty"`
	// Kind - Possible values include: 'KindBasicEnvironmentResourceKindEnvironmentResource', 'KindBasicEnvironmentResourceKindStandard', 'KindBasicEnvironmentResourceKindLongTerm'
	Kind KindBasicEnvironmentResource `json:"kind,omitempty"`
	// Location - Resource location
	Location *string `json:"location,omitempty"`
	// Tags - Resource tags
	Tags map[string]*string `json:"tags"`
	// ID - READ-ONLY; Resource Id
	ID *string `json:"id,omitempty"`
	// Name - READ-ONLY; Resource name
	Name *string `json:"name,omitempty"`
	// Type - READ-ONLY; Resource type
	Type *string `json:"type,omitempty"`
}

// MarshalJSON is the custom marshaler for LongTermEnvironmentResource.
func (lter LongTermEnvironmentResource) MarshalJSON() ([]byte, error) {
	lter.Kind = KindBasicEnvironmentResourceKindLongTerm
	objectMap := make(map[string]interface{})
	if lter.LongTermEnvironmentResourceProperties != nil {
		objectMap["properties"] = lter.LongTermEnvironmentResourceProperties
	}
	if lter.Sku != nil {
		objectMap["sku"] = lter.Sku
	}
	if lter.Kind != "" {
		objectMap["kind"] = lter.Kind
	}
	if lter.Location != nil {
		objectMap["location"] = lter.Location
	}
	if lter.Tags != nil {
		objectMap["tags"] = lter.Tags
	}
	return json.Marshal(objectMap)
}

// AsStandardEnvironmentResource is the BasicEnvironmentResource implementation for LongTermEnvironmentResource.
func (lter LongTermEnvironmentResource) AsStandardEnvironmentResource() (*StandardEnvironmentResource, bool) {
	return nil, false
}

// AsLongTermEnvironmentResource is the BasicEnvironmentResource implementation for LongTermEnvironmentResource.
func (lter LongTermEnvironmentResource) AsLongTermEnvironmentResource() (*LongTermEnvironmentResource, bool) {
	return &lter, true
}

// AsEnvironmentResource is the BasicEnvironmentResource implementation for LongTermEnvironmentResource.
func (lter LongTermEnvironmentResource) AsEnvironmentResource() (*EnvironmentResource, bool) {
	return nil, false
}

// AsBasicEnvironmentResource is the BasicEnvironmentResource implementation for LongTermEnvironmentResource.
func (lter LongTermEnvironmentResource) AsBasicEnvironmentResource() (BasicEnvironmentResource, bool) {
	return &lter, true
}

// UnmarshalJSON is the custom unmarshaler for LongTermEnvironmentResource struct.
func (lter *LongTermEnvironmentResource) UnmarshalJSON(body []byte) error {
	var m map[string]*json.RawMessage
	err := json.Unmarshal(body, &m)
	if err != nil {
		return err
	}
	for k, v := range m {
		switch k {
		case "properties":
			if v != nil {
				var longTermEnvironmentResourceProperties LongTermEnvironmentResourceProperties
				err = json.Unmarshal(*v, &longTermEnvironmentResourceProperties)
				if err != nil {
					return err
				}
				lter.LongTermEnvironmentResourceProperties = &longTermEnvironmentResourceProperties
			}
		case "sku":
			if v != nil {
				var sku Sku
				err = json.Unmarshal(*v, &sku)
				if err != nil {
					return err
				}
				lter.Sku = &sku
			}
		case "kind":
			if v != nil {
				var kind KindBasicEnvironmentResource
				err = json.Unmarshal(*v, &kind)
				if err != nil {
					return err
				}
				lter.Kind = kind
			}
		case "location":
			if v != nil {
				var location string
				err = json.Unmarshal(*v, &location)
				if err != nil {
					return err
				}
				lter.Location = &location
			}
		case "tags":
			if v != nil {
				var tags map[string]*string
				err = json.Unmarshal(*v, &tags)
				if err != nil {
					return err
				}
				lter.Tags = tags
			}
		case "id":
			if v != nil {
				var ID string
				err = json.Unmarshal(*v, &ID)
				if err != nil {
					return err
				}
				lter.ID = &ID
			}
		case "name":
			if v != nil {
				var name string
				err = json.Unmarshal(*v, &name)
				if err != nil {
					return err
				}
				lter.Name = &name
			}
		case "type":
			if v != nil {
				var typeVar string
				err = json.Unmarshal(*v, &typeVar)
				if err != nil {
					return err
				}
				lter.Type = &typeVar
			}
		}
	}

	return nil
}

// LongTermEnvironmentResourceProperties properties of the long-term environment.
type LongTermEnvironmentResourceProperties struct {
	// DataAccessID - READ-ONLY; An id used to access the environment data, e.g. to query the environment's events or upload reference data for the environment.
	DataAccessID *uuid.UUID `json:"dataAccessId,omitempty"`
	// DataAccessFqdn - READ-ONLY; The fully qualified domain name used to access the environment data, e.g. to query the environment's events or upload reference data for the environment.
	DataAccessFqdn *string `json:"dataAccessFqdn,omitempty"`
	// Status - An object that represents the status of the environment, and its internal state in the Time Series Insights service.
	Status *EnvironmentStatus `json:"status,omitempty"`
	// ProvisioningState - Provisioning state of the resource. Possible values include: 'Accepted', 'Creating', 'Updating', 'Succeeded', 'Failed', 'Deleting'
	ProvisioningState ProvisioningState `json:"provisioningState,omitempty"`
	// CreationTime - READ-ONLY; The time the resource was created.
	CreationTime *date.Time `json:"creationTime,omitempty"`
	// TimeSeriesIDProperties - The list of event properties which will be used to define the environment's time series id.
	TimeSeriesIDProperties *[]TimeSeriesIDProperty `json:"timeSeriesIdProperties,omitempty"`
	// StorageConfiguration - The storage configuration provides the connection details that allows the Time Series Insights service to connect to the customer storage account that is used to store the environment's data.
	StorageConfiguration *LongTermStorageConfigurationOutput `json:"storageConfiguration,omitempty"`
	// WarmStoreConfiguration - The warm store configuration provides the details to create a warm store cache that will retain a copy of the environment's data available for faster query.
	WarmStoreConfiguration *WarmStoreConfigurationProperties `json:"warmStoreConfiguration,omitempty"`
}

// MarshalJSON is the custom marshaler for LongTermEnvironmentResourceProperties.
func (lterp LongTermEnvironmentResourceProperties) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if lterp.Status != nil {
		objectMap["status"] = lterp.Status
	}
	if lterp.ProvisioningState != "" {
		objectMap["provisioningState"] = lterp.ProvisioningState
	}
	if lterp.TimeSeriesIDProperties != nil {
		objectMap["timeSeriesIdProperties"] = lterp.TimeSeriesIDProperties
	}
	if lterp.StorageConfiguration != nil {
		objectMap["storageConfiguration"] = lterp.StorageConfiguration
	}
	if lterp.WarmStoreConfiguration != nil {
		objectMap["warmStoreConfiguration"] = lterp.WarmStoreConfiguration
	}
	return json.Marshal(objectMap)
}

// LongTermEnvironmentUpdateParameters parameters supplied to the Update Environment operation to update a
// long-term environment.
type LongTermEnvironmentUpdateParameters struct {
	// LongTermEnvironmentMutableProperties - Properties of the long-term environment.
	*LongTermEnvironmentMutableProperties `json:"properties,omitempty"`
	// Tags - Key-value pairs of additional properties for the environment.
	Tags map[string]*string `json:"tags"`
}

// MarshalJSON is the custom marshaler for LongTermEnvironmentUpdateParameters.
func (lteup LongTermEnvironmentUpdateParameters) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if lteup.LongTermEnvironmentMutableProperties != nil {
		objectMap["properties"] = lteup.LongTermEnvironmentMutableProperties
	}
	if lteup.Tags != nil {
		objectMap["tags"] = lteup.Tags
	}
	return json.Marshal(objectMap)
}

// UnmarshalJSON is the custom unmarshaler for LongTermEnvironmentUpdateParameters struct.
func (lteup *LongTermEnvironmentUpdateParameters) UnmarshalJSON(body []byte) error {
	var m map[string]*json.RawMessage
	err := json.Unmarshal(body, &m)
	if err != nil {
		return err
	}
	for k, v := range m {
		switch k {
		case "properties":
			if v != nil {
				var longTermEnvironmentMutableProperties LongTermEnvironmentMutableProperties
				err = json.Unmarshal(*v, &longTermEnvironmentMutableProperties)
				if err != nil {
					return err
				}
				lteup.LongTermEnvironmentMutableProperties = &longTermEnvironmentMutableProperties
			}
		case "tags":
			if v != nil {
				var tags map[string]*string
				err = json.Unmarshal(*v, &tags)
				if err != nil {
					return err
				}
				lteup.Tags = tags
			}
		}
	}

	return nil
}

// LongTermStorageConfigurationInput the storage configuration provides the connection details that allows
// the Time Series Insights service to connect to the customer storage account that is used to store the
// environment's data.
type LongTermStorageConfigurationInput struct {
	// AccountName - The name of the storage account that will hold the environment's long term data.
	AccountName *string `json:"accountName,omitempty"`
	// ManagementKey - The value of the management key that grants the Time Series Insights service write access to the storage account. This property is not shown in environment responses.
	ManagementKey *string `json:"managementKey,omitempty"`
}

// LongTermStorageConfigurationMutableProperties the storage configuration provides the connection details
// that allows the Time Series Insights service to connect to the customer storage account that is used to
// store the environment's data.
type LongTermStorageConfigurationMutableProperties struct {
	// ManagementKey - The value of the management key that grants the Time Series Insights service write access to the storage account. This property is not shown in environment responses.
	ManagementKey *string `json:"managementKey,omitempty"`
}

// LongTermStorageConfigurationOutput the storage configuration provides the non-secret connection details
// about the customer storage account that is used to store the environment's data.
type LongTermStorageConfigurationOutput struct {
	// AccountName - The name of the storage account that will hold the environment's long term data.
	AccountName *string `json:"accountName,omitempty"`
}

// Operation a Time Series Insights REST API operation
type Operation struct {
	// Name - READ-ONLY; The name of the operation being performed on this particular object.
	Name *string `json:"name,omitempty"`
	// Display - READ-ONLY; Contains the localized display information for this particular operation / action.
	Display *OperationDisplay `json:"display,omitempty"`
}

// MarshalJSON is the custom marshaler for Operation.
func (o Operation) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	return json.Marshal(objectMap)
}

// OperationDisplay contains the localized display information for this particular operation / action.
type OperationDisplay struct {
	// Provider - READ-ONLY; The localized friendly form of the resource provider name.
	Provider *string `json:"provider,omitempty"`
	// Resource - READ-ONLY; The localized friendly form of the resource type related to this action/operation.
	Resource *string `json:"resource,omitempty"`
	// Operation - READ-ONLY; The localized friendly name for the operation.
	Operation *string `json:"operation,omitempty"`
	// Description - READ-ONLY; The localized friendly description for the operation.
	Description *string `json:"description,omitempty"`
}

// MarshalJSON is the custom marshaler for OperationDisplay.
func (o OperationDisplay) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	return json.Marshal(objectMap)
}

// OperationListResult result of the request to list Time Series Insights operations. It contains a list of
// operations and a URL link to get the next set of results.
type OperationListResult struct {
	autorest.Response `json:"-"`
	// Value - READ-ONLY; List of Time Series Insights operations supported by the Microsoft.TimeSeriesInsights resource provider.
	Value *[]Operation `json:"value,omitempty"`
	// NextLink - READ-ONLY; URL to get the next set of operation list results if there are any.
	NextLink *string `json:"nextLink,omitempty"`
}

// MarshalJSON is the custom marshaler for OperationListResult.
func (olr OperationListResult) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	return json.Marshal(objectMap)
}

// OperationListResultIterator provides access to a complete listing of Operation values.
type OperationListResultIterator struct {
	i    int
	page OperationListResultPage
}

// NextWithContext advances to the next value.  If there was an error making
// the request the iterator does not advance and the error is returned.
func (iter *OperationListResultIterator) NextWithContext(ctx context.Context) (err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/OperationListResultIterator.NextWithContext")
		defer func() {
			sc := -1
			if iter.Response().Response.Response != nil {
				sc = iter.Response().Response.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	iter.i++
	if iter.i < len(iter.page.Values()) {
		return nil
	}
	err = iter.page.NextWithContext(ctx)
	if err != nil {
		iter.i--
		return err
	}
	iter.i = 0
	return nil
}

// Next advances to the next value.  If there was an error making
// the request the iterator does not advance and the error is returned.
// Deprecated: Use NextWithContext() instead.
func (iter *OperationListResultIterator) Next() error {
	return iter.NextWithContext(context.Background())
}

// NotDone returns true if the enumeration should be started or is not yet complete.
func (iter OperationListResultIterator) NotDone() bool {
	return iter.page.NotDone() && iter.i < len(iter.page.Values())
}

// Response returns the raw server response from the last page request.
func (iter OperationListResultIterator) Response() OperationListResult {
	return iter.page.Response()
}

// Value returns the current value or a zero-initialized value if the
// iterator has advanced beyond the end of the collection.
func (iter OperationListResultIterator) Value() Operation {
	if !iter.page.NotDone() {
		return Operation{}
	}
	return iter.page.Values()[iter.i]
}

// Creates a new instance of the OperationListResultIterator type.
func NewOperationListResultIterator(page OperationListResultPage) OperationListResultIterator {
	return OperationListResultIterator{page: page}
}

// IsEmpty returns true if the ListResult contains no values.
func (olr OperationListResult) IsEmpty() bool {
	return olr.Value == nil || len(*olr.Value) == 0
}

// hasNextLink returns true if the NextLink is not empty.
func (olr OperationListResult) hasNextLink() bool {
	return olr.NextLink != nil && len(*olr.NextLink) != 0
}

// operationListResultPreparer prepares a request to retrieve the next set of results.
// It returns nil if no more results exist.
func (olr OperationListResult) operationListResultPreparer(ctx context.Context) (*http.Request, error) {
	if !olr.hasNextLink() {
		return nil, nil
	}
	return autorest.Prepare((&http.Request{}).WithContext(ctx),
		autorest.AsJSON(),
		autorest.AsGet(),
		autorest.WithBaseURL(to.String(olr.NextLink)))
}

// OperationListResultPage contains a page of Operation values.
type OperationListResultPage struct {
	fn  func(context.Context, OperationListResult) (OperationListResult, error)
	olr OperationListResult
}

// NextWithContext advances to the next page of values.  If there was an error making
// the request the page does not advance and the error is returned.
func (page *OperationListResultPage) NextWithContext(ctx context.Context) (err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/OperationListResultPage.NextWithContext")
		defer func() {
			sc := -1
			if page.Response().Response.Response != nil {
				sc = page.Response().Response.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	for {
		next, err := page.fn(ctx, page.olr)
		if err != nil {
			return err
		}
		page.olr = next
		if !next.hasNextLink() || !next.IsEmpty() {
			break
		}
	}
	return nil
}

// Next advances to the next page of values.  If there was an error making
// the request the page does not advance and the error is returned.
// Deprecated: Use NextWithContext() instead.
func (page *OperationListResultPage) Next() error {
	return page.NextWithContext(context.Background())
}

// NotDone returns true if the page enumeration should be started or is not yet complete.
func (page OperationListResultPage) NotDone() bool {
	return !page.olr.IsEmpty()
}

// Response returns the raw server response from the last page request.
func (page OperationListResultPage) Response() OperationListResult {
	return page.olr
}

// Values returns the slice of values for the current page or nil if there are no values.
func (page OperationListResultPage) Values() []Operation {
	if page.olr.IsEmpty() {
		return nil
	}
	return *page.olr.Value
}

// Creates a new instance of the OperationListResultPage type.
func NewOperationListResultPage(cur OperationListResult, getNextPage func(context.Context, OperationListResult) (OperationListResult, error)) OperationListResultPage {
	return OperationListResultPage{
		fn:  getNextPage,
		olr: cur,
	}
}

// ReferenceDataSetCreateOrUpdateParameters ...
type ReferenceDataSetCreateOrUpdateParameters struct {
	*ReferenceDataSetCreationProperties `json:"properties,omitempty"`
	// Location - The location of the resource.
	Location *string `json:"location,omitempty"`
	// Tags - Key-value pairs of additional properties for the resource.
	Tags map[string]*string `json:"tags"`
}

// MarshalJSON is the custom marshaler for ReferenceDataSetCreateOrUpdateParameters.
func (rdscoup ReferenceDataSetCreateOrUpdateParameters) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if rdscoup.ReferenceDataSetCreationProperties != nil {
		objectMap["properties"] = rdscoup.ReferenceDataSetCreationProperties
	}
	if rdscoup.Location != nil {
		objectMap["location"] = rdscoup.Location
	}
	if rdscoup.Tags != nil {
		objectMap["tags"] = rdscoup.Tags
	}
	return json.Marshal(objectMap)
}

// UnmarshalJSON is the custom unmarshaler for ReferenceDataSetCreateOrUpdateParameters struct.
func (rdscoup *ReferenceDataSetCreateOrUpdateParameters) UnmarshalJSON(body []byte) error {
	var m map[string]*json.RawMessage
	err := json.Unmarshal(body, &m)
	if err != nil {
		return err
	}
	for k, v := range m {
		switch k {
		case "properties":
			if v != nil {
				var referenceDataSetCreationProperties ReferenceDataSetCreationProperties
				err = json.Unmarshal(*v, &referenceDataSetCreationProperties)
				if err != nil {
					return err
				}
				rdscoup.ReferenceDataSetCreationProperties = &referenceDataSetCreationProperties
			}
		case "location":
			if v != nil {
				var location string
				err = json.Unmarshal(*v, &location)
				if err != nil {
					return err
				}
				rdscoup.Location = &location
			}
		case "tags":
			if v != nil {
				var tags map[string]*string
				err = json.Unmarshal(*v, &tags)
				if err != nil {
					return err
				}
				rdscoup.Tags = tags
			}
		}
	}

	return nil
}

// ReferenceDataSetCreationProperties properties used to create a reference data set.
type ReferenceDataSetCreationProperties struct {
	// KeyProperties - The list of key properties for the reference data set.
	KeyProperties *[]ReferenceDataSetKeyProperty `json:"keyProperties,omitempty"`
	// DataStringComparisonBehavior - The reference data set key comparison behavior can be set using this property. By default, the value is 'Ordinal' - which means case sensitive key comparison will be performed while joining reference data with events or while adding new reference data. When 'OrdinalIgnoreCase' is set, case insensitive comparison will be used. Possible values include: 'Ordinal', 'OrdinalIgnoreCase'
	DataStringComparisonBehavior DataStringComparisonBehavior `json:"dataStringComparisonBehavior,omitempty"`
}

// ReferenceDataSetKeyProperty a key property for the reference data set. A reference data set can have
// multiple key properties.
type ReferenceDataSetKeyProperty struct {
	// Name - The name of the key property.
	Name *string `json:"name,omitempty"`
	// Type - The type of the key property. Possible values include: 'ReferenceDataKeyPropertyTypeString', 'ReferenceDataKeyPropertyTypeDouble', 'ReferenceDataKeyPropertyTypeBool', 'ReferenceDataKeyPropertyTypeDateTime'
	Type ReferenceDataKeyPropertyType `json:"type,omitempty"`
}

// ReferenceDataSetListResponse the response of the List Reference Data Sets operation.
type ReferenceDataSetListResponse struct {
	autorest.Response `json:"-"`
	// Value - Result of the List Reference Data Sets operation.
	Value *[]ReferenceDataSetResource `json:"value,omitempty"`
}

// ReferenceDataSetResource a reference data set provides metadata about the events in an environment.
// Metadata in the reference data set will be joined with events as they are read from event sources. The
// metadata that makes up the reference data set is uploaded or modified through the Time Series Insights
// data plane APIs.
type ReferenceDataSetResource struct {
	autorest.Response                   `json:"-"`
	*ReferenceDataSetResourceProperties `json:"properties,omitempty"`
	// Location - Resource location
	Location *string `json:"location,omitempty"`
	// Tags - Resource tags
	Tags map[string]*string `json:"tags"`
	// ID - READ-ONLY; Resource Id
	ID *string `json:"id,omitempty"`
	// Name - READ-ONLY; Resource name
	Name *string `json:"name,omitempty"`
	// Type - READ-ONLY; Resource type
	Type *string `json:"type,omitempty"`
}

// MarshalJSON is the custom marshaler for ReferenceDataSetResource.
func (rdsr ReferenceDataSetResource) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if rdsr.ReferenceDataSetResourceProperties != nil {
		objectMap["properties"] = rdsr.ReferenceDataSetResourceProperties
	}
	if rdsr.Location != nil {
		objectMap["location"] = rdsr.Location
	}
	if rdsr.Tags != nil {
		objectMap["tags"] = rdsr.Tags
	}
	return json.Marshal(objectMap)
}

// UnmarshalJSON is the custom unmarshaler for ReferenceDataSetResource struct.
func (rdsr *ReferenceDataSetResource) UnmarshalJSON(body []byte) error {
	var m map[string]*json.RawMessage
	err := json.Unmarshal(body, &m)
	if err != nil {
		return err
	}
	for k, v := range m {
		switch k {
		case "properties":
			if v != nil {
				var referenceDataSetResourceProperties ReferenceDataSetResourceProperties
				err = json.Unmarshal(*v, &referenceDataSetResourceProperties)
				if err != nil {
					return err
				}
				rdsr.ReferenceDataSetResourceProperties = &referenceDataSetResourceProperties
			}
		case "location":
			if v != nil {
				var location string
				err = json.Unmarshal(*v, &location)
				if err != nil {
					return err
				}
				rdsr.Location = &location
			}
		case "tags":
			if v != nil {
				var tags map[string]*string
				err = json.Unmarshal(*v, &tags)
				if err != nil {
					return err
				}
				rdsr.Tags = tags
			}
		case "id":
			if v != nil {
				var ID string
				err = json.Unmarshal(*v, &ID)
				if err != nil {
					return err
				}
				rdsr.ID = &ID
			}
		case "name":
			if v != nil {
				var name string
				err = json.Unmarshal(*v, &name)
				if err != nil {
					return err
				}
				rdsr.Name = &name
			}
		case "type":
			if v != nil {
				var typeVar string
				err = json.Unmarshal(*v, &typeVar)
				if err != nil {
					return err
				}
				rdsr.Type = &typeVar
			}
		}
	}

	return nil
}

// ReferenceDataSetResourceProperties properties of the reference data set.
type ReferenceDataSetResourceProperties struct {
	// KeyProperties - The list of key properties for the reference data set.
	KeyProperties *[]ReferenceDataSetKeyProperty `json:"keyProperties,omitempty"`
	// DataStringComparisonBehavior - The reference data set key comparison behavior can be set using this property. By default, the value is 'Ordinal' - which means case sensitive key comparison will be performed while joining reference data with events or while adding new reference data. When 'OrdinalIgnoreCase' is set, case insensitive comparison will be used. Possible values include: 'Ordinal', 'OrdinalIgnoreCase'
	DataStringComparisonBehavior DataStringComparisonBehavior `json:"dataStringComparisonBehavior,omitempty"`
	// ProvisioningState - Provisioning state of the resource. Possible values include: 'Accepted', 'Creating', 'Updating', 'Succeeded', 'Failed', 'Deleting'
	ProvisioningState ProvisioningState `json:"provisioningState,omitempty"`
	// CreationTime - READ-ONLY; The time the resource was created.
	CreationTime *date.Time `json:"creationTime,omitempty"`
}

// MarshalJSON is the custom marshaler for ReferenceDataSetResourceProperties.
func (rdsrp ReferenceDataSetResourceProperties) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if rdsrp.KeyProperties != nil {
		objectMap["keyProperties"] = rdsrp.KeyProperties
	}
	if rdsrp.DataStringComparisonBehavior != "" {
		objectMap["dataStringComparisonBehavior"] = rdsrp.DataStringComparisonBehavior
	}
	if rdsrp.ProvisioningState != "" {
		objectMap["provisioningState"] = rdsrp.ProvisioningState
	}
	return json.Marshal(objectMap)
}

// ReferenceDataSetUpdateParameters parameters supplied to the Update Reference Data Set operation.
type ReferenceDataSetUpdateParameters struct {
	// Tags - Key-value pairs of additional properties for the reference data set.
	Tags map[string]*string `json:"tags"`
}

// MarshalJSON is the custom marshaler for ReferenceDataSetUpdateParameters.
func (rdsup ReferenceDataSetUpdateParameters) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if rdsup.Tags != nil {
		objectMap["tags"] = rdsup.Tags
	}
	return json.Marshal(objectMap)
}

// Resource time Series Insights resource
type Resource struct {
	// ID - READ-ONLY; Resource Id
	ID *string `json:"id,omitempty"`
	// Name - READ-ONLY; Resource name
	Name *string `json:"name,omitempty"`
	// Type - READ-ONLY; Resource type
	Type *string `json:"type,omitempty"`
}

// MarshalJSON is the custom marshaler for Resource.
func (r Resource) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	return json.Marshal(objectMap)
}

// ResourceProperties properties that are common to all tracked resources.
type ResourceProperties struct {
	// ProvisioningState - Provisioning state of the resource. Possible values include: 'Accepted', 'Creating', 'Updating', 'Succeeded', 'Failed', 'Deleting'
	ProvisioningState ProvisioningState `json:"provisioningState,omitempty"`
	// CreationTime - READ-ONLY; The time the resource was created.
	CreationTime *date.Time `json:"creationTime,omitempty"`
}

// MarshalJSON is the custom marshaler for ResourceProperties.
func (rp ResourceProperties) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if rp.ProvisioningState != "" {
		objectMap["provisioningState"] = rp.ProvisioningState
	}
	return json.Marshal(objectMap)
}

// Sku the sku determines the type of environment, either standard (S1 or S2) or long-term (L1). For
// standard environments the sku determines the capacity of the environment, the ingress rate, and the
// billing rate.
type Sku struct {
	// Name - The name of this SKU. Possible values include: 'S1', 'S2', 'P1', 'L1'
	Name SkuName `json:"name,omitempty"`
	// Capacity - The capacity of the sku. For standard environments, this value can be changed to support scale out of environments after they have been created.
	Capacity *int32 `json:"capacity,omitempty"`
}

// StandardEnvironmentCreateOrUpdateParameters parameters supplied to the Create or Update Environment
// operation for a standard environment.
type StandardEnvironmentCreateOrUpdateParameters struct {
	*StandardEnvironmentCreationProperties `json:"properties,omitempty"`
	// Sku - The sku determines the type of environment, either standard (S1 or S2) or long-term (L1). For standard environments the sku determines the capacity of the environment, the ingress rate, and the billing rate.
	Sku *Sku `json:"sku,omitempty"`
	// Kind - Possible values include: 'KindEnvironmentCreateOrUpdateParameters', 'KindStandard', 'KindLongTerm'
	Kind Kind `json:"kind,omitempty"`
	// Location - The location of the resource.
	Location *string `json:"location,omitempty"`
	// Tags - Key-value pairs of additional properties for the resource.
	Tags map[string]*string `json:"tags"`
}

// MarshalJSON is the custom marshaler for StandardEnvironmentCreateOrUpdateParameters.
func (secoup StandardEnvironmentCreateOrUpdateParameters) MarshalJSON() ([]byte, error) {
	secoup.Kind = KindStandard
	objectMap := make(map[string]interface{})
	if secoup.StandardEnvironmentCreationProperties != nil {
		objectMap["properties"] = secoup.StandardEnvironmentCreationProperties
	}
	if secoup.Sku != nil {
		objectMap["sku"] = secoup.Sku
	}
	if secoup.Kind != "" {
		objectMap["kind"] = secoup.Kind
	}
	if secoup.Location != nil {
		objectMap["location"] = secoup.Location
	}
	if secoup.Tags != nil {
		objectMap["tags"] = secoup.Tags
	}
	return json.Marshal(objectMap)
}

// AsStandardEnvironmentCreateOrUpdateParameters is the BasicEnvironmentCreateOrUpdateParameters implementation for StandardEnvironmentCreateOrUpdateParameters.
func (secoup StandardEnvironmentCreateOrUpdateParameters) AsStandardEnvironmentCreateOrUpdateParameters() (*StandardEnvironmentCreateOrUpdateParameters, bool) {
	return &secoup, true
}

// AsLongTermEnvironmentCreateOrUpdateParameters is the BasicEnvironmentCreateOrUpdateParameters implementation for StandardEnvironmentCreateOrUpdateParameters.
func (secoup StandardEnvironmentCreateOrUpdateParameters) AsLongTermEnvironmentCreateOrUpdateParameters() (*LongTermEnvironmentCreateOrUpdateParameters, bool) {
	return nil, false
}

// AsEnvironmentCreateOrUpdateParameters is the BasicEnvironmentCreateOrUpdateParameters implementation for StandardEnvironmentCreateOrUpdateParameters.
func (secoup StandardEnvironmentCreateOrUpdateParameters) AsEnvironmentCreateOrUpdateParameters() (*EnvironmentCreateOrUpdateParameters, bool) {
	return nil, false
}

// AsBasicEnvironmentCreateOrUpdateParameters is the BasicEnvironmentCreateOrUpdateParameters implementation for StandardEnvironmentCreateOrUpdateParameters.
func (secoup StandardEnvironmentCreateOrUpdateParameters) AsBasicEnvironmentCreateOrUpdateParameters() (BasicEnvironmentCreateOrUpdateParameters, bool) {
	return &secoup, true
}

// UnmarshalJSON is the custom unmarshaler for StandardEnvironmentCreateOrUpdateParameters struct.
func (secoup *StandardEnvironmentCreateOrUpdateParameters) UnmarshalJSON(body []byte) error {
	var m map[string]*json.RawMessage
	err := json.Unmarshal(body, &m)
	if err != nil {
		return err
	}
	for k, v := range m {
		switch k {
		case "properties":
			if v != nil {
				var standardEnvironmentCreationProperties StandardEnvironmentCreationProperties
				err = json.Unmarshal(*v, &standardEnvironmentCreationProperties)
				if err != nil {
					return err
				}
				secoup.StandardEnvironmentCreationProperties = &standardEnvironmentCreationProperties
			}
		case "sku":
			if v != nil {
				var sku Sku
				err = json.Unmarshal(*v, &sku)
				if err != nil {
					return err
				}
				secoup.Sku = &sku
			}
		case "kind":
			if v != nil {
				var kind Kind
				err = json.Unmarshal(*v, &kind)
				if err != nil {
					return err
				}
				secoup.Kind = kind
			}
		case "location":
			if v != nil {
				var location string
				err = json.Unmarshal(*v, &location)
				if err != nil {
					return err
				}
				secoup.Location = &location
			}
		case "tags":
			if v != nil {
				var tags map[string]*string
				err = json.Unmarshal(*v, &tags)
				if err != nil {
					return err
				}
				secoup.Tags = tags
			}
		}
	}

	return nil
}

// StandardEnvironmentCreationProperties properties used to create a standard environment.
type StandardEnvironmentCreationProperties struct {
	// DataRetentionTime - ISO8601 timespan specifying the minimum number of days the environment's events will be available for query.
	DataRetentionTime *string `json:"dataRetentionTime,omitempty"`
	// StorageLimitExceededBehavior - The behavior the Time Series Insights service should take when the environment's capacity has been exceeded. If "PauseIngress" is specified, new events will not be read from the event source. If "PurgeOldData" is specified, new events will continue to be read and old events will be deleted from the environment. The default behavior is PurgeOldData. Possible values include: 'PurgeOldData', 'PauseIngress'
	StorageLimitExceededBehavior StorageLimitExceededBehavior `json:"storageLimitExceededBehavior,omitempty"`
	// PartitionKeyProperties - The list of event properties which will be used to partition data in the environment. Currently, only a single partition key property is supported.
	PartitionKeyProperties *[]TimeSeriesIDProperty `json:"partitionKeyProperties,omitempty"`
}

// StandardEnvironmentMutableProperties an object that represents a set of mutable standard environment
// resource properties.
type StandardEnvironmentMutableProperties struct {
	// DataRetentionTime - ISO8601 timespan specifying the minimum number of days the environment's events will be available for query.
	DataRetentionTime *string `json:"dataRetentionTime,omitempty"`
	// StorageLimitExceededBehavior - The behavior the Time Series Insights service should take when the environment's capacity has been exceeded. If "PauseIngress" is specified, new events will not be read from the event source. If "PurgeOldData" is specified, new events will continue to be read and old events will be deleted from the environment. The default behavior is PurgeOldData. Possible values include: 'PurgeOldData', 'PauseIngress'
	StorageLimitExceededBehavior StorageLimitExceededBehavior `json:"storageLimitExceededBehavior,omitempty"`
}

// StandardEnvironmentResource an environment is a set of time-series data available for query, and is the
// top level Azure Time Series Insights resource. Standard environments have data retention limits.
type StandardEnvironmentResource struct {
	*StandardEnvironmentResourceProperties `json:"properties,omitempty"`
	// Sku - The sku determines the type of environment, either standard (S1 or S2) or long-term (L1). For standard environments the sku determines the capacity of the environment, the ingress rate, and the billing rate.
	Sku *Sku `json:"sku,omitempty"`
	// Kind - Possible values include: 'KindBasicEnvironmentResourceKindEnvironmentResource', 'KindBasicEnvironmentResourceKindStandard', 'KindBasicEnvironmentResourceKindLongTerm'
	Kind KindBasicEnvironmentResource `json:"kind,omitempty"`
	// Location - Resource location
	Location *string `json:"location,omitempty"`
	// Tags - Resource tags
	Tags map[string]*string `json:"tags"`
	// ID - READ-ONLY; Resource Id
	ID *string `json:"id,omitempty"`
	// Name - READ-ONLY; Resource name
	Name *string `json:"name,omitempty"`
	// Type - READ-ONLY; Resource type
	Type *string `json:"type,omitempty"`
}

// MarshalJSON is the custom marshaler for StandardEnvironmentResource.
func (ser StandardEnvironmentResource) MarshalJSON() ([]byte, error) {
	ser.Kind = KindBasicEnvironmentResourceKindStandard
	objectMap := make(map[string]interface{})
	if ser.StandardEnvironmentResourceProperties != nil {
		objectMap["properties"] = ser.StandardEnvironmentResourceProperties
	}
	if ser.Sku != nil {
		objectMap["sku"] = ser.Sku
	}
	if ser.Kind != "" {
		objectMap["kind"] = ser.Kind
	}
	if ser.Location != nil {
		objectMap["location"] = ser.Location
	}
	if ser.Tags != nil {
		objectMap["tags"] = ser.Tags
	}
	return json.Marshal(objectMap)
}

// AsStandardEnvironmentResource is the BasicEnvironmentResource implementation for StandardEnvironmentResource.
func (ser StandardEnvironmentResource) AsStandardEnvironmentResource() (*StandardEnvironmentResource, bool) {
	return &ser, true
}

// AsLongTermEnvironmentResource is the BasicEnvironmentResource implementation for StandardEnvironmentResource.
func (ser StandardEnvironmentResource) AsLongTermEnvironmentResource() (*LongTermEnvironmentResource, bool) {
	return nil, false
}

// AsEnvironmentResource is the BasicEnvironmentResource implementation for StandardEnvironmentResource.
func (ser StandardEnvironmentResource) AsEnvironmentResource() (*EnvironmentResource, bool) {
	return nil, false
}

// AsBasicEnvironmentResource is the BasicEnvironmentResource implementation for StandardEnvironmentResource.
func (ser StandardEnvironmentResource) AsBasicEnvironmentResource() (BasicEnvironmentResource, bool) {
	return &ser, true
}

// UnmarshalJSON is the custom unmarshaler for StandardEnvironmentResource struct.
func (ser *StandardEnvironmentResource) UnmarshalJSON(body []byte) error {
	var m map[string]*json.RawMessage
	err := json.Unmarshal(body, &m)
	if err != nil {
		return err
	}
	for k, v := range m {
		switch k {
		case "properties":
			if v != nil {
				var standardEnvironmentResourceProperties StandardEnvironmentResourceProperties
				err = json.Unmarshal(*v, &standardEnvironmentResourceProperties)
				if err != nil {
					return err
				}
				ser.StandardEnvironmentResourceProperties = &standardEnvironmentResourceProperties
			}
		case "sku":
			if v != nil {
				var sku Sku
				err = json.Unmarshal(*v, &sku)
				if err != nil {
					return err
				}
				ser.Sku = &sku
			}
		case "kind":
			if v != nil {
				var kind KindBasicEnvironmentResource
				err = json.Unmarshal(*v, &kind)
				if err != nil {
					return err
				}
				ser.Kind = kind
			}
		case "location":
			if v != nil {
				var location string
				err = json.Unmarshal(*v, &location)
				if err != nil {
					return err
				}
				ser.Location = &location
			}
		case "tags":
			if v != nil {
				var tags map[string]*string
				err = json.Unmarshal(*v, &tags)
				if err != nil {
					return err
				}
				ser.Tags = tags
			}
		case "id":
			if v != nil {
				var ID string
				err = json.Unmarshal(*v, &ID)
				if err != nil {
					return err
				}
				ser.ID = &ID
			}
		case "name":
			if v != nil {
				var name string
				err = json.Unmarshal(*v, &name)
				if err != nil {
					return err
				}
				ser.Name = &name
			}
		case "type":
			if v != nil {
				var typeVar string
				err = json.Unmarshal(*v, &typeVar)
				if err != nil {
					return err
				}
				ser.Type = &typeVar
			}
		}
	}

	return nil
}

// StandardEnvironmentResourceProperties properties of the standard environment.
type StandardEnvironmentResourceProperties struct {
	// DataRetentionTime - ISO8601 timespan specifying the minimum number of days the environment's events will be available for query.
	DataRetentionTime *string `json:"dataRetentionTime,omitempty"`
	// StorageLimitExceededBehavior - The behavior the Time Series Insights service should take when the environment's capacity has been exceeded. If "PauseIngress" is specified, new events will not be read from the event source. If "PurgeOldData" is specified, new events will continue to be read and old events will be deleted from the environment. The default behavior is PurgeOldData. Possible values include: 'PurgeOldData', 'PauseIngress'
	StorageLimitExceededBehavior StorageLimitExceededBehavior `json:"storageLimitExceededBehavior,omitempty"`
	// PartitionKeyProperties - The list of event properties which will be used to partition data in the environment. Currently, only a single partition key property is supported.
	PartitionKeyProperties *[]TimeSeriesIDProperty `json:"partitionKeyProperties,omitempty"`
	// DataAccessID - READ-ONLY; An id used to access the environment data, e.g. to query the environment's events or upload reference data for the environment.
	DataAccessID *uuid.UUID `json:"dataAccessId,omitempty"`
	// DataAccessFqdn - READ-ONLY; The fully qualified domain name used to access the environment data, e.g. to query the environment's events or upload reference data for the environment.
	DataAccessFqdn *string `json:"dataAccessFqdn,omitempty"`
	// Status - An object that represents the status of the environment, and its internal state in the Time Series Insights service.
	Status *EnvironmentStatus `json:"status,omitempty"`
	// ProvisioningState - Provisioning state of the resource. Possible values include: 'Accepted', 'Creating', 'Updating', 'Succeeded', 'Failed', 'Deleting'
	ProvisioningState ProvisioningState `json:"provisioningState,omitempty"`
	// CreationTime - READ-ONLY; The time the resource was created.
	CreationTime *date.Time `json:"creationTime,omitempty"`
}

// MarshalJSON is the custom marshaler for StandardEnvironmentResourceProperties.
func (serp StandardEnvironmentResourceProperties) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if serp.DataRetentionTime != nil {
		objectMap["dataRetentionTime"] = serp.DataRetentionTime
	}
	if serp.StorageLimitExceededBehavior != "" {
		objectMap["storageLimitExceededBehavior"] = serp.StorageLimitExceededBehavior
	}
	if serp.PartitionKeyProperties != nil {
		objectMap["partitionKeyProperties"] = serp.PartitionKeyProperties
	}
	if serp.Status != nil {
		objectMap["status"] = serp.Status
	}
	if serp.ProvisioningState != "" {
		objectMap["provisioningState"] = serp.ProvisioningState
	}
	return json.Marshal(objectMap)
}

// StandardEnvironmentUpdateParameters parameters supplied to the Update Environment operation to update a
// standard environment.
type StandardEnvironmentUpdateParameters struct {
	// Sku - The sku of the environment.
	Sku *Sku `json:"sku,omitempty"`
	// StandardEnvironmentMutableProperties - Properties of the standard environment.
	*StandardEnvironmentMutableProperties `json:"properties,omitempty"`
	// Tags - Key-value pairs of additional properties for the environment.
	Tags map[string]*string `json:"tags"`
}

// MarshalJSON is the custom marshaler for StandardEnvironmentUpdateParameters.
func (seup StandardEnvironmentUpdateParameters) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if seup.Sku != nil {
		objectMap["sku"] = seup.Sku
	}
	if seup.StandardEnvironmentMutableProperties != nil {
		objectMap["properties"] = seup.StandardEnvironmentMutableProperties
	}
	if seup.Tags != nil {
		objectMap["tags"] = seup.Tags
	}
	return json.Marshal(objectMap)
}

// UnmarshalJSON is the custom unmarshaler for StandardEnvironmentUpdateParameters struct.
func (seup *StandardEnvironmentUpdateParameters) UnmarshalJSON(body []byte) error {
	var m map[string]*json.RawMessage
	err := json.Unmarshal(body, &m)
	if err != nil {
		return err
	}
	for k, v := range m {
		switch k {
		case "sku":
			if v != nil {
				var sku Sku
				err = json.Unmarshal(*v, &sku)
				if err != nil {
					return err
				}
				seup.Sku = &sku
			}
		case "properties":
			if v != nil {
				var standardEnvironmentMutableProperties StandardEnvironmentMutableProperties
				err = json.Unmarshal(*v, &standardEnvironmentMutableProperties)
				if err != nil {
					return err
				}
				seup.StandardEnvironmentMutableProperties = &standardEnvironmentMutableProperties
			}
		case "tags":
			if v != nil {
				var tags map[string]*string
				err = json.Unmarshal(*v, &tags)
				if err != nil {
					return err
				}
				seup.Tags = tags
			}
		}
	}

	return nil
}

// TimeSeriesIDProperty the structure of the property that a time series id can have. An environment can
// have multiple such properties.
type TimeSeriesIDProperty struct {
	// Name - The name of the property.
	Name *string `json:"name,omitempty"`
	// Type - The type of the property. Possible values include: 'String'
	Type PropertyType `json:"type,omitempty"`
}

// TrackedResource time Series Insights resource that is tracked by Azure Resource Manager.
type TrackedResource struct {
	// Location - Resource location
	Location *string `json:"location,omitempty"`
	// Tags - Resource tags
	Tags map[string]*string `json:"tags"`
	// ID - READ-ONLY; Resource Id
	ID *string `json:"id,omitempty"`
	// Name - READ-ONLY; Resource name
	Name *string `json:"name,omitempty"`
	// Type - READ-ONLY; Resource type
	Type *string `json:"type,omitempty"`
}

// MarshalJSON is the custom marshaler for TrackedResource.
func (tr TrackedResource) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if tr.Location != nil {
		objectMap["location"] = tr.Location
	}
	if tr.Tags != nil {
		objectMap["tags"] = tr.Tags
	}
	return json.Marshal(objectMap)
}

// WarmStorageEnvironmentStatus an object that represents the status of warm storage on an environment.
type WarmStorageEnvironmentStatus struct {
	// WarmStoragePropertiesUsage - An object that contains the status of warm storage properties usage.
	*WarmStoragePropertiesUsage `json:"propertiesUsage,omitempty"`
}

// MarshalJSON is the custom marshaler for WarmStorageEnvironmentStatus.
func (wses WarmStorageEnvironmentStatus) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if wses.WarmStoragePropertiesUsage != nil {
		objectMap["propertiesUsage"] = wses.WarmStoragePropertiesUsage
	}
	return json.Marshal(objectMap)
}

// UnmarshalJSON is the custom unmarshaler for WarmStorageEnvironmentStatus struct.
func (wses *WarmStorageEnvironmentStatus) UnmarshalJSON(body []byte) error {
	var m map[string]*json.RawMessage
	err := json.Unmarshal(body, &m)
	if err != nil {
		return err
	}
	for k, v := range m {
		switch k {
		case "propertiesUsage":
			if v != nil {
				var warmStoragePropertiesUsage WarmStoragePropertiesUsage
				err = json.Unmarshal(*v, &warmStoragePropertiesUsage)
				if err != nil {
					return err
				}
				wses.WarmStoragePropertiesUsage = &warmStoragePropertiesUsage
			}
		}
	}

	return nil
}

// WarmStoragePropertiesUsage an object that contains the status of warm storage properties usage.
type WarmStoragePropertiesUsage struct {
	// State - This string represents the state of warm storage properties usage. It can be "Ok", "Error", "Unknown". Possible values include: 'WarmStoragePropertiesStateOk', 'WarmStoragePropertiesStateError', 'WarmStoragePropertiesStateUnknown'
	State WarmStoragePropertiesState `json:"state,omitempty"`
	// WarmStoragePropertiesUsageStateDetails - An object that contains the details about warm storage properties usage state.
	*WarmStoragePropertiesUsageStateDetails `json:"stateDetails,omitempty"`
}

// MarshalJSON is the custom marshaler for WarmStoragePropertiesUsage.
func (wspu WarmStoragePropertiesUsage) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	if wspu.State != "" {
		objectMap["state"] = wspu.State
	}
	if wspu.WarmStoragePropertiesUsageStateDetails != nil {
		objectMap["stateDetails"] = wspu.WarmStoragePropertiesUsageStateDetails
	}
	return json.Marshal(objectMap)
}

// UnmarshalJSON is the custom unmarshaler for WarmStoragePropertiesUsage struct.
func (wspu *WarmStoragePropertiesUsage) UnmarshalJSON(body []byte) error {
	var m map[string]*json.RawMessage
	err := json.Unmarshal(body, &m)
	if err != nil {
		return err
	}
	for k, v := range m {
		switch k {
		case "state":
			if v != nil {
				var state WarmStoragePropertiesState
				err = json.Unmarshal(*v, &state)
				if err != nil {
					return err
				}
				wspu.State = state
			}
		case "stateDetails":
			if v != nil {
				var warmStoragePropertiesUsageStateDetails WarmStoragePropertiesUsageStateDetails
				err = json.Unmarshal(*v, &warmStoragePropertiesUsageStateDetails)
				if err != nil {
					return err
				}
				wspu.WarmStoragePropertiesUsageStateDetails = &warmStoragePropertiesUsageStateDetails
			}
		}
	}

	return nil
}

// WarmStoragePropertiesUsageStateDetails an object that contains the details about warm storage properties
// usage state.
type WarmStoragePropertiesUsageStateDetails struct {
	// CurrentCount - A value that represents the number of properties used by the environment for S1/S2 SKU and number of properties used by Warm Store for PAYG SKU
	CurrentCount *int32 `json:"currentCount,omitempty"`
	// MaxCount - A value that represents the maximum number of properties used allowed by the environment for S1/S2 SKU and maximum number of properties allowed by Warm Store for PAYG SKU.
	MaxCount *int32 `json:"maxCount,omitempty"`
}

// WarmStoreConfigurationProperties the warm store configuration provides the details to create a warm
// store cache that will retain a copy of the environment's data available for faster query.
type WarmStoreConfigurationProperties struct {
	// DataRetention - ISO8601 timespan specifying the number of days the environment's events will be available for query from the warm store.
	DataRetention *string `json:"dataRetention,omitempty"`
}