/*
 * DO NOT EDIT.  THIS FILE IS GENERATED FROM ../../../dist/idl/calICalendar.idl
 */

#ifndef __gen_calICalendar_h__
#define __gen_calICalendar_h__


#ifndef __gen_nsISupports_h__
#include "nsISupports.h"
#endif

/* For IDL files that don't want to include root IDL files. */
#ifndef NS_NO_VTABLE
#define NS_NO_VTABLE
#endif
class nsIURI; /* forward declaration */

class calIItemBase; /* forward declaration */

class nsIVariant; /* forward declaration */

class nsISimpleEnumerator; /* forward declaration */

class calICalendarACLManager; /* forward declaration */

class calICalendarACLEntry; /* forward declaration */

class calIObserver; /* forward declaration */

class calIOperationListener; /* forward declaration */

class calIRange; /* forward declaration */

class calIDateTime; /* forward declaration */

class calIOperation; /* forward declaration */

class calIStatusObserver; /* forward declaration */

class nsIDOMChromeWindow; /* forward declaration */


/* starting interface:    calICalendar */
#define CALICALENDAR_IID_STR "b18782c0-6557-4e8e-931d-4bf052f0a31e"

#define CALICALENDAR_IID \
  {0xb18782c0, 0x6557, 0x4e8e, \
    { 0x93, 0x1d, 0x4b, 0xf0, 0x52, 0xf0, 0xa3, 0x1e }}

class NS_NO_VTABLE calICalendar : public nsISupports {
 public:

  NS_DECLARE_STATIC_IID_ACCESSOR(CALICALENDAR_IID)

  /* attribute AUTF8String id; */
  NS_IMETHOD GetId(nsACString & aId) = 0;
  NS_IMETHOD SetId(const nsACString & aId) = 0;

  /* attribute AUTF8String name; */
  NS_IMETHOD GetName(nsACString & aName) = 0;
  NS_IMETHOD SetName(const nsACString & aName) = 0;

  /* readonly attribute AUTF8String type; */
  NS_IMETHOD GetType(nsACString & aType) = 0;

  /* readonly attribute AString providerID; */
  NS_IMETHOD GetProviderID(nsAString & aProviderID) = 0;

  /* readonly attribute calICalendarACLManager aclManager; */
  NS_IMETHOD GetAclManager(calICalendarACLManager * *aAclManager) = 0;

  /* readonly attribute calICalendarACLEntry aclEntry; */
  NS_IMETHOD GetAclEntry(calICalendarACLEntry * *aAclEntry) = 0;

  /* attribute calICalendar superCalendar; */
  NS_IMETHOD GetSuperCalendar(calICalendar * *aSuperCalendar) = 0;
  NS_IMETHOD SetSuperCalendar(calICalendar *aSuperCalendar) = 0;

  /* attribute nsIURI uri; */
  NS_IMETHOD GetUri(nsIURI * *aUri) = 0;
  NS_IMETHOD SetUri(nsIURI *aUri) = 0;

  /* attribute boolean readOnly; */
  NS_IMETHOD GetReadOnly(bool *aReadOnly) = 0;
  NS_IMETHOD SetReadOnly(bool aReadOnly) = 0;

  /* readonly attribute boolean canRefresh; */
  NS_IMETHOD GetCanRefresh(bool *aCanRefresh) = 0;

  /* attribute boolean transientProperties; */
  NS_IMETHOD GetTransientProperties(bool *aTransientProperties) = 0;
  NS_IMETHOD SetTransientProperties(bool aTransientProperties) = 0;

  /* nsIVariant getProperty (in AUTF8String aName); */
  NS_IMETHOD GetProperty(const nsACString & aName, nsIVariant * *_retval) = 0;

  /* void setProperty (in AUTF8String aName, in nsIVariant aValue); */
  NS_IMETHOD SetProperty(const nsACString & aName, nsIVariant *aValue) = 0;

  /* void deleteProperty (in AUTF8String aName); */
  NS_IMETHOD DeleteProperty(const nsACString & aName) = 0;

  enum {
    ITEM_FILTER_COMPLETED_YES = 1U,
    ITEM_FILTER_COMPLETED_NO = 2U,
    ITEM_FILTER_COMPLETED_ALL = 3U,
    ITEM_FILTER_TYPE_TODO = 4U,
    ITEM_FILTER_TYPE_EVENT = 8U,
    ITEM_FILTER_TYPE_JOURNAL = 16U,
    ITEM_FILTER_TYPE_ALL = 28U,
    ITEM_FILTER_ALL_ITEMS = 65535U,
    ITEM_FILTER_CLASS_OCCURRENCES = 65536U,
    ITEM_FILTER_REQUEST_NEEDS_ACTION = 131072U,
    ITEM_FILTER_OFFLINE_CREATED = 536870912U,
    ITEM_FILTER_OFFLINE_MODIFIED = 1073741824U,
    ITEM_FILTER_OFFLINE_DELETED = 2147483648U
  };

  /* void addObserver (in calIObserver observer); */
  NS_IMETHOD AddObserver(calIObserver *observer) = 0;

  /* void removeObserver (in calIObserver observer); */
  NS_IMETHOD RemoveObserver(calIObserver *observer) = 0;

  /* calIOperation addItem (in calIItemBase aItem, in calIOperationListener aListener); */
  NS_IMETHOD AddItem(calIItemBase *aItem, calIOperationListener *aListener, calIOperation * *_retval) = 0;

  /* calIOperation adoptItem (in calIItemBase aItem, in calIOperationListener aListener); */
  NS_IMETHOD AdoptItem(calIItemBase *aItem, calIOperationListener *aListener, calIOperation * *_retval) = 0;

  /* calIOperation modifyItem (in calIItemBase aNewItem, in calIItemBase aOldItem, in calIOperationListener aListener); */
  NS_IMETHOD ModifyItem(calIItemBase *aNewItem, calIItemBase *aOldItem, calIOperationListener *aListener, calIOperation * *_retval) = 0;

  /* calIOperation deleteItem (in calIItemBase aItem, in calIOperationListener aListener); */
  NS_IMETHOD DeleteItem(calIItemBase *aItem, calIOperationListener *aListener, calIOperation * *_retval) = 0;

  /* calIOperation getItem (in string aId, in calIOperationListener aListener); */
  NS_IMETHOD GetItem(const char * aId, calIOperationListener *aListener, calIOperation * *_retval) = 0;

  /* calIOperation getItems (in unsigned long aItemFilter, in unsigned long aCount, in calIDateTime aRangeStart, in calIDateTime aRangeEndEx, in calIOperationListener aListener); */
  NS_IMETHOD GetItems(uint32_t aItemFilter, uint32_t aCount, calIDateTime *aRangeStart, calIDateTime *aRangeEndEx, calIOperationListener *aListener, calIOperation * *_retval) = 0;

  /* calIOperation refresh (); */
  NS_IMETHOD Refresh(calIOperation * *_retval) = 0;

  /* void startBatch (); */
  NS_IMETHOD StartBatch(void) = 0;

  /* void endBatch (); */
  NS_IMETHOD EndBatch(void) = 0;

};

  NS_DEFINE_STATIC_IID_ACCESSOR(calICalendar, CALICALENDAR_IID)

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_CALICALENDAR \
  NS_IMETHOD GetId(nsACString & aId) override; \
  NS_IMETHOD SetId(const nsACString & aId) override; \
  NS_IMETHOD GetName(nsACString & aName) override; \
  NS_IMETHOD SetName(const nsACString & aName) override; \
  NS_IMETHOD GetType(nsACString & aType) override; \
  NS_IMETHOD GetProviderID(nsAString & aProviderID) override; \
  NS_IMETHOD GetAclManager(calICalendarACLManager * *aAclManager) override; \
  NS_IMETHOD GetAclEntry(calICalendarACLEntry * *aAclEntry) override; \
  NS_IMETHOD GetSuperCalendar(calICalendar * *aSuperCalendar) override; \
  NS_IMETHOD SetSuperCalendar(calICalendar *aSuperCalendar) override; \
  NS_IMETHOD GetUri(nsIURI * *aUri) override; \
  NS_IMETHOD SetUri(nsIURI *aUri) override; \
  NS_IMETHOD GetReadOnly(bool *aReadOnly) override; \
  NS_IMETHOD SetReadOnly(bool aReadOnly) override; \
  NS_IMETHOD GetCanRefresh(bool *aCanRefresh) override; \
  NS_IMETHOD GetTransientProperties(bool *aTransientProperties) override; \
  NS_IMETHOD SetTransientProperties(bool aTransientProperties) override; \
  NS_IMETHOD GetProperty(const nsACString & aName, nsIVariant * *_retval) override; \
  NS_IMETHOD SetProperty(const nsACString & aName, nsIVariant *aValue) override; \
  NS_IMETHOD DeleteProperty(const nsACString & aName) override; \
  NS_IMETHOD AddObserver(calIObserver *observer) override; \
  NS_IMETHOD RemoveObserver(calIObserver *observer) override; \
  NS_IMETHOD AddItem(calIItemBase *aItem, calIOperationListener *aListener, calIOperation * *_retval) override; \
  NS_IMETHOD AdoptItem(calIItemBase *aItem, calIOperationListener *aListener, calIOperation * *_retval) override; \
  NS_IMETHOD ModifyItem(calIItemBase *aNewItem, calIItemBase *aOldItem, calIOperationListener *aListener, calIOperation * *_retval) override; \
  NS_IMETHOD DeleteItem(calIItemBase *aItem, calIOperationListener *aListener, calIOperation * *_retval) override; \
  NS_IMETHOD GetItem(const char * aId, calIOperationListener *aListener, calIOperation * *_retval) override; \
  NS_IMETHOD GetItems(uint32_t aItemFilter, uint32_t aCount, calIDateTime *aRangeStart, calIDateTime *aRangeEndEx, calIOperationListener *aListener, calIOperation * *_retval) override; \
  NS_IMETHOD Refresh(calIOperation * *_retval) override; \
  NS_IMETHOD StartBatch(void) override; \
  NS_IMETHOD EndBatch(void) override; 

/* Use this macro when declaring the members of this interface when the
   class doesn't implement the interface. This is useful for forwarding. */
#define NS_DECL_NON_VIRTUAL_CALICALENDAR \
  NS_METHOD GetId(nsACString & aId); \
  NS_METHOD SetId(const nsACString & aId); \
  NS_METHOD GetName(nsACString & aName); \
  NS_METHOD SetName(const nsACString & aName); \
  NS_METHOD GetType(nsACString & aType); \
  NS_METHOD GetProviderID(nsAString & aProviderID); \
  NS_METHOD GetAclManager(calICalendarACLManager * *aAclManager); \
  NS_METHOD GetAclEntry(calICalendarACLEntry * *aAclEntry); \
  NS_METHOD GetSuperCalendar(calICalendar * *aSuperCalendar); \
  NS_METHOD SetSuperCalendar(calICalendar *aSuperCalendar); \
  NS_METHOD GetUri(nsIURI * *aUri); \
  NS_METHOD SetUri(nsIURI *aUri); \
  NS_METHOD GetReadOnly(bool *aReadOnly); \
  NS_METHOD SetReadOnly(bool aReadOnly); \
  NS_METHOD GetCanRefresh(bool *aCanRefresh); \
  NS_METHOD GetTransientProperties(bool *aTransientProperties); \
  NS_METHOD SetTransientProperties(bool aTransientProperties); \
  NS_METHOD GetProperty(const nsACString & aName, nsIVariant * *_retval); \
  NS_METHOD SetProperty(const nsACString & aName, nsIVariant *aValue); \
  NS_METHOD DeleteProperty(const nsACString & aName); \
  NS_METHOD AddObserver(calIObserver *observer); \
  NS_METHOD RemoveObserver(calIObserver *observer); \
  NS_METHOD AddItem(calIItemBase *aItem, calIOperationListener *aListener, calIOperation * *_retval); \
  NS_METHOD AdoptItem(calIItemBase *aItem, calIOperationListener *aListener, calIOperation * *_retval); \
  NS_METHOD ModifyItem(calIItemBase *aNewItem, calIItemBase *aOldItem, calIOperationListener *aListener, calIOperation * *_retval); \
  NS_METHOD DeleteItem(calIItemBase *aItem, calIOperationListener *aListener, calIOperation * *_retval); \
  NS_METHOD GetItem(const char * aId, calIOperationListener *aListener, calIOperation * *_retval); \
  NS_METHOD GetItems(uint32_t aItemFilter, uint32_t aCount, calIDateTime *aRangeStart, calIDateTime *aRangeEndEx, calIOperationListener *aListener, calIOperation * *_retval); \
  NS_METHOD Refresh(calIOperation * *_retval); \
  NS_METHOD StartBatch(void); \
  NS_METHOD EndBatch(void); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_CALICALENDAR(_to) \
  NS_IMETHOD GetId(nsACString & aId) override { return _to GetId(aId); } \
  NS_IMETHOD SetId(const nsACString & aId) override { return _to SetId(aId); } \
  NS_IMETHOD GetName(nsACString & aName) override { return _to GetName(aName); } \
  NS_IMETHOD SetName(const nsACString & aName) override { return _to SetName(aName); } \
  NS_IMETHOD GetType(nsACString & aType) override { return _to GetType(aType); } \
  NS_IMETHOD GetProviderID(nsAString & aProviderID) override { return _to GetProviderID(aProviderID); } \
  NS_IMETHOD GetAclManager(calICalendarACLManager * *aAclManager) override { return _to GetAclManager(aAclManager); } \
  NS_IMETHOD GetAclEntry(calICalendarACLEntry * *aAclEntry) override { return _to GetAclEntry(aAclEntry); } \
  NS_IMETHOD GetSuperCalendar(calICalendar * *aSuperCalendar) override { return _to GetSuperCalendar(aSuperCalendar); } \
  NS_IMETHOD SetSuperCalendar(calICalendar *aSuperCalendar) override { return _to SetSuperCalendar(aSuperCalendar); } \
  NS_IMETHOD GetUri(nsIURI * *aUri) override { return _to GetUri(aUri); } \
  NS_IMETHOD SetUri(nsIURI *aUri) override { return _to SetUri(aUri); } \
  NS_IMETHOD GetReadOnly(bool *aReadOnly) override { return _to GetReadOnly(aReadOnly); } \
  NS_IMETHOD SetReadOnly(bool aReadOnly) override { return _to SetReadOnly(aReadOnly); } \
  NS_IMETHOD GetCanRefresh(bool *aCanRefresh) override { return _to GetCanRefresh(aCanRefresh); } \
  NS_IMETHOD GetTransientProperties(bool *aTransientProperties) override { return _to GetTransientProperties(aTransientProperties); } \
  NS_IMETHOD SetTransientProperties(bool aTransientProperties) override { return _to SetTransientProperties(aTransientProperties); } \
  NS_IMETHOD GetProperty(const nsACString & aName, nsIVariant * *_retval) override { return _to GetProperty(aName, _retval); } \
  NS_IMETHOD SetProperty(const nsACString & aName, nsIVariant *aValue) override { return _to SetProperty(aName, aValue); } \
  NS_IMETHOD DeleteProperty(const nsACString & aName) override { return _to DeleteProperty(aName); } \
  NS_IMETHOD AddObserver(calIObserver *observer) override { return _to AddObserver(observer); } \
  NS_IMETHOD RemoveObserver(calIObserver *observer) override { return _to RemoveObserver(observer); } \
  NS_IMETHOD AddItem(calIItemBase *aItem, calIOperationListener *aListener, calIOperation * *_retval) override { return _to AddItem(aItem, aListener, _retval); } \
  NS_IMETHOD AdoptItem(calIItemBase *aItem, calIOperationListener *aListener, calIOperation * *_retval) override { return _to AdoptItem(aItem, aListener, _retval); } \
  NS_IMETHOD ModifyItem(calIItemBase *aNewItem, calIItemBase *aOldItem, calIOperationListener *aListener, calIOperation * *_retval) override { return _to ModifyItem(aNewItem, aOldItem, aListener, _retval); } \
  NS_IMETHOD DeleteItem(calIItemBase *aItem, calIOperationListener *aListener, calIOperation * *_retval) override { return _to DeleteItem(aItem, aListener, _retval); } \
  NS_IMETHOD GetItem(const char * aId, calIOperationListener *aListener, calIOperation * *_retval) override { return _to GetItem(aId, aListener, _retval); } \
  NS_IMETHOD GetItems(uint32_t aItemFilter, uint32_t aCount, calIDateTime *aRangeStart, calIDateTime *aRangeEndEx, calIOperationListener *aListener, calIOperation * *_retval) override { return _to GetItems(aItemFilter, aCount, aRangeStart, aRangeEndEx, aListener, _retval); } \
  NS_IMETHOD Refresh(calIOperation * *_retval) override { return _to Refresh(_retval); } \
  NS_IMETHOD StartBatch(void) override { return _to StartBatch(); } \
  NS_IMETHOD EndBatch(void) override { return _to EndBatch(); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_CALICALENDAR(_to) \
  NS_IMETHOD GetId(nsACString & aId) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetId(aId); } \
  NS_IMETHOD SetId(const nsACString & aId) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetId(aId); } \
  NS_IMETHOD GetName(nsACString & aName) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetName(aName); } \
  NS_IMETHOD SetName(const nsACString & aName) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetName(aName); } \
  NS_IMETHOD GetType(nsACString & aType) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetType(aType); } \
  NS_IMETHOD GetProviderID(nsAString & aProviderID) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetProviderID(aProviderID); } \
  NS_IMETHOD GetAclManager(calICalendarACLManager * *aAclManager) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAclManager(aAclManager); } \
  NS_IMETHOD GetAclEntry(calICalendarACLEntry * *aAclEntry) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAclEntry(aAclEntry); } \
  NS_IMETHOD GetSuperCalendar(calICalendar * *aSuperCalendar) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetSuperCalendar(aSuperCalendar); } \
  NS_IMETHOD SetSuperCalendar(calICalendar *aSuperCalendar) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetSuperCalendar(aSuperCalendar); } \
  NS_IMETHOD GetUri(nsIURI * *aUri) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetUri(aUri); } \
  NS_IMETHOD SetUri(nsIURI *aUri) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetUri(aUri); } \
  NS_IMETHOD GetReadOnly(bool *aReadOnly) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetReadOnly(aReadOnly); } \
  NS_IMETHOD SetReadOnly(bool aReadOnly) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetReadOnly(aReadOnly); } \
  NS_IMETHOD GetCanRefresh(bool *aCanRefresh) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetCanRefresh(aCanRefresh); } \
  NS_IMETHOD GetTransientProperties(bool *aTransientProperties) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetTransientProperties(aTransientProperties); } \
  NS_IMETHOD SetTransientProperties(bool aTransientProperties) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetTransientProperties(aTransientProperties); } \
  NS_IMETHOD GetProperty(const nsACString & aName, nsIVariant * *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetProperty(aName, _retval); } \
  NS_IMETHOD SetProperty(const nsACString & aName, nsIVariant *aValue) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetProperty(aName, aValue); } \
  NS_IMETHOD DeleteProperty(const nsACString & aName) override { return !_to ? NS_ERROR_NULL_POINTER : _to->DeleteProperty(aName); } \
  NS_IMETHOD AddObserver(calIObserver *observer) override { return !_to ? NS_ERROR_NULL_POINTER : _to->AddObserver(observer); } \
  NS_IMETHOD RemoveObserver(calIObserver *observer) override { return !_to ? NS_ERROR_NULL_POINTER : _to->RemoveObserver(observer); } \
  NS_IMETHOD AddItem(calIItemBase *aItem, calIOperationListener *aListener, calIOperation * *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->AddItem(aItem, aListener, _retval); } \
  NS_IMETHOD AdoptItem(calIItemBase *aItem, calIOperationListener *aListener, calIOperation * *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->AdoptItem(aItem, aListener, _retval); } \
  NS_IMETHOD ModifyItem(calIItemBase *aNewItem, calIItemBase *aOldItem, calIOperationListener *aListener, calIOperation * *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->ModifyItem(aNewItem, aOldItem, aListener, _retval); } \
  NS_IMETHOD DeleteItem(calIItemBase *aItem, calIOperationListener *aListener, calIOperation * *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->DeleteItem(aItem, aListener, _retval); } \
  NS_IMETHOD GetItem(const char * aId, calIOperationListener *aListener, calIOperation * *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetItem(aId, aListener, _retval); } \
  NS_IMETHOD GetItems(uint32_t aItemFilter, uint32_t aCount, calIDateTime *aRangeStart, calIDateTime *aRangeEndEx, calIOperationListener *aListener, calIOperation * *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetItems(aItemFilter, aCount, aRangeStart, aRangeEndEx, aListener, _retval); } \
  NS_IMETHOD Refresh(calIOperation * *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->Refresh(_retval); } \
  NS_IMETHOD StartBatch(void) override { return !_to ? NS_ERROR_NULL_POINTER : _to->StartBatch(); } \
  NS_IMETHOD EndBatch(void) override { return !_to ? NS_ERROR_NULL_POINTER : _to->EndBatch(); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class _MYCLASS_ : public calICalendar
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_CALICALENDAR

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS(_MYCLASS_, calICalendar)

_MYCLASS_::_MYCLASS_()
{
  /* member initializers and constructor code */
}

_MYCLASS_::~_MYCLASS_()
{
  /* destructor code */
}

/* attribute AUTF8String id; */
NS_IMETHODIMP _MYCLASS_::GetId(nsACString & aId)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetId(const nsACString & aId)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AUTF8String name; */
NS_IMETHODIMP _MYCLASS_::GetName(nsACString & aName)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetName(const nsACString & aName)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute AUTF8String type; */
NS_IMETHODIMP _MYCLASS_::GetType(nsACString & aType)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute AString providerID; */
NS_IMETHODIMP _MYCLASS_::GetProviderID(nsAString & aProviderID)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute calICalendarACLManager aclManager; */
NS_IMETHODIMP _MYCLASS_::GetAclManager(calICalendarACLManager * *aAclManager)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute calICalendarACLEntry aclEntry; */
NS_IMETHODIMP _MYCLASS_::GetAclEntry(calICalendarACLEntry * *aAclEntry)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute calICalendar superCalendar; */
NS_IMETHODIMP _MYCLASS_::GetSuperCalendar(calICalendar * *aSuperCalendar)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetSuperCalendar(calICalendar *aSuperCalendar)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute nsIURI uri; */
NS_IMETHODIMP _MYCLASS_::GetUri(nsIURI * *aUri)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetUri(nsIURI *aUri)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute boolean readOnly; */
NS_IMETHODIMP _MYCLASS_::GetReadOnly(bool *aReadOnly)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetReadOnly(bool aReadOnly)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute boolean canRefresh; */
NS_IMETHODIMP _MYCLASS_::GetCanRefresh(bool *aCanRefresh)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute boolean transientProperties; */
NS_IMETHODIMP _MYCLASS_::GetTransientProperties(bool *aTransientProperties)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetTransientProperties(bool aTransientProperties)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* nsIVariant getProperty (in AUTF8String aName); */
NS_IMETHODIMP _MYCLASS_::GetProperty(const nsACString & aName, nsIVariant * *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setProperty (in AUTF8String aName, in nsIVariant aValue); */
NS_IMETHODIMP _MYCLASS_::SetProperty(const nsACString & aName, nsIVariant *aValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void deleteProperty (in AUTF8String aName); */
NS_IMETHODIMP _MYCLASS_::DeleteProperty(const nsACString & aName)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void addObserver (in calIObserver observer); */
NS_IMETHODIMP _MYCLASS_::AddObserver(calIObserver *observer)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void removeObserver (in calIObserver observer); */
NS_IMETHODIMP _MYCLASS_::RemoveObserver(calIObserver *observer)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* calIOperation addItem (in calIItemBase aItem, in calIOperationListener aListener); */
NS_IMETHODIMP _MYCLASS_::AddItem(calIItemBase *aItem, calIOperationListener *aListener, calIOperation * *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* calIOperation adoptItem (in calIItemBase aItem, in calIOperationListener aListener); */
NS_IMETHODIMP _MYCLASS_::AdoptItem(calIItemBase *aItem, calIOperationListener *aListener, calIOperation * *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* calIOperation modifyItem (in calIItemBase aNewItem, in calIItemBase aOldItem, in calIOperationListener aListener); */
NS_IMETHODIMP _MYCLASS_::ModifyItem(calIItemBase *aNewItem, calIItemBase *aOldItem, calIOperationListener *aListener, calIOperation * *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* calIOperation deleteItem (in calIItemBase aItem, in calIOperationListener aListener); */
NS_IMETHODIMP _MYCLASS_::DeleteItem(calIItemBase *aItem, calIOperationListener *aListener, calIOperation * *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* calIOperation getItem (in string aId, in calIOperationListener aListener); */
NS_IMETHODIMP _MYCLASS_::GetItem(const char * aId, calIOperationListener *aListener, calIOperation * *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* calIOperation getItems (in unsigned long aItemFilter, in unsigned long aCount, in calIDateTime aRangeStart, in calIDateTime aRangeEndEx, in calIOperationListener aListener); */
NS_IMETHODIMP _MYCLASS_::GetItems(uint32_t aItemFilter, uint32_t aCount, calIDateTime *aRangeStart, calIDateTime *aRangeEndEx, calIOperationListener *aListener, calIOperation * *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* calIOperation refresh (); */
NS_IMETHODIMP _MYCLASS_::Refresh(calIOperation * *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void startBatch (); */
NS_IMETHODIMP _MYCLASS_::StartBatch()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void endBatch (); */
NS_IMETHODIMP _MYCLASS_::EndBatch()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    calICompositeCalendar */
#define CALICOMPOSITECALENDAR_IID_STR "6748fa00-79b5-4728-84f3-20dd47e0b031"

#define CALICOMPOSITECALENDAR_IID \
  {0x6748fa00, 0x79b5, 0x4728, \
    { 0x84, 0xf3, 0x20, 0xdd, 0x47, 0xe0, 0xb0, 0x31 }}

class NS_NO_VTABLE calICompositeCalendar : public calICalendar {
 public:

  NS_DECLARE_STATIC_IID_ACCESSOR(CALICOMPOSITECALENDAR_IID)

  /* void addCalendar (in calICalendar aCalendar); */
  NS_IMETHOD AddCalendar(calICalendar *aCalendar) = 0;

  /* void removeCalendar (in calICalendar aCalendar); */
  NS_IMETHOD RemoveCalendar(calICalendar *aCalendar) = 0;

  /* calICalendar getCalendarById (in AUTF8String aId); */
  NS_IMETHOD GetCalendarById(const nsACString & aId, calICalendar * *_retval) = 0;

  /* void getCalendars (out uint32_t count, [array, size_is (count), retval] out calICalendar aCalendars); */
  NS_IMETHOD GetCalendars(uint32_t *count, calICalendar * **aCalendars) = 0;

  /* attribute calICalendar defaultCalendar; */
  NS_IMETHOD GetDefaultCalendar(calICalendar * *aDefaultCalendar) = 0;
  NS_IMETHOD SetDefaultCalendar(calICalendar *aDefaultCalendar) = 0;

  /* attribute ACString prefPrefix; */
  NS_IMETHOD GetPrefPrefix(nsACString & aPrefPrefix) = 0;
  NS_IMETHOD SetPrefPrefix(const nsACString & aPrefPrefix) = 0;

  /* readonly attribute boolean statusDisplayed; */
  NS_IMETHOD GetStatusDisplayed(bool *aStatusDisplayed) = 0;

  /* void setStatusObserver (in calIStatusObserver aStatusObserver, in nsIDOMChromeWindow aWindow); */
  NS_IMETHOD SetStatusObserver(calIStatusObserver *aStatusObserver, nsIDOMChromeWindow *aWindow) = 0;

};

  NS_DEFINE_STATIC_IID_ACCESSOR(calICompositeCalendar, CALICOMPOSITECALENDAR_IID)

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_CALICOMPOSITECALENDAR \
  NS_IMETHOD AddCalendar(calICalendar *aCalendar) override; \
  NS_IMETHOD RemoveCalendar(calICalendar *aCalendar) override; \
  NS_IMETHOD GetCalendarById(const nsACString & aId, calICalendar * *_retval) override; \
  NS_IMETHOD GetCalendars(uint32_t *count, calICalendar * **aCalendars) override; \
  NS_IMETHOD GetDefaultCalendar(calICalendar * *aDefaultCalendar) override; \
  NS_IMETHOD SetDefaultCalendar(calICalendar *aDefaultCalendar) override; \
  NS_IMETHOD GetPrefPrefix(nsACString & aPrefPrefix) override; \
  NS_IMETHOD SetPrefPrefix(const nsACString & aPrefPrefix) override; \
  NS_IMETHOD GetStatusDisplayed(bool *aStatusDisplayed) override; \
  NS_IMETHOD SetStatusObserver(calIStatusObserver *aStatusObserver, nsIDOMChromeWindow *aWindow) override; 

/* Use this macro when declaring the members of this interface when the
   class doesn't implement the interface. This is useful for forwarding. */
#define NS_DECL_NON_VIRTUAL_CALICOMPOSITECALENDAR \
  NS_METHOD AddCalendar(calICalendar *aCalendar); \
  NS_METHOD RemoveCalendar(calICalendar *aCalendar); \
  NS_METHOD GetCalendarById(const nsACString & aId, calICalendar * *_retval); \
  NS_METHOD GetCalendars(uint32_t *count, calICalendar * **aCalendars); \
  NS_METHOD GetDefaultCalendar(calICalendar * *aDefaultCalendar); \
  NS_METHOD SetDefaultCalendar(calICalendar *aDefaultCalendar); \
  NS_METHOD GetPrefPrefix(nsACString & aPrefPrefix); \
  NS_METHOD SetPrefPrefix(const nsACString & aPrefPrefix); \
  NS_METHOD GetStatusDisplayed(bool *aStatusDisplayed); \
  NS_METHOD SetStatusObserver(calIStatusObserver *aStatusObserver, nsIDOMChromeWindow *aWindow); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_CALICOMPOSITECALENDAR(_to) \
  NS_IMETHOD AddCalendar(calICalendar *aCalendar) override { return _to AddCalendar(aCalendar); } \
  NS_IMETHOD RemoveCalendar(calICalendar *aCalendar) override { return _to RemoveCalendar(aCalendar); } \
  NS_IMETHOD GetCalendarById(const nsACString & aId, calICalendar * *_retval) override { return _to GetCalendarById(aId, _retval); } \
  NS_IMETHOD GetCalendars(uint32_t *count, calICalendar * **aCalendars) override { return _to GetCalendars(count, aCalendars); } \
  NS_IMETHOD GetDefaultCalendar(calICalendar * *aDefaultCalendar) override { return _to GetDefaultCalendar(aDefaultCalendar); } \
  NS_IMETHOD SetDefaultCalendar(calICalendar *aDefaultCalendar) override { return _to SetDefaultCalendar(aDefaultCalendar); } \
  NS_IMETHOD GetPrefPrefix(nsACString & aPrefPrefix) override { return _to GetPrefPrefix(aPrefPrefix); } \
  NS_IMETHOD SetPrefPrefix(const nsACString & aPrefPrefix) override { return _to SetPrefPrefix(aPrefPrefix); } \
  NS_IMETHOD GetStatusDisplayed(bool *aStatusDisplayed) override { return _to GetStatusDisplayed(aStatusDisplayed); } \
  NS_IMETHOD SetStatusObserver(calIStatusObserver *aStatusObserver, nsIDOMChromeWindow *aWindow) override { return _to SetStatusObserver(aStatusObserver, aWindow); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_CALICOMPOSITECALENDAR(_to) \
  NS_IMETHOD AddCalendar(calICalendar *aCalendar) override { return !_to ? NS_ERROR_NULL_POINTER : _to->AddCalendar(aCalendar); } \
  NS_IMETHOD RemoveCalendar(calICalendar *aCalendar) override { return !_to ? NS_ERROR_NULL_POINTER : _to->RemoveCalendar(aCalendar); } \
  NS_IMETHOD GetCalendarById(const nsACString & aId, calICalendar * *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetCalendarById(aId, _retval); } \
  NS_IMETHOD GetCalendars(uint32_t *count, calICalendar * **aCalendars) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetCalendars(count, aCalendars); } \
  NS_IMETHOD GetDefaultCalendar(calICalendar * *aDefaultCalendar) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetDefaultCalendar(aDefaultCalendar); } \
  NS_IMETHOD SetDefaultCalendar(calICalendar *aDefaultCalendar) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetDefaultCalendar(aDefaultCalendar); } \
  NS_IMETHOD GetPrefPrefix(nsACString & aPrefPrefix) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPrefPrefix(aPrefPrefix); } \
  NS_IMETHOD SetPrefPrefix(const nsACString & aPrefPrefix) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetPrefPrefix(aPrefPrefix); } \
  NS_IMETHOD GetStatusDisplayed(bool *aStatusDisplayed) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetStatusDisplayed(aStatusDisplayed); } \
  NS_IMETHOD SetStatusObserver(calIStatusObserver *aStatusObserver, nsIDOMChromeWindow *aWindow) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetStatusObserver(aStatusObserver, aWindow); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class _MYCLASS_ : public calICompositeCalendar
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_CALICOMPOSITECALENDAR

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS(_MYCLASS_, calICompositeCalendar)

_MYCLASS_::_MYCLASS_()
{
  /* member initializers and constructor code */
}

_MYCLASS_::~_MYCLASS_()
{
  /* destructor code */
}

/* void addCalendar (in calICalendar aCalendar); */
NS_IMETHODIMP _MYCLASS_::AddCalendar(calICalendar *aCalendar)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void removeCalendar (in calICalendar aCalendar); */
NS_IMETHODIMP _MYCLASS_::RemoveCalendar(calICalendar *aCalendar)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* calICalendar getCalendarById (in AUTF8String aId); */
NS_IMETHODIMP _MYCLASS_::GetCalendarById(const nsACString & aId, calICalendar * *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void getCalendars (out uint32_t count, [array, size_is (count), retval] out calICalendar aCalendars); */
NS_IMETHODIMP _MYCLASS_::GetCalendars(uint32_t *count, calICalendar * **aCalendars)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute calICalendar defaultCalendar; */
NS_IMETHODIMP _MYCLASS_::GetDefaultCalendar(calICalendar * *aDefaultCalendar)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetDefaultCalendar(calICalendar *aDefaultCalendar)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute ACString prefPrefix; */
NS_IMETHODIMP _MYCLASS_::GetPrefPrefix(nsACString & aPrefPrefix)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetPrefPrefix(const nsACString & aPrefPrefix)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute boolean statusDisplayed; */
NS_IMETHODIMP _MYCLASS_::GetStatusDisplayed(bool *aStatusDisplayed)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setStatusObserver (in calIStatusObserver aStatusObserver, in nsIDOMChromeWindow aWindow); */
NS_IMETHODIMP _MYCLASS_::SetStatusObserver(calIStatusObserver *aStatusObserver, nsIDOMChromeWindow *aWindow)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    calIObserver */
#define CALIOBSERVER_IID_STR "2953c9b2-2c73-11d9-80b6-00045ace3b8d"

#define CALIOBSERVER_IID \
  {0x2953c9b2, 0x2c73, 0x11d9, \
    { 0x80, 0xb6, 0x00, 0x04, 0x5a, 0xce, 0x3b, 0x8d }}

class NS_NO_VTABLE calIObserver : public nsISupports {
 public:

  NS_DECLARE_STATIC_IID_ACCESSOR(CALIOBSERVER_IID)

  /* void onStartBatch (); */
  NS_IMETHOD OnStartBatch(void) = 0;

  /* void onEndBatch (); */
  NS_IMETHOD OnEndBatch(void) = 0;

  /* void onLoad (in calICalendar aCalendar); */
  NS_IMETHOD OnLoad(calICalendar *aCalendar) = 0;

  /* void onAddItem (in calIItemBase aItem); */
  NS_IMETHOD OnAddItem(calIItemBase *aItem) = 0;

  /* void onModifyItem (in calIItemBase aNewItem, in calIItemBase aOldItem); */
  NS_IMETHOD OnModifyItem(calIItemBase *aNewItem, calIItemBase *aOldItem) = 0;

  /* void onDeleteItem (in calIItemBase aDeletedItem); */
  NS_IMETHOD OnDeleteItem(calIItemBase *aDeletedItem) = 0;

  /* void onError (in calICalendar aCalendar, in nsresult aErrNo, in AUTF8String aMessage); */
  NS_IMETHOD OnError(calICalendar *aCalendar, nsresult aErrNo, const nsACString & aMessage) = 0;

  /* void onPropertyChanged (in calICalendar aCalendar, in AUTF8String aName, in nsIVariant aValue, in nsIVariant aOldValue); */
  NS_IMETHOD OnPropertyChanged(calICalendar *aCalendar, const nsACString & aName, nsIVariant *aValue, nsIVariant *aOldValue) = 0;

  /* void onPropertyDeleting (in calICalendar aCalendar, in AUTF8String aName); */
  NS_IMETHOD OnPropertyDeleting(calICalendar *aCalendar, const nsACString & aName) = 0;

};

  NS_DEFINE_STATIC_IID_ACCESSOR(calIObserver, CALIOBSERVER_IID)

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_CALIOBSERVER \
  NS_IMETHOD OnStartBatch(void) override; \
  NS_IMETHOD OnEndBatch(void) override; \
  NS_IMETHOD OnLoad(calICalendar *aCalendar) override; \
  NS_IMETHOD OnAddItem(calIItemBase *aItem) override; \
  NS_IMETHOD OnModifyItem(calIItemBase *aNewItem, calIItemBase *aOldItem) override; \
  NS_IMETHOD OnDeleteItem(calIItemBase *aDeletedItem) override; \
  NS_IMETHOD OnError(calICalendar *aCalendar, nsresult aErrNo, const nsACString & aMessage) override; \
  NS_IMETHOD OnPropertyChanged(calICalendar *aCalendar, const nsACString & aName, nsIVariant *aValue, nsIVariant *aOldValue) override; \
  NS_IMETHOD OnPropertyDeleting(calICalendar *aCalendar, const nsACString & aName) override; 

/* Use this macro when declaring the members of this interface when the
   class doesn't implement the interface. This is useful for forwarding. */
#define NS_DECL_NON_VIRTUAL_CALIOBSERVER \
  NS_METHOD OnStartBatch(void); \
  NS_METHOD OnEndBatch(void); \
  NS_METHOD OnLoad(calICalendar *aCalendar); \
  NS_METHOD OnAddItem(calIItemBase *aItem); \
  NS_METHOD OnModifyItem(calIItemBase *aNewItem, calIItemBase *aOldItem); \
  NS_METHOD OnDeleteItem(calIItemBase *aDeletedItem); \
  NS_METHOD OnError(calICalendar *aCalendar, nsresult aErrNo, const nsACString & aMessage); \
  NS_METHOD OnPropertyChanged(calICalendar *aCalendar, const nsACString & aName, nsIVariant *aValue, nsIVariant *aOldValue); \
  NS_METHOD OnPropertyDeleting(calICalendar *aCalendar, const nsACString & aName); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_CALIOBSERVER(_to) \
  NS_IMETHOD OnStartBatch(void) override { return _to OnStartBatch(); } \
  NS_IMETHOD OnEndBatch(void) override { return _to OnEndBatch(); } \
  NS_IMETHOD OnLoad(calICalendar *aCalendar) override { return _to OnLoad(aCalendar); } \
  NS_IMETHOD OnAddItem(calIItemBase *aItem) override { return _to OnAddItem(aItem); } \
  NS_IMETHOD OnModifyItem(calIItemBase *aNewItem, calIItemBase *aOldItem) override { return _to OnModifyItem(aNewItem, aOldItem); } \
  NS_IMETHOD OnDeleteItem(calIItemBase *aDeletedItem) override { return _to OnDeleteItem(aDeletedItem); } \
  NS_IMETHOD OnError(calICalendar *aCalendar, nsresult aErrNo, const nsACString & aMessage) override { return _to OnError(aCalendar, aErrNo, aMessage); } \
  NS_IMETHOD OnPropertyChanged(calICalendar *aCalendar, const nsACString & aName, nsIVariant *aValue, nsIVariant *aOldValue) override { return _to OnPropertyChanged(aCalendar, aName, aValue, aOldValue); } \
  NS_IMETHOD OnPropertyDeleting(calICalendar *aCalendar, const nsACString & aName) override { return _to OnPropertyDeleting(aCalendar, aName); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_CALIOBSERVER(_to) \
  NS_IMETHOD OnStartBatch(void) override { return !_to ? NS_ERROR_NULL_POINTER : _to->OnStartBatch(); } \
  NS_IMETHOD OnEndBatch(void) override { return !_to ? NS_ERROR_NULL_POINTER : _to->OnEndBatch(); } \
  NS_IMETHOD OnLoad(calICalendar *aCalendar) override { return !_to ? NS_ERROR_NULL_POINTER : _to->OnLoad(aCalendar); } \
  NS_IMETHOD OnAddItem(calIItemBase *aItem) override { return !_to ? NS_ERROR_NULL_POINTER : _to->OnAddItem(aItem); } \
  NS_IMETHOD OnModifyItem(calIItemBase *aNewItem, calIItemBase *aOldItem) override { return !_to ? NS_ERROR_NULL_POINTER : _to->OnModifyItem(aNewItem, aOldItem); } \
  NS_IMETHOD OnDeleteItem(calIItemBase *aDeletedItem) override { return !_to ? NS_ERROR_NULL_POINTER : _to->OnDeleteItem(aDeletedItem); } \
  NS_IMETHOD OnError(calICalendar *aCalendar, nsresult aErrNo, const nsACString & aMessage) override { return !_to ? NS_ERROR_NULL_POINTER : _to->OnError(aCalendar, aErrNo, aMessage); } \
  NS_IMETHOD OnPropertyChanged(calICalendar *aCalendar, const nsACString & aName, nsIVariant *aValue, nsIVariant *aOldValue) override { return !_to ? NS_ERROR_NULL_POINTER : _to->OnPropertyChanged(aCalendar, aName, aValue, aOldValue); } \
  NS_IMETHOD OnPropertyDeleting(calICalendar *aCalendar, const nsACString & aName) override { return !_to ? NS_ERROR_NULL_POINTER : _to->OnPropertyDeleting(aCalendar, aName); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class _MYCLASS_ : public calIObserver
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_CALIOBSERVER

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS(_MYCLASS_, calIObserver)

_MYCLASS_::_MYCLASS_()
{
  /* member initializers and constructor code */
}

_MYCLASS_::~_MYCLASS_()
{
  /* destructor code */
}

/* void onStartBatch (); */
NS_IMETHODIMP _MYCLASS_::OnStartBatch()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onEndBatch (); */
NS_IMETHODIMP _MYCLASS_::OnEndBatch()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onLoad (in calICalendar aCalendar); */
NS_IMETHODIMP _MYCLASS_::OnLoad(calICalendar *aCalendar)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onAddItem (in calIItemBase aItem); */
NS_IMETHODIMP _MYCLASS_::OnAddItem(calIItemBase *aItem)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onModifyItem (in calIItemBase aNewItem, in calIItemBase aOldItem); */
NS_IMETHODIMP _MYCLASS_::OnModifyItem(calIItemBase *aNewItem, calIItemBase *aOldItem)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onDeleteItem (in calIItemBase aDeletedItem); */
NS_IMETHODIMP _MYCLASS_::OnDeleteItem(calIItemBase *aDeletedItem)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onError (in calICalendar aCalendar, in nsresult aErrNo, in AUTF8String aMessage); */
NS_IMETHODIMP _MYCLASS_::OnError(calICalendar *aCalendar, nsresult aErrNo, const nsACString & aMessage)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onPropertyChanged (in calICalendar aCalendar, in AUTF8String aName, in nsIVariant aValue, in nsIVariant aOldValue); */
NS_IMETHODIMP _MYCLASS_::OnPropertyChanged(calICalendar *aCalendar, const nsACString & aName, nsIVariant *aValue, nsIVariant *aOldValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onPropertyDeleting (in calICalendar aCalendar, in AUTF8String aName); */
NS_IMETHODIMP _MYCLASS_::OnPropertyDeleting(calICalendar *aCalendar, const nsACString & aName)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    calICompositeObserver */
#define CALICOMPOSITEOBSERVER_IID_STR "a3584c92-b8eb-4aa8-a638-e46a2e11d6a9"

#define CALICOMPOSITEOBSERVER_IID \
  {0xa3584c92, 0xb8eb, 0x4aa8, \
    { 0xa6, 0x38, 0xe4, 0x6a, 0x2e, 0x11, 0xd6, 0xa9 }}

class NS_NO_VTABLE calICompositeObserver : public calIObserver {
 public:

  NS_DECLARE_STATIC_IID_ACCESSOR(CALICOMPOSITEOBSERVER_IID)

  /* void onCalendarAdded (in calICalendar aCalendar); */
  NS_IMETHOD OnCalendarAdded(calICalendar *aCalendar) = 0;

  /* void onCalendarRemoved (in calICalendar aCalendar); */
  NS_IMETHOD OnCalendarRemoved(calICalendar *aCalendar) = 0;

  /* void onDefaultCalendarChanged (in calICalendar aNewDefaultCalendar); */
  NS_IMETHOD OnDefaultCalendarChanged(calICalendar *aNewDefaultCalendar) = 0;

};

  NS_DEFINE_STATIC_IID_ACCESSOR(calICompositeObserver, CALICOMPOSITEOBSERVER_IID)

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_CALICOMPOSITEOBSERVER \
  NS_IMETHOD OnCalendarAdded(calICalendar *aCalendar) override; \
  NS_IMETHOD OnCalendarRemoved(calICalendar *aCalendar) override; \
  NS_IMETHOD OnDefaultCalendarChanged(calICalendar *aNewDefaultCalendar) override; 

/* Use this macro when declaring the members of this interface when the
   class doesn't implement the interface. This is useful for forwarding. */
#define NS_DECL_NON_VIRTUAL_CALICOMPOSITEOBSERVER \
  NS_METHOD OnCalendarAdded(calICalendar *aCalendar); \
  NS_METHOD OnCalendarRemoved(calICalendar *aCalendar); \
  NS_METHOD OnDefaultCalendarChanged(calICalendar *aNewDefaultCalendar); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_CALICOMPOSITEOBSERVER(_to) \
  NS_IMETHOD OnCalendarAdded(calICalendar *aCalendar) override { return _to OnCalendarAdded(aCalendar); } \
  NS_IMETHOD OnCalendarRemoved(calICalendar *aCalendar) override { return _to OnCalendarRemoved(aCalendar); } \
  NS_IMETHOD OnDefaultCalendarChanged(calICalendar *aNewDefaultCalendar) override { return _to OnDefaultCalendarChanged(aNewDefaultCalendar); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_CALICOMPOSITEOBSERVER(_to) \
  NS_IMETHOD OnCalendarAdded(calICalendar *aCalendar) override { return !_to ? NS_ERROR_NULL_POINTER : _to->OnCalendarAdded(aCalendar); } \
  NS_IMETHOD OnCalendarRemoved(calICalendar *aCalendar) override { return !_to ? NS_ERROR_NULL_POINTER : _to->OnCalendarRemoved(aCalendar); } \
  NS_IMETHOD OnDefaultCalendarChanged(calICalendar *aNewDefaultCalendar) override { return !_to ? NS_ERROR_NULL_POINTER : _to->OnDefaultCalendarChanged(aNewDefaultCalendar); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class _MYCLASS_ : public calICompositeObserver
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_CALICOMPOSITEOBSERVER

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS(_MYCLASS_, calICompositeObserver)

_MYCLASS_::_MYCLASS_()
{
  /* member initializers and constructor code */
}

_MYCLASS_::~_MYCLASS_()
{
  /* destructor code */
}

/* void onCalendarAdded (in calICalendar aCalendar); */
NS_IMETHODIMP _MYCLASS_::OnCalendarAdded(calICalendar *aCalendar)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onCalendarRemoved (in calICalendar aCalendar); */
NS_IMETHODIMP _MYCLASS_::OnCalendarRemoved(calICalendar *aCalendar)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onDefaultCalendarChanged (in calICalendar aNewDefaultCalendar); */
NS_IMETHODIMP _MYCLASS_::OnDefaultCalendarChanged(calICalendar *aNewDefaultCalendar)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    calIOperationListener */
#define CALIOPERATIONLISTENER_IID_STR "ed3d87d8-2c77-11d9-8f5f-00045ace3b8d"

#define CALIOPERATIONLISTENER_IID \
  {0xed3d87d8, 0x2c77, 0x11d9, \
    { 0x8f, 0x5f, 0x00, 0x04, 0x5a, 0xce, 0x3b, 0x8d }}

class NS_NO_VTABLE calIOperationListener : public nsISupports {
 public:

  NS_DECLARE_STATIC_IID_ACCESSOR(CALIOPERATIONLISTENER_IID)

  /* void onOperationComplete (in calICalendar aCalendar, in nsresult aStatus, in unsigned long aOperationType, in string aId, in nsIVariant aDetail); */
  NS_IMETHOD OnOperationComplete(calICalendar *aCalendar, nsresult aStatus, uint32_t aOperationType, const char * aId, nsIVariant *aDetail) = 0;

  enum {
    ADD = 1U,
    MODIFY = 2U,
    DELETE = 3U,
    GET = 4U
  };

  /* void onGetResult (in calICalendar aCalendar, in nsresult aStatus, in nsIIDRef aItemType, in nsIVariant aDetail, in uint32_t aCount, [array, size_is (aCount), iid_is (aItemType)] in nsQIResult aItems); */
  NS_IMETHOD OnGetResult(calICalendar *aCalendar, nsresult aStatus, const nsIID & aItemType, nsIVariant *aDetail, uint32_t aCount, void **aItems) = 0;

};

  NS_DEFINE_STATIC_IID_ACCESSOR(calIOperationListener, CALIOPERATIONLISTENER_IID)

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_CALIOPERATIONLISTENER \
  NS_IMETHOD OnOperationComplete(calICalendar *aCalendar, nsresult aStatus, uint32_t aOperationType, const char * aId, nsIVariant *aDetail) override; \
  NS_IMETHOD OnGetResult(calICalendar *aCalendar, nsresult aStatus, const nsIID & aItemType, nsIVariant *aDetail, uint32_t aCount, void **aItems) override; 

/* Use this macro when declaring the members of this interface when the
   class doesn't implement the interface. This is useful for forwarding. */
#define NS_DECL_NON_VIRTUAL_CALIOPERATIONLISTENER \
  NS_METHOD OnOperationComplete(calICalendar *aCalendar, nsresult aStatus, uint32_t aOperationType, const char * aId, nsIVariant *aDetail); \
  NS_METHOD OnGetResult(calICalendar *aCalendar, nsresult aStatus, const nsIID & aItemType, nsIVariant *aDetail, uint32_t aCount, void **aItems); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_CALIOPERATIONLISTENER(_to) \
  NS_IMETHOD OnOperationComplete(calICalendar *aCalendar, nsresult aStatus, uint32_t aOperationType, const char * aId, nsIVariant *aDetail) override { return _to OnOperationComplete(aCalendar, aStatus, aOperationType, aId, aDetail); } \
  NS_IMETHOD OnGetResult(calICalendar *aCalendar, nsresult aStatus, const nsIID & aItemType, nsIVariant *aDetail, uint32_t aCount, void **aItems) override { return _to OnGetResult(aCalendar, aStatus, aItemType, aDetail, aCount, aItems); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_CALIOPERATIONLISTENER(_to) \
  NS_IMETHOD OnOperationComplete(calICalendar *aCalendar, nsresult aStatus, uint32_t aOperationType, const char * aId, nsIVariant *aDetail) override { return !_to ? NS_ERROR_NULL_POINTER : _to->OnOperationComplete(aCalendar, aStatus, aOperationType, aId, aDetail); } \
  NS_IMETHOD OnGetResult(calICalendar *aCalendar, nsresult aStatus, const nsIID & aItemType, nsIVariant *aDetail, uint32_t aCount, void **aItems) override { return !_to ? NS_ERROR_NULL_POINTER : _to->OnGetResult(aCalendar, aStatus, aItemType, aDetail, aCount, aItems); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class _MYCLASS_ : public calIOperationListener
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_CALIOPERATIONLISTENER

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS(_MYCLASS_, calIOperationListener)

_MYCLASS_::_MYCLASS_()
{
  /* member initializers and constructor code */
}

_MYCLASS_::~_MYCLASS_()
{
  /* destructor code */
}

/* void onOperationComplete (in calICalendar aCalendar, in nsresult aStatus, in unsigned long aOperationType, in string aId, in nsIVariant aDetail); */
NS_IMETHODIMP _MYCLASS_::OnOperationComplete(calICalendar *aCalendar, nsresult aStatus, uint32_t aOperationType, const char * aId, nsIVariant *aDetail)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onGetResult (in calICalendar aCalendar, in nsresult aStatus, in nsIIDRef aItemType, in nsIVariant aDetail, in uint32_t aCount, [array, size_is (aCount), iid_is (aItemType)] in nsQIResult aItems); */
NS_IMETHODIMP _MYCLASS_::OnGetResult(calICalendar *aCalendar, nsresult aStatus, const nsIID & aItemType, nsIVariant *aDetail, uint32_t aCount, void **aItems)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


#endif /* __gen_calICalendar_h__ */
