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

#ifndef __gen_flockIPhoto_h__
#define __gen_flockIPhoto_h__


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

#ifndef __gen_nsIRDFDataSource_h__
#include "nsIRDFDataSource.h"
#endif

#ifndef __gen_nsIRDFRemoteDataSource_h__
#include "nsIRDFRemoteDataSource.h"
#endif

#ifndef __gen_nsISimpleEnumerator_h__
#include "nsISimpleEnumerator.h"
#endif

#ifndef __gen_nsIDictionary_h__
#include "nsIDictionary.h"
#endif

#ifndef __gen_nsIDOMDocument_h__
#include "nsIDOMDocument.h"
#endif

#ifndef __gen_flockIError_h__
#include "flockIError.h"
#endif

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

class flockIPhoto; /* forward declaration */


/* starting interface:    flockIPhotoPerson */
#define FLOCKIPHOTOPERSON_IID_STR "15706e56-37da-4ae2-98e5-915f5d9ad6b1"

#define FLOCKIPHOTOPERSON_IID \
  {0x15706e56, 0x37da, 0x4ae2, \
    { 0x98, 0xe5, 0x91, 0x5f, 0x5d, 0x9a, 0xd6, 0xb1 }}

class NS_NO_VTABLE flockIPhotoPerson : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(FLOCKIPHOTOPERSON_IID)

  /* void init (in flockIPhotoAPI aService, in AString aID, in AString aUsername, in AString aFullName); */
  NS_IMETHOD Init(flockIPhotoAPI *aService, const nsAString & aID, const nsAString & aUsername, const nsAString & aFullName) = 0;

  /* attribute flockIPhotoAPI service; */
  NS_IMETHOD GetService(flockIPhotoAPI * *aService) = 0;
  NS_IMETHOD SetService(flockIPhotoAPI * aService) = 0;

  /* attribute AString username; */
  NS_IMETHOD GetUsername(nsAString & aUsername) = 0;
  NS_IMETHOD SetUsername(const nsAString & aUsername) = 0;

  /* attribute AString fullname; */
  NS_IMETHOD GetFullname(nsAString & aFullname) = 0;
  NS_IMETHOD SetFullname(const nsAString & aFullname) = 0;

  /* attribute AString id; */
  NS_IMETHOD GetId(nsAString & aId) = 0;
  NS_IMETHOD SetId(const nsAString & aId) = 0;

  /* attribute PRInt64 seq; */
  NS_IMETHOD GetSeq(PRInt64 *aSeq) = 0;
  NS_IMETHOD SetSeq(PRInt64 aSeq) = 0;

  /* attribute PRInt64 lastNewSeq; */
  NS_IMETHOD GetLastNewSeq(PRInt64 *aLastNewSeq) = 0;
  NS_IMETHOD SetLastNewSeq(PRInt64 aLastNewSeq) = 0;

  /* attribute boolean hasNew; */
  NS_IMETHOD GetHasNew(PRBool *aHasNew) = 0;
  NS_IMETHOD SetHasNew(PRBool aHasNew) = 0;

  /* attribute AString commentsFeedUrl; */
  NS_IMETHOD GetCommentsFeedUrl(nsAString & aCommentsFeedUrl) = 0;
  NS_IMETHOD SetCommentsFeedUrl(const nsAString & aCommentsFeedUrl) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_FLOCKIPHOTOPERSON \
  NS_IMETHOD Init(flockIPhotoAPI *aService, const nsAString & aID, const nsAString & aUsername, const nsAString & aFullName); \
  NS_IMETHOD GetService(flockIPhotoAPI * *aService); \
  NS_IMETHOD SetService(flockIPhotoAPI * aService); \
  NS_IMETHOD GetUsername(nsAString & aUsername); \
  NS_IMETHOD SetUsername(const nsAString & aUsername); \
  NS_IMETHOD GetFullname(nsAString & aFullname); \
  NS_IMETHOD SetFullname(const nsAString & aFullname); \
  NS_IMETHOD GetId(nsAString & aId); \
  NS_IMETHOD SetId(const nsAString & aId); \
  NS_IMETHOD GetSeq(PRInt64 *aSeq); \
  NS_IMETHOD SetSeq(PRInt64 aSeq); \
  NS_IMETHOD GetLastNewSeq(PRInt64 *aLastNewSeq); \
  NS_IMETHOD SetLastNewSeq(PRInt64 aLastNewSeq); \
  NS_IMETHOD GetHasNew(PRBool *aHasNew); \
  NS_IMETHOD SetHasNew(PRBool aHasNew); \
  NS_IMETHOD GetCommentsFeedUrl(nsAString & aCommentsFeedUrl); \
  NS_IMETHOD SetCommentsFeedUrl(const nsAString & aCommentsFeedUrl); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_FLOCKIPHOTOPERSON(_to) \
  NS_IMETHOD Init(flockIPhotoAPI *aService, const nsAString & aID, const nsAString & aUsername, const nsAString & aFullName) { return _to Init(aService, aID, aUsername, aFullName); } \
  NS_IMETHOD GetService(flockIPhotoAPI * *aService) { return _to GetService(aService); } \
  NS_IMETHOD SetService(flockIPhotoAPI * aService) { return _to SetService(aService); } \
  NS_IMETHOD GetUsername(nsAString & aUsername) { return _to GetUsername(aUsername); } \
  NS_IMETHOD SetUsername(const nsAString & aUsername) { return _to SetUsername(aUsername); } \
  NS_IMETHOD GetFullname(nsAString & aFullname) { return _to GetFullname(aFullname); } \
  NS_IMETHOD SetFullname(const nsAString & aFullname) { return _to SetFullname(aFullname); } \
  NS_IMETHOD GetId(nsAString & aId) { return _to GetId(aId); } \
  NS_IMETHOD SetId(const nsAString & aId) { return _to SetId(aId); } \
  NS_IMETHOD GetSeq(PRInt64 *aSeq) { return _to GetSeq(aSeq); } \
  NS_IMETHOD SetSeq(PRInt64 aSeq) { return _to SetSeq(aSeq); } \
  NS_IMETHOD GetLastNewSeq(PRInt64 *aLastNewSeq) { return _to GetLastNewSeq(aLastNewSeq); } \
  NS_IMETHOD SetLastNewSeq(PRInt64 aLastNewSeq) { return _to SetLastNewSeq(aLastNewSeq); } \
  NS_IMETHOD GetHasNew(PRBool *aHasNew) { return _to GetHasNew(aHasNew); } \
  NS_IMETHOD SetHasNew(PRBool aHasNew) { return _to SetHasNew(aHasNew); } \
  NS_IMETHOD GetCommentsFeedUrl(nsAString & aCommentsFeedUrl) { return _to GetCommentsFeedUrl(aCommentsFeedUrl); } \
  NS_IMETHOD SetCommentsFeedUrl(const nsAString & aCommentsFeedUrl) { return _to SetCommentsFeedUrl(aCommentsFeedUrl); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_FLOCKIPHOTOPERSON(_to) \
  NS_IMETHOD Init(flockIPhotoAPI *aService, const nsAString & aID, const nsAString & aUsername, const nsAString & aFullName) { return !_to ? NS_ERROR_NULL_POINTER : _to->Init(aService, aID, aUsername, aFullName); } \
  NS_IMETHOD GetService(flockIPhotoAPI * *aService) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetService(aService); } \
  NS_IMETHOD SetService(flockIPhotoAPI * aService) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetService(aService); } \
  NS_IMETHOD GetUsername(nsAString & aUsername) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetUsername(aUsername); } \
  NS_IMETHOD SetUsername(const nsAString & aUsername) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetUsername(aUsername); } \
  NS_IMETHOD GetFullname(nsAString & aFullname) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetFullname(aFullname); } \
  NS_IMETHOD SetFullname(const nsAString & aFullname) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetFullname(aFullname); } \
  NS_IMETHOD GetId(nsAString & aId) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetId(aId); } \
  NS_IMETHOD SetId(const nsAString & aId) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetId(aId); } \
  NS_IMETHOD GetSeq(PRInt64 *aSeq) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetSeq(aSeq); } \
  NS_IMETHOD SetSeq(PRInt64 aSeq) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetSeq(aSeq); } \
  NS_IMETHOD GetLastNewSeq(PRInt64 *aLastNewSeq) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetLastNewSeq(aLastNewSeq); } \
  NS_IMETHOD SetLastNewSeq(PRInt64 aLastNewSeq) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetLastNewSeq(aLastNewSeq); } \
  NS_IMETHOD GetHasNew(PRBool *aHasNew) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetHasNew(aHasNew); } \
  NS_IMETHOD SetHasNew(PRBool aHasNew) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetHasNew(aHasNew); } \
  NS_IMETHOD GetCommentsFeedUrl(nsAString & aCommentsFeedUrl) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetCommentsFeedUrl(aCommentsFeedUrl); } \
  NS_IMETHOD SetCommentsFeedUrl(const nsAString & aCommentsFeedUrl) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetCommentsFeedUrl(aCommentsFeedUrl); } 

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

/* Header file */
class _MYCLASS_ : public flockIPhotoPerson
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_FLOCKIPHOTOPERSON

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(_MYCLASS_, flockIPhotoPerson)

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

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

/* void init (in flockIPhotoAPI aService, in AString aID, in AString aUsername, in AString aFullName); */
NS_IMETHODIMP _MYCLASS_::Init(flockIPhotoAPI *aService, const nsAString & aID, const nsAString & aUsername, const nsAString & aFullName)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute flockIPhotoAPI service; */
NS_IMETHODIMP _MYCLASS_::GetService(flockIPhotoAPI * *aService)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetService(flockIPhotoAPI * aService)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AString username; */
NS_IMETHODIMP _MYCLASS_::GetUsername(nsAString & aUsername)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetUsername(const nsAString & aUsername)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AString fullname; */
NS_IMETHODIMP _MYCLASS_::GetFullname(nsAString & aFullname)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetFullname(const nsAString & aFullname)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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

/* attribute PRInt64 seq; */
NS_IMETHODIMP _MYCLASS_::GetSeq(PRInt64 *aSeq)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetSeq(PRInt64 aSeq)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute PRInt64 lastNewSeq; */
NS_IMETHODIMP _MYCLASS_::GetLastNewSeq(PRInt64 *aLastNewSeq)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetLastNewSeq(PRInt64 aLastNewSeq)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute boolean hasNew; */
NS_IMETHODIMP _MYCLASS_::GetHasNew(PRBool *aHasNew)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetHasNew(PRBool aHasNew)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AString commentsFeedUrl; */
NS_IMETHODIMP _MYCLASS_::GetCommentsFeedUrl(nsAString & aCommentsFeedUrl)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetCommentsFeedUrl(const nsAString & aCommentsFeedUrl)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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


/* starting interface:    flockIPhotoAlbum */
#define FLOCKIPHOTOALBUM_IID_STR "cfcffc53-7c57-418c-ae84-f66ddd7b3f77"

#define FLOCKIPHOTOALBUM_IID \
  {0xcfcffc53, 0x7c57, 0x418c, \
    { 0xae, 0x84, 0xf6, 0x6d, 0xdd, 0x7b, 0x3f, 0x77 }}

class NS_NO_VTABLE flockIPhotoAlbum : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(FLOCKIPHOTOALBUM_IID)

  /* attribute AString id; */
  NS_IMETHOD GetId(nsAString & aId) = 0;
  NS_IMETHOD SetId(const nsAString & aId) = 0;

  /* attribute AString title; */
  NS_IMETHOD GetTitle(nsAString & aTitle) = 0;
  NS_IMETHOD SetTitle(const nsAString & aTitle) = 0;

  /* attribute AString url; */
  NS_IMETHOD GetUrl(nsAString & aUrl) = 0;
  NS_IMETHOD SetUrl(const nsAString & aUrl) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_FLOCKIPHOTOALBUM \
  NS_IMETHOD GetId(nsAString & aId); \
  NS_IMETHOD SetId(const nsAString & aId); \
  NS_IMETHOD GetTitle(nsAString & aTitle); \
  NS_IMETHOD SetTitle(const nsAString & aTitle); \
  NS_IMETHOD GetUrl(nsAString & aUrl); \
  NS_IMETHOD SetUrl(const nsAString & aUrl); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_FLOCKIPHOTOALBUM(_to) \
  NS_IMETHOD GetId(nsAString & aId) { return _to GetId(aId); } \
  NS_IMETHOD SetId(const nsAString & aId) { return _to SetId(aId); } \
  NS_IMETHOD GetTitle(nsAString & aTitle) { return _to GetTitle(aTitle); } \
  NS_IMETHOD SetTitle(const nsAString & aTitle) { return _to SetTitle(aTitle); } \
  NS_IMETHOD GetUrl(nsAString & aUrl) { return _to GetUrl(aUrl); } \
  NS_IMETHOD SetUrl(const nsAString & aUrl) { return _to SetUrl(aUrl); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_FLOCKIPHOTOALBUM(_to) \
  NS_IMETHOD GetId(nsAString & aId) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetId(aId); } \
  NS_IMETHOD SetId(const nsAString & aId) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetId(aId); } \
  NS_IMETHOD GetTitle(nsAString & aTitle) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetTitle(aTitle); } \
  NS_IMETHOD SetTitle(const nsAString & aTitle) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetTitle(aTitle); } \
  NS_IMETHOD GetUrl(nsAString & aUrl) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetUrl(aUrl); } \
  NS_IMETHOD SetUrl(const nsAString & aUrl) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetUrl(aUrl); } 

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

/* Header file */
class _MYCLASS_ : public flockIPhotoAlbum
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_FLOCKIPHOTOALBUM

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(_MYCLASS_, flockIPhotoAlbum)

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

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

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

/* attribute AString title; */
NS_IMETHODIMP _MYCLASS_::GetTitle(nsAString & aTitle)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetTitle(const nsAString & aTitle)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AString url; */
NS_IMETHODIMP _MYCLASS_::GetUrl(nsAString & aUrl)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetUrl(const nsAString & aUrl)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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


/* starting interface:    flockIPhotoAccount */
#define FLOCKIPHOTOACCOUNT_IID_STR "9c86ff00-c9b4-11da-a94d-0800200c9a66"

#define FLOCKIPHOTOACCOUNT_IID \
  {0x9c86ff00, 0xc9b4, 0x11da, \
    { 0xa9, 0x4d, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66 }}

class NS_NO_VTABLE flockIPhotoAccount : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(FLOCKIPHOTOACCOUNT_IID)

  /* attribute AString username; */
  NS_IMETHOD GetUsername(nsAString & aUsername) = 0;
  NS_IMETHOD SetUsername(const nsAString & aUsername) = 0;

  /* attribute AString maxSpace; */
  NS_IMETHOD GetMaxSpace(nsAString & aMaxSpace) = 0;
  NS_IMETHOD SetMaxSpace(const nsAString & aMaxSpace) = 0;

  /* attribute AString usedSpace; */
  NS_IMETHOD GetUsedSpace(nsAString & aUsedSpace) = 0;
  NS_IMETHOD SetUsedSpace(const nsAString & aUsedSpace) = 0;

  /* attribute AString maxFileSize; */
  NS_IMETHOD GetMaxFileSize(nsAString & aMaxFileSize) = 0;
  NS_IMETHOD SetMaxFileSize(const nsAString & aMaxFileSize) = 0;

  /* attribute AString usageUnits; */
  NS_IMETHOD GetUsageUnits(nsAString & aUsageUnits) = 0;
  NS_IMETHOD SetUsageUnits(const nsAString & aUsageUnits) = 0;

  /* attribute boolean isPremium; */
  NS_IMETHOD GetIsPremium(PRBool *aIsPremium) = 0;
  NS_IMETHOD SetIsPremium(PRBool aIsPremium) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_FLOCKIPHOTOACCOUNT \
  NS_IMETHOD GetUsername(nsAString & aUsername); \
  NS_IMETHOD SetUsername(const nsAString & aUsername); \
  NS_IMETHOD GetMaxSpace(nsAString & aMaxSpace); \
  NS_IMETHOD SetMaxSpace(const nsAString & aMaxSpace); \
  NS_IMETHOD GetUsedSpace(nsAString & aUsedSpace); \
  NS_IMETHOD SetUsedSpace(const nsAString & aUsedSpace); \
  NS_IMETHOD GetMaxFileSize(nsAString & aMaxFileSize); \
  NS_IMETHOD SetMaxFileSize(const nsAString & aMaxFileSize); \
  NS_IMETHOD GetUsageUnits(nsAString & aUsageUnits); \
  NS_IMETHOD SetUsageUnits(const nsAString & aUsageUnits); \
  NS_IMETHOD GetIsPremium(PRBool *aIsPremium); \
  NS_IMETHOD SetIsPremium(PRBool aIsPremium); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_FLOCKIPHOTOACCOUNT(_to) \
  NS_IMETHOD GetUsername(nsAString & aUsername) { return _to GetUsername(aUsername); } \
  NS_IMETHOD SetUsername(const nsAString & aUsername) { return _to SetUsername(aUsername); } \
  NS_IMETHOD GetMaxSpace(nsAString & aMaxSpace) { return _to GetMaxSpace(aMaxSpace); } \
  NS_IMETHOD SetMaxSpace(const nsAString & aMaxSpace) { return _to SetMaxSpace(aMaxSpace); } \
  NS_IMETHOD GetUsedSpace(nsAString & aUsedSpace) { return _to GetUsedSpace(aUsedSpace); } \
  NS_IMETHOD SetUsedSpace(const nsAString & aUsedSpace) { return _to SetUsedSpace(aUsedSpace); } \
  NS_IMETHOD GetMaxFileSize(nsAString & aMaxFileSize) { return _to GetMaxFileSize(aMaxFileSize); } \
  NS_IMETHOD SetMaxFileSize(const nsAString & aMaxFileSize) { return _to SetMaxFileSize(aMaxFileSize); } \
  NS_IMETHOD GetUsageUnits(nsAString & aUsageUnits) { return _to GetUsageUnits(aUsageUnits); } \
  NS_IMETHOD SetUsageUnits(const nsAString & aUsageUnits) { return _to SetUsageUnits(aUsageUnits); } \
  NS_IMETHOD GetIsPremium(PRBool *aIsPremium) { return _to GetIsPremium(aIsPremium); } \
  NS_IMETHOD SetIsPremium(PRBool aIsPremium) { return _to SetIsPremium(aIsPremium); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_FLOCKIPHOTOACCOUNT(_to) \
  NS_IMETHOD GetUsername(nsAString & aUsername) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetUsername(aUsername); } \
  NS_IMETHOD SetUsername(const nsAString & aUsername) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetUsername(aUsername); } \
  NS_IMETHOD GetMaxSpace(nsAString & aMaxSpace) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetMaxSpace(aMaxSpace); } \
  NS_IMETHOD SetMaxSpace(const nsAString & aMaxSpace) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetMaxSpace(aMaxSpace); } \
  NS_IMETHOD GetUsedSpace(nsAString & aUsedSpace) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetUsedSpace(aUsedSpace); } \
  NS_IMETHOD SetUsedSpace(const nsAString & aUsedSpace) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetUsedSpace(aUsedSpace); } \
  NS_IMETHOD GetMaxFileSize(nsAString & aMaxFileSize) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetMaxFileSize(aMaxFileSize); } \
  NS_IMETHOD SetMaxFileSize(const nsAString & aMaxFileSize) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetMaxFileSize(aMaxFileSize); } \
  NS_IMETHOD GetUsageUnits(nsAString & aUsageUnits) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetUsageUnits(aUsageUnits); } \
  NS_IMETHOD SetUsageUnits(const nsAString & aUsageUnits) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetUsageUnits(aUsageUnits); } \
  NS_IMETHOD GetIsPremium(PRBool *aIsPremium) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetIsPremium(aIsPremium); } \
  NS_IMETHOD SetIsPremium(PRBool aIsPremium) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetIsPremium(aIsPremium); } 

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

/* Header file */
class _MYCLASS_ : public flockIPhotoAccount
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_FLOCKIPHOTOACCOUNT

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(_MYCLASS_, flockIPhotoAccount)

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

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

/* attribute AString username; */
NS_IMETHODIMP _MYCLASS_::GetUsername(nsAString & aUsername)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetUsername(const nsAString & aUsername)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AString maxSpace; */
NS_IMETHODIMP _MYCLASS_::GetMaxSpace(nsAString & aMaxSpace)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetMaxSpace(const nsAString & aMaxSpace)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AString usedSpace; */
NS_IMETHODIMP _MYCLASS_::GetUsedSpace(nsAString & aUsedSpace)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetUsedSpace(const nsAString & aUsedSpace)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AString maxFileSize; */
NS_IMETHODIMP _MYCLASS_::GetMaxFileSize(nsAString & aMaxFileSize)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetMaxFileSize(const nsAString & aMaxFileSize)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AString usageUnits; */
NS_IMETHODIMP _MYCLASS_::GetUsageUnits(nsAString & aUsageUnits)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetUsageUnits(const nsAString & aUsageUnits)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute boolean isPremium; */
NS_IMETHODIMP _MYCLASS_::GetIsPremium(PRBool *aIsPremium)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetIsPremium(PRBool aIsPremium)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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


/* starting interface:    flockIPhotoUpload */
#define FLOCKIPHOTOUPLOAD_IID_STR "5b2aeb54-0955-46fc-b3d7-19b9593d099a"

#define FLOCKIPHOTOUPLOAD_IID \
  {0x5b2aeb54, 0x0955, 0x46fc, \
    { 0xb3, 0xd7, 0x19, 0xb9, 0x59, 0x3d, 0x09, 0x9a }}

class NS_NO_VTABLE flockIPhotoUpload : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(FLOCKIPHOTOUPLOAD_IID)

  /* attribute string id; */
  NS_IMETHOD GetId(char * *aId) = 0;
  NS_IMETHOD SetId(const char * aId) = 0;

  /* attribute string fileName; */
  NS_IMETHOD GetFileName(char * *aFileName) = 0;
  NS_IMETHOD SetFileName(const char * aFileName) = 0;

  /* attribute string originalFileSpec; */
  NS_IMETHOD GetOriginalFileSpec(char * *aOriginalFileSpec) = 0;
  NS_IMETHOD SetOriginalFileSpec(const char * aOriginalFileSpec) = 0;

  /* attribute string originalFilePath; */
  NS_IMETHOD GetOriginalFilePath(char * *aOriginalFilePath) = 0;
  NS_IMETHOD SetOriginalFilePath(const char * aOriginalFilePath) = 0;

  /* attribute string workingFilePath; */
  NS_IMETHOD GetWorkingFilePath(char * *aWorkingFilePath) = 0;
  NS_IMETHOD SetWorkingFilePath(const char * aWorkingFilePath) = 0;

  /* attribute string workingFileSpec; */
  NS_IMETHOD GetWorkingFileSpec(char * *aWorkingFileSpec) = 0;
  NS_IMETHOD SetWorkingFileSpec(const char * aWorkingFileSpec) = 0;

  /* attribute string previewFileSpec; */
  NS_IMETHOD GetPreviewFileSpec(char * *aPreviewFileSpec) = 0;
  NS_IMETHOD SetPreviewFileSpec(const char * aPreviewFileSpec) = 0;

  /* attribute string previewFilePath; */
  NS_IMETHOD GetPreviewFilePath(char * *aPreviewFilePath) = 0;
  NS_IMETHOD SetPreviewFilePath(const char * aPreviewFilePath) = 0;

  /* attribute string thumbFileSpec; */
  NS_IMETHOD GetThumbFileSpec(char * *aThumbFileSpec) = 0;
  NS_IMETHOD SetThumbFileSpec(const char * aThumbFileSpec) = 0;

  /* attribute string thumbFilePath; */
  NS_IMETHOD GetThumbFilePath(char * *aThumbFilePath) = 0;
  NS_IMETHOD SetThumbFilePath(const char * aThumbFilePath) = 0;

  /* attribute AString title; */
  NS_IMETHOD GetTitle(nsAString & aTitle) = 0;
  NS_IMETHOD SetTitle(const nsAString & aTitle) = 0;

  /* attribute AString tags; */
  NS_IMETHOD GetTags(nsAString & aTags) = 0;
  NS_IMETHOD SetTags(const nsAString & aTags) = 0;

  /* attribute AString description; */
  NS_IMETHOD GetDescription(nsAString & aDescription) = 0;
  NS_IMETHOD SetDescription(const nsAString & aDescription) = 0;

  /* attribute string is_public; */
  NS_IMETHOD GetIs_public(char * *aIs_public) = 0;
  NS_IMETHOD SetIs_public(const char * aIs_public) = 0;

  /* attribute string is_friend; */
  NS_IMETHOD GetIs_friend(char * *aIs_friend) = 0;
  NS_IMETHOD SetIs_friend(const char * aIs_friend) = 0;

  /* attribute string is_family; */
  NS_IMETHOD GetIs_family(char * *aIs_family) = 0;
  NS_IMETHOD SetIs_family(const char * aIs_family) = 0;

  /* attribute AString album; */
  NS_IMETHOD GetAlbum(nsAString & aAlbum) = 0;
  NS_IMETHOD SetAlbum(const nsAString & aAlbum) = 0;

  /* attribute string state; */
  NS_IMETHOD GetState(char * *aState) = 0;
  NS_IMETHOD SetState(const char * aState) = 0;

  /* attribute string rotation; */
  NS_IMETHOD GetRotation(char * *aRotation) = 0;
  NS_IMETHOD SetRotation(const char * aRotation) = 0;

  /* attribute string crop; */
  NS_IMETHOD GetCrop(char * *aCrop) = 0;
  NS_IMETHOD SetCrop(const char * aCrop) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_FLOCKIPHOTOUPLOAD \
  NS_IMETHOD GetId(char * *aId); \
  NS_IMETHOD SetId(const char * aId); \
  NS_IMETHOD GetFileName(char * *aFileName); \
  NS_IMETHOD SetFileName(const char * aFileName); \
  NS_IMETHOD GetOriginalFileSpec(char * *aOriginalFileSpec); \
  NS_IMETHOD SetOriginalFileSpec(const char * aOriginalFileSpec); \
  NS_IMETHOD GetOriginalFilePath(char * *aOriginalFilePath); \
  NS_IMETHOD SetOriginalFilePath(const char * aOriginalFilePath); \
  NS_IMETHOD GetWorkingFilePath(char * *aWorkingFilePath); \
  NS_IMETHOD SetWorkingFilePath(const char * aWorkingFilePath); \
  NS_IMETHOD GetWorkingFileSpec(char * *aWorkingFileSpec); \
  NS_IMETHOD SetWorkingFileSpec(const char * aWorkingFileSpec); \
  NS_IMETHOD GetPreviewFileSpec(char * *aPreviewFileSpec); \
  NS_IMETHOD SetPreviewFileSpec(const char * aPreviewFileSpec); \
  NS_IMETHOD GetPreviewFilePath(char * *aPreviewFilePath); \
  NS_IMETHOD SetPreviewFilePath(const char * aPreviewFilePath); \
  NS_IMETHOD GetThumbFileSpec(char * *aThumbFileSpec); \
  NS_IMETHOD SetThumbFileSpec(const char * aThumbFileSpec); \
  NS_IMETHOD GetThumbFilePath(char * *aThumbFilePath); \
  NS_IMETHOD SetThumbFilePath(const char * aThumbFilePath); \
  NS_IMETHOD GetTitle(nsAString & aTitle); \
  NS_IMETHOD SetTitle(const nsAString & aTitle); \
  NS_IMETHOD GetTags(nsAString & aTags); \
  NS_IMETHOD SetTags(const nsAString & aTags); \
  NS_IMETHOD GetDescription(nsAString & aDescription); \
  NS_IMETHOD SetDescription(const nsAString & aDescription); \
  NS_IMETHOD GetIs_public(char * *aIs_public); \
  NS_IMETHOD SetIs_public(const char * aIs_public); \
  NS_IMETHOD GetIs_friend(char * *aIs_friend); \
  NS_IMETHOD SetIs_friend(const char * aIs_friend); \
  NS_IMETHOD GetIs_family(char * *aIs_family); \
  NS_IMETHOD SetIs_family(const char * aIs_family); \
  NS_IMETHOD GetAlbum(nsAString & aAlbum); \
  NS_IMETHOD SetAlbum(const nsAString & aAlbum); \
  NS_IMETHOD GetState(char * *aState); \
  NS_IMETHOD SetState(const char * aState); \
  NS_IMETHOD GetRotation(char * *aRotation); \
  NS_IMETHOD SetRotation(const char * aRotation); \
  NS_IMETHOD GetCrop(char * *aCrop); \
  NS_IMETHOD SetCrop(const char * aCrop); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_FLOCKIPHOTOUPLOAD(_to) \
  NS_IMETHOD GetId(char * *aId) { return _to GetId(aId); } \
  NS_IMETHOD SetId(const char * aId) { return _to SetId(aId); } \
  NS_IMETHOD GetFileName(char * *aFileName) { return _to GetFileName(aFileName); } \
  NS_IMETHOD SetFileName(const char * aFileName) { return _to SetFileName(aFileName); } \
  NS_IMETHOD GetOriginalFileSpec(char * *aOriginalFileSpec) { return _to GetOriginalFileSpec(aOriginalFileSpec); } \
  NS_IMETHOD SetOriginalFileSpec(const char * aOriginalFileSpec) { return _to SetOriginalFileSpec(aOriginalFileSpec); } \
  NS_IMETHOD GetOriginalFilePath(char * *aOriginalFilePath) { return _to GetOriginalFilePath(aOriginalFilePath); } \
  NS_IMETHOD SetOriginalFilePath(const char * aOriginalFilePath) { return _to SetOriginalFilePath(aOriginalFilePath); } \
  NS_IMETHOD GetWorkingFilePath(char * *aWorkingFilePath) { return _to GetWorkingFilePath(aWorkingFilePath); } \
  NS_IMETHOD SetWorkingFilePath(const char * aWorkingFilePath) { return _to SetWorkingFilePath(aWorkingFilePath); } \
  NS_IMETHOD GetWorkingFileSpec(char * *aWorkingFileSpec) { return _to GetWorkingFileSpec(aWorkingFileSpec); } \
  NS_IMETHOD SetWorkingFileSpec(const char * aWorkingFileSpec) { return _to SetWorkingFileSpec(aWorkingFileSpec); } \
  NS_IMETHOD GetPreviewFileSpec(char * *aPreviewFileSpec) { return _to GetPreviewFileSpec(aPreviewFileSpec); } \
  NS_IMETHOD SetPreviewFileSpec(const char * aPreviewFileSpec) { return _to SetPreviewFileSpec(aPreviewFileSpec); } \
  NS_IMETHOD GetPreviewFilePath(char * *aPreviewFilePath) { return _to GetPreviewFilePath(aPreviewFilePath); } \
  NS_IMETHOD SetPreviewFilePath(const char * aPreviewFilePath) { return _to SetPreviewFilePath(aPreviewFilePath); } \
  NS_IMETHOD GetThumbFileSpec(char * *aThumbFileSpec) { return _to GetThumbFileSpec(aThumbFileSpec); } \
  NS_IMETHOD SetThumbFileSpec(const char * aThumbFileSpec) { return _to SetThumbFileSpec(aThumbFileSpec); } \
  NS_IMETHOD GetThumbFilePath(char * *aThumbFilePath) { return _to GetThumbFilePath(aThumbFilePath); } \
  NS_IMETHOD SetThumbFilePath(const char * aThumbFilePath) { return _to SetThumbFilePath(aThumbFilePath); } \
  NS_IMETHOD GetTitle(nsAString & aTitle) { return _to GetTitle(aTitle); } \
  NS_IMETHOD SetTitle(const nsAString & aTitle) { return _to SetTitle(aTitle); } \
  NS_IMETHOD GetTags(nsAString & aTags) { return _to GetTags(aTags); } \
  NS_IMETHOD SetTags(const nsAString & aTags) { return _to SetTags(aTags); } \
  NS_IMETHOD GetDescription(nsAString & aDescription) { return _to GetDescription(aDescription); } \
  NS_IMETHOD SetDescription(const nsAString & aDescription) { return _to SetDescription(aDescription); } \
  NS_IMETHOD GetIs_public(char * *aIs_public) { return _to GetIs_public(aIs_public); } \
  NS_IMETHOD SetIs_public(const char * aIs_public) { return _to SetIs_public(aIs_public); } \
  NS_IMETHOD GetIs_friend(char * *aIs_friend) { return _to GetIs_friend(aIs_friend); } \
  NS_IMETHOD SetIs_friend(const char * aIs_friend) { return _to SetIs_friend(aIs_friend); } \
  NS_IMETHOD GetIs_family(char * *aIs_family) { return _to GetIs_family(aIs_family); } \
  NS_IMETHOD SetIs_family(const char * aIs_family) { return _to SetIs_family(aIs_family); } \
  NS_IMETHOD GetAlbum(nsAString & aAlbum) { return _to GetAlbum(aAlbum); } \
  NS_IMETHOD SetAlbum(const nsAString & aAlbum) { return _to SetAlbum(aAlbum); } \
  NS_IMETHOD GetState(char * *aState) { return _to GetState(aState); } \
  NS_IMETHOD SetState(const char * aState) { return _to SetState(aState); } \
  NS_IMETHOD GetRotation(char * *aRotation) { return _to GetRotation(aRotation); } \
  NS_IMETHOD SetRotation(const char * aRotation) { return _to SetRotation(aRotation); } \
  NS_IMETHOD GetCrop(char * *aCrop) { return _to GetCrop(aCrop); } \
  NS_IMETHOD SetCrop(const char * aCrop) { return _to SetCrop(aCrop); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_FLOCKIPHOTOUPLOAD(_to) \
  NS_IMETHOD GetId(char * *aId) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetId(aId); } \
  NS_IMETHOD SetId(const char * aId) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetId(aId); } \
  NS_IMETHOD GetFileName(char * *aFileName) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetFileName(aFileName); } \
  NS_IMETHOD SetFileName(const char * aFileName) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetFileName(aFileName); } \
  NS_IMETHOD GetOriginalFileSpec(char * *aOriginalFileSpec) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetOriginalFileSpec(aOriginalFileSpec); } \
  NS_IMETHOD SetOriginalFileSpec(const char * aOriginalFileSpec) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetOriginalFileSpec(aOriginalFileSpec); } \
  NS_IMETHOD GetOriginalFilePath(char * *aOriginalFilePath) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetOriginalFilePath(aOriginalFilePath); } \
  NS_IMETHOD SetOriginalFilePath(const char * aOriginalFilePath) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetOriginalFilePath(aOriginalFilePath); } \
  NS_IMETHOD GetWorkingFilePath(char * *aWorkingFilePath) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetWorkingFilePath(aWorkingFilePath); } \
  NS_IMETHOD SetWorkingFilePath(const char * aWorkingFilePath) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetWorkingFilePath(aWorkingFilePath); } \
  NS_IMETHOD GetWorkingFileSpec(char * *aWorkingFileSpec) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetWorkingFileSpec(aWorkingFileSpec); } \
  NS_IMETHOD SetWorkingFileSpec(const char * aWorkingFileSpec) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetWorkingFileSpec(aWorkingFileSpec); } \
  NS_IMETHOD GetPreviewFileSpec(char * *aPreviewFileSpec) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPreviewFileSpec(aPreviewFileSpec); } \
  NS_IMETHOD SetPreviewFileSpec(const char * aPreviewFileSpec) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetPreviewFileSpec(aPreviewFileSpec); } \
  NS_IMETHOD GetPreviewFilePath(char * *aPreviewFilePath) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPreviewFilePath(aPreviewFilePath); } \
  NS_IMETHOD SetPreviewFilePath(const char * aPreviewFilePath) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetPreviewFilePath(aPreviewFilePath); } \
  NS_IMETHOD GetThumbFileSpec(char * *aThumbFileSpec) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetThumbFileSpec(aThumbFileSpec); } \
  NS_IMETHOD SetThumbFileSpec(const char * aThumbFileSpec) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetThumbFileSpec(aThumbFileSpec); } \
  NS_IMETHOD GetThumbFilePath(char * *aThumbFilePath) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetThumbFilePath(aThumbFilePath); } \
  NS_IMETHOD SetThumbFilePath(const char * aThumbFilePath) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetThumbFilePath(aThumbFilePath); } \
  NS_IMETHOD GetTitle(nsAString & aTitle) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetTitle(aTitle); } \
  NS_IMETHOD SetTitle(const nsAString & aTitle) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetTitle(aTitle); } \
  NS_IMETHOD GetTags(nsAString & aTags) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetTags(aTags); } \
  NS_IMETHOD SetTags(const nsAString & aTags) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetTags(aTags); } \
  NS_IMETHOD GetDescription(nsAString & aDescription) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetDescription(aDescription); } \
  NS_IMETHOD SetDescription(const nsAString & aDescription) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetDescription(aDescription); } \
  NS_IMETHOD GetIs_public(char * *aIs_public) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetIs_public(aIs_public); } \
  NS_IMETHOD SetIs_public(const char * aIs_public) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetIs_public(aIs_public); } \
  NS_IMETHOD GetIs_friend(char * *aIs_friend) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetIs_friend(aIs_friend); } \
  NS_IMETHOD SetIs_friend(const char * aIs_friend) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetIs_friend(aIs_friend); } \
  NS_IMETHOD GetIs_family(char * *aIs_family) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetIs_family(aIs_family); } \
  NS_IMETHOD SetIs_family(const char * aIs_family) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetIs_family(aIs_family); } \
  NS_IMETHOD GetAlbum(nsAString & aAlbum) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAlbum(aAlbum); } \
  NS_IMETHOD SetAlbum(const nsAString & aAlbum) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAlbum(aAlbum); } \
  NS_IMETHOD GetState(char * *aState) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetState(aState); } \
  NS_IMETHOD SetState(const char * aState) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetState(aState); } \
  NS_IMETHOD GetRotation(char * *aRotation) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetRotation(aRotation); } \
  NS_IMETHOD SetRotation(const char * aRotation) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetRotation(aRotation); } \
  NS_IMETHOD GetCrop(char * *aCrop) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetCrop(aCrop); } \
  NS_IMETHOD SetCrop(const char * aCrop) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetCrop(aCrop); } 

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

/* Header file */
class _MYCLASS_ : public flockIPhotoUpload
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_FLOCKIPHOTOUPLOAD

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(_MYCLASS_, flockIPhotoUpload)

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

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

/* attribute string id; */
NS_IMETHODIMP _MYCLASS_::GetId(char * *aId)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetId(const char * aId)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string fileName; */
NS_IMETHODIMP _MYCLASS_::GetFileName(char * *aFileName)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetFileName(const char * aFileName)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string originalFileSpec; */
NS_IMETHODIMP _MYCLASS_::GetOriginalFileSpec(char * *aOriginalFileSpec)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetOriginalFileSpec(const char * aOriginalFileSpec)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string originalFilePath; */
NS_IMETHODIMP _MYCLASS_::GetOriginalFilePath(char * *aOriginalFilePath)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetOriginalFilePath(const char * aOriginalFilePath)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string workingFilePath; */
NS_IMETHODIMP _MYCLASS_::GetWorkingFilePath(char * *aWorkingFilePath)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetWorkingFilePath(const char * aWorkingFilePath)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string workingFileSpec; */
NS_IMETHODIMP _MYCLASS_::GetWorkingFileSpec(char * *aWorkingFileSpec)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetWorkingFileSpec(const char * aWorkingFileSpec)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string previewFileSpec; */
NS_IMETHODIMP _MYCLASS_::GetPreviewFileSpec(char * *aPreviewFileSpec)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetPreviewFileSpec(const char * aPreviewFileSpec)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string previewFilePath; */
NS_IMETHODIMP _MYCLASS_::GetPreviewFilePath(char * *aPreviewFilePath)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetPreviewFilePath(const char * aPreviewFilePath)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string thumbFileSpec; */
NS_IMETHODIMP _MYCLASS_::GetThumbFileSpec(char * *aThumbFileSpec)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetThumbFileSpec(const char * aThumbFileSpec)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string thumbFilePath; */
NS_IMETHODIMP _MYCLASS_::GetThumbFilePath(char * *aThumbFilePath)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetThumbFilePath(const char * aThumbFilePath)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AString title; */
NS_IMETHODIMP _MYCLASS_::GetTitle(nsAString & aTitle)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetTitle(const nsAString & aTitle)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AString tags; */
NS_IMETHODIMP _MYCLASS_::GetTags(nsAString & aTags)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetTags(const nsAString & aTags)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AString description; */
NS_IMETHODIMP _MYCLASS_::GetDescription(nsAString & aDescription)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetDescription(const nsAString & aDescription)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string is_public; */
NS_IMETHODIMP _MYCLASS_::GetIs_public(char * *aIs_public)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetIs_public(const char * aIs_public)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string is_friend; */
NS_IMETHODIMP _MYCLASS_::GetIs_friend(char * *aIs_friend)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetIs_friend(const char * aIs_friend)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string is_family; */
NS_IMETHODIMP _MYCLASS_::GetIs_family(char * *aIs_family)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetIs_family(const char * aIs_family)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AString album; */
NS_IMETHODIMP _MYCLASS_::GetAlbum(nsAString & aAlbum)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetAlbum(const nsAString & aAlbum)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string state; */
NS_IMETHODIMP _MYCLASS_::GetState(char * *aState)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetState(const char * aState)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string rotation; */
NS_IMETHODIMP _MYCLASS_::GetRotation(char * *aRotation)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetRotation(const char * aRotation)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string crop; */
NS_IMETHODIMP _MYCLASS_::GetCrop(char * *aCrop)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetCrop(const char * aCrop)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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


/* starting interface:    flockIPhotoUploadListener */
#define FLOCKIPHOTOUPLOADLISTENER_IID_STR "03c80699-d437-466d-a9af-d28b4f3bc6e1"

#define FLOCKIPHOTOUPLOADLISTENER_IID \
  {0x03c80699, 0xd437, 0x466d, \
    { 0xa9, 0xaf, 0xd2, 0x8b, 0x4f, 0x3b, 0xc6, 0xe1 }}

class NS_NO_VTABLE flockIPhotoUploadListener : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(FLOCKIPHOTOUPLOADLISTENER_IID)

  /* void onCreatePhotoUpload (in flockIPhotoUpload aUpload); */
  NS_IMETHOD OnCreatePhotoUpload(flockIPhotoUpload *aUpload) = 0;

  /* void onUploadStart (in flockIPhotoUpload aUpload, in long aCount, in long aMax); */
  NS_IMETHOD OnUploadStart(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax) = 0;

  /* void onUpload (in flockIPhotoUpload aUpload, in long aCount, in long aMax); */
  NS_IMETHOD OnUpload(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax) = 0;

  /* void onUploadError (in flockIPhotoUpload aUpload, in long aCount, in long aMax, in flockIError aError); */
  NS_IMETHOD OnUploadError(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax, flockIError *aError) = 0;

  /* void onUploadComplete (); */
  NS_IMETHOD OnUploadComplete(void) = 0;

  /* void onUploadAdd (in flockIPhotoUpload aUpload); */
  NS_IMETHOD OnUploadAdd(flockIPhotoUpload *aUpload) = 0;

  /* void onUploadRemove (); */
  NS_IMETHOD OnUploadRemove(void) = 0;

  /* void onUploadCreateError (in AString aFilename); */
  NS_IMETHOD OnUploadCreateError(const nsAString & aFilename) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_FLOCKIPHOTOUPLOADLISTENER \
  NS_IMETHOD OnCreatePhotoUpload(flockIPhotoUpload *aUpload); \
  NS_IMETHOD OnUploadStart(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax); \
  NS_IMETHOD OnUpload(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax); \
  NS_IMETHOD OnUploadError(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax, flockIError *aError); \
  NS_IMETHOD OnUploadComplete(void); \
  NS_IMETHOD OnUploadAdd(flockIPhotoUpload *aUpload); \
  NS_IMETHOD OnUploadRemove(void); \
  NS_IMETHOD OnUploadCreateError(const nsAString & aFilename); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_FLOCKIPHOTOUPLOADLISTENER(_to) \
  NS_IMETHOD OnCreatePhotoUpload(flockIPhotoUpload *aUpload) { return _to OnCreatePhotoUpload(aUpload); } \
  NS_IMETHOD OnUploadStart(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax) { return _to OnUploadStart(aUpload, aCount, aMax); } \
  NS_IMETHOD OnUpload(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax) { return _to OnUpload(aUpload, aCount, aMax); } \
  NS_IMETHOD OnUploadError(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax, flockIError *aError) { return _to OnUploadError(aUpload, aCount, aMax, aError); } \
  NS_IMETHOD OnUploadComplete(void) { return _to OnUploadComplete(); } \
  NS_IMETHOD OnUploadAdd(flockIPhotoUpload *aUpload) { return _to OnUploadAdd(aUpload); } \
  NS_IMETHOD OnUploadRemove(void) { return _to OnUploadRemove(); } \
  NS_IMETHOD OnUploadCreateError(const nsAString & aFilename) { return _to OnUploadCreateError(aFilename); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_FLOCKIPHOTOUPLOADLISTENER(_to) \
  NS_IMETHOD OnCreatePhotoUpload(flockIPhotoUpload *aUpload) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnCreatePhotoUpload(aUpload); } \
  NS_IMETHOD OnUploadStart(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnUploadStart(aUpload, aCount, aMax); } \
  NS_IMETHOD OnUpload(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnUpload(aUpload, aCount, aMax); } \
  NS_IMETHOD OnUploadError(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax, flockIError *aError) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnUploadError(aUpload, aCount, aMax, aError); } \
  NS_IMETHOD OnUploadComplete(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnUploadComplete(); } \
  NS_IMETHOD OnUploadAdd(flockIPhotoUpload *aUpload) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnUploadAdd(aUpload); } \
  NS_IMETHOD OnUploadRemove(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnUploadRemove(); } \
  NS_IMETHOD OnUploadCreateError(const nsAString & aFilename) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnUploadCreateError(aFilename); } 

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

/* Header file */
class _MYCLASS_ : public flockIPhotoUploadListener
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_FLOCKIPHOTOUPLOADLISTENER

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(_MYCLASS_, flockIPhotoUploadListener)

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

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

/* void onCreatePhotoUpload (in flockIPhotoUpload aUpload); */
NS_IMETHODIMP _MYCLASS_::OnCreatePhotoUpload(flockIPhotoUpload *aUpload)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onUploadStart (in flockIPhotoUpload aUpload, in long aCount, in long aMax); */
NS_IMETHODIMP _MYCLASS_::OnUploadStart(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onUpload (in flockIPhotoUpload aUpload, in long aCount, in long aMax); */
NS_IMETHODIMP _MYCLASS_::OnUpload(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onUploadError (in flockIPhotoUpload aUpload, in long aCount, in long aMax, in flockIError aError); */
NS_IMETHODIMP _MYCLASS_::OnUploadError(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax, flockIError *aError)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onUploadComplete (); */
NS_IMETHODIMP _MYCLASS_::OnUploadComplete()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onUploadAdd (in flockIPhotoUpload aUpload); */
NS_IMETHODIMP _MYCLASS_::OnUploadAdd(flockIPhotoUpload *aUpload)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onUploadRemove (); */
NS_IMETHODIMP _MYCLASS_::OnUploadRemove()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onUploadCreateError (in AString aFilename); */
NS_IMETHODIMP _MYCLASS_::OnUploadCreateError(const nsAString & aFilename)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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


/* starting interface:    flockIPhotoAuthListener */
#define FLOCKIPHOTOAUTHLISTENER_IID_STR "b5bcbdf9-2fb9-405d-9e5e-99004b8342a1"

#define FLOCKIPHOTOAUTHLISTENER_IID \
  {0xb5bcbdf9, 0x2fb9, 0x405d, \
    { 0x9e, 0x5e, 0x99, 0x00, 0x4b, 0x83, 0x42, 0xa1 }}

class NS_NO_VTABLE flockIPhotoAuthListener : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(FLOCKIPHOTOAUTHLISTENER_IID)

  /* void onAuth (); */
  NS_IMETHOD OnAuth(void) = 0;

  /* void onError (in flockIError aError); */
  NS_IMETHOD OnError(flockIError *aError) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_FLOCKIPHOTOAUTHLISTENER \
  NS_IMETHOD OnAuth(void); \
  NS_IMETHOD OnError(flockIError *aError); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_FLOCKIPHOTOAUTHLISTENER(_to) \
  NS_IMETHOD OnAuth(void) { return _to OnAuth(); } \
  NS_IMETHOD OnError(flockIError *aError) { return _to OnError(aError); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_FLOCKIPHOTOAUTHLISTENER(_to) \
  NS_IMETHOD OnAuth(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnAuth(); } \
  NS_IMETHOD OnError(flockIError *aError) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnError(aError); } 

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

/* Header file */
class _MYCLASS_ : public flockIPhotoAuthListener
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_FLOCKIPHOTOAUTHLISTENER

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(_MYCLASS_, flockIPhotoAuthListener)

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

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

/* void onAuth (); */
NS_IMETHODIMP _MYCLASS_::OnAuth()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onError (in flockIError aError); */
NS_IMETHODIMP _MYCLASS_::OnError(flockIError *aError)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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


/* starting interface:    flockIPhotoUploadAPIListener */
#define FLOCKIPHOTOUPLOADAPILISTENER_IID_STR "2a470693-5a07-4a7a-bca9-3bf7b6841348"

#define FLOCKIPHOTOUPLOADAPILISTENER_IID \
  {0x2a470693, 0x5a07, 0x4a7a, \
    { 0xbc, 0xa9, 0x3b, 0xf7, 0xb6, 0x84, 0x13, 0x48 }}

class NS_NO_VTABLE flockIPhotoUploadAPIListener : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(FLOCKIPHOTOUPLOADAPILISTENER_IID)

  /* void onUploadComplete (in flockIPhotoUpload aUpload); */
  NS_IMETHOD OnUploadComplete(flockIPhotoUpload *aUpload) = 0;

  /* void onUploadFinalized (in flockIPhotoUpload aUpload, in flockIPhoto aPhoto); */
  NS_IMETHOD OnUploadFinalized(flockIPhotoUpload *aUpload, flockIPhoto *aPhoto) = 0;

  /* void onError (in flockIError aError); */
  NS_IMETHOD OnError(flockIError *aError) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_FLOCKIPHOTOUPLOADAPILISTENER \
  NS_IMETHOD OnUploadComplete(flockIPhotoUpload *aUpload); \
  NS_IMETHOD OnUploadFinalized(flockIPhotoUpload *aUpload, flockIPhoto *aPhoto); \
  NS_IMETHOD OnError(flockIError *aError); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_FLOCKIPHOTOUPLOADAPILISTENER(_to) \
  NS_IMETHOD OnUploadComplete(flockIPhotoUpload *aUpload) { return _to OnUploadComplete(aUpload); } \
  NS_IMETHOD OnUploadFinalized(flockIPhotoUpload *aUpload, flockIPhoto *aPhoto) { return _to OnUploadFinalized(aUpload, aPhoto); } \
  NS_IMETHOD OnError(flockIError *aError) { return _to OnError(aError); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_FLOCKIPHOTOUPLOADAPILISTENER(_to) \
  NS_IMETHOD OnUploadComplete(flockIPhotoUpload *aUpload) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnUploadComplete(aUpload); } \
  NS_IMETHOD OnUploadFinalized(flockIPhotoUpload *aUpload, flockIPhoto *aPhoto) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnUploadFinalized(aUpload, aPhoto); } \
  NS_IMETHOD OnError(flockIError *aError) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnError(aError); } 

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

/* Header file */
class _MYCLASS_ : public flockIPhotoUploadAPIListener
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_FLOCKIPHOTOUPLOADAPILISTENER

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(_MYCLASS_, flockIPhotoUploadAPIListener)

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

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

/* void onUploadComplete (in flockIPhotoUpload aUpload); */
NS_IMETHODIMP _MYCLASS_::OnUploadComplete(flockIPhotoUpload *aUpload)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onUploadFinalized (in flockIPhotoUpload aUpload, in flockIPhoto aPhoto); */
NS_IMETHODIMP _MYCLASS_::OnUploadFinalized(flockIPhotoUpload *aUpload, flockIPhoto *aPhoto)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onError (in flockIError aError); */
NS_IMETHODIMP _MYCLASS_::OnError(flockIError *aError)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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


/* starting interface:    flockIPhoto */
#define FLOCKIPHOTO_IID_STR "79550209-2ab6-48f7-831d-20aa9bed2606"

#define FLOCKIPHOTO_IID \
  {0x79550209, 0x2ab6, 0x48f7, \
    { 0x83, 0x1d, 0x20, 0xaa, 0x9b, 0xed, 0x26, 0x06 }}

class NS_NO_VTABLE flockIPhoto : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(FLOCKIPHOTO_IID)

  /* attribute string id; */
  NS_IMETHOD GetId(char * *aId) = 0;
  NS_IMETHOD SetId(const char * aId) = 0;

  /* attribute string webPageUrl; */
  NS_IMETHOD GetWebPageUrl(char * *aWebPageUrl) = 0;
  NS_IMETHOD SetWebPageUrl(const char * aWebPageUrl) = 0;

  /* attribute string thumbnail; */
  NS_IMETHOD GetThumbnail(char * *aThumbnail) = 0;
  NS_IMETHOD SetThumbnail(const char * aThumbnail) = 0;

  /* attribute string midSizePhoto; */
  NS_IMETHOD GetMidSizePhoto(char * *aMidSizePhoto) = 0;
  NS_IMETHOD SetMidSizePhoto(const char * aMidSizePhoto) = 0;

  /* attribute string largeSizePhoto; */
  NS_IMETHOD GetLargeSizePhoto(char * *aLargeSizePhoto) = 0;
  NS_IMETHOD SetLargeSizePhoto(const char * aLargeSizePhoto) = 0;

  /* attribute AUTF8String title; */
  NS_IMETHOD GetTitle(nsACString & aTitle) = 0;
  NS_IMETHOD SetTitle(const nsACString & aTitle) = 0;

  /* attribute AUTF8String username; */
  NS_IMETHOD GetUsername(nsACString & aUsername) = 0;
  NS_IMETHOD SetUsername(const nsACString & aUsername) = 0;

  /* attribute AUTF8String userid; */
  NS_IMETHOD GetUserid(nsACString & aUserid) = 0;
  NS_IMETHOD SetUserid(const nsACString & aUserid) = 0;

  /* attribute string is_public; */
  NS_IMETHOD GetIs_public(char * *aIs_public) = 0;
  NS_IMETHOD SetIs_public(const char * aIs_public) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_FLOCKIPHOTO \
  NS_IMETHOD GetId(char * *aId); \
  NS_IMETHOD SetId(const char * aId); \
  NS_IMETHOD GetWebPageUrl(char * *aWebPageUrl); \
  NS_IMETHOD SetWebPageUrl(const char * aWebPageUrl); \
  NS_IMETHOD GetThumbnail(char * *aThumbnail); \
  NS_IMETHOD SetThumbnail(const char * aThumbnail); \
  NS_IMETHOD GetMidSizePhoto(char * *aMidSizePhoto); \
  NS_IMETHOD SetMidSizePhoto(const char * aMidSizePhoto); \
  NS_IMETHOD GetLargeSizePhoto(char * *aLargeSizePhoto); \
  NS_IMETHOD SetLargeSizePhoto(const char * aLargeSizePhoto); \
  NS_IMETHOD GetTitle(nsACString & aTitle); \
  NS_IMETHOD SetTitle(const nsACString & aTitle); \
  NS_IMETHOD GetUsername(nsACString & aUsername); \
  NS_IMETHOD SetUsername(const nsACString & aUsername); \
  NS_IMETHOD GetUserid(nsACString & aUserid); \
  NS_IMETHOD SetUserid(const nsACString & aUserid); \
  NS_IMETHOD GetIs_public(char * *aIs_public); \
  NS_IMETHOD SetIs_public(const char * aIs_public); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_FLOCKIPHOTO(_to) \
  NS_IMETHOD GetId(char * *aId) { return _to GetId(aId); } \
  NS_IMETHOD SetId(const char * aId) { return _to SetId(aId); } \
  NS_IMETHOD GetWebPageUrl(char * *aWebPageUrl) { return _to GetWebPageUrl(aWebPageUrl); } \
  NS_IMETHOD SetWebPageUrl(const char * aWebPageUrl) { return _to SetWebPageUrl(aWebPageUrl); } \
  NS_IMETHOD GetThumbnail(char * *aThumbnail) { return _to GetThumbnail(aThumbnail); } \
  NS_IMETHOD SetThumbnail(const char * aThumbnail) { return _to SetThumbnail(aThumbnail); } \
  NS_IMETHOD GetMidSizePhoto(char * *aMidSizePhoto) { return _to GetMidSizePhoto(aMidSizePhoto); } \
  NS_IMETHOD SetMidSizePhoto(const char * aMidSizePhoto) { return _to SetMidSizePhoto(aMidSizePhoto); } \
  NS_IMETHOD GetLargeSizePhoto(char * *aLargeSizePhoto) { return _to GetLargeSizePhoto(aLargeSizePhoto); } \
  NS_IMETHOD SetLargeSizePhoto(const char * aLargeSizePhoto) { return _to SetLargeSizePhoto(aLargeSizePhoto); } \
  NS_IMETHOD GetTitle(nsACString & aTitle) { return _to GetTitle(aTitle); } \
  NS_IMETHOD SetTitle(const nsACString & aTitle) { return _to SetTitle(aTitle); } \
  NS_IMETHOD GetUsername(nsACString & aUsername) { return _to GetUsername(aUsername); } \
  NS_IMETHOD SetUsername(const nsACString & aUsername) { return _to SetUsername(aUsername); } \
  NS_IMETHOD GetUserid(nsACString & aUserid) { return _to GetUserid(aUserid); } \
  NS_IMETHOD SetUserid(const nsACString & aUserid) { return _to SetUserid(aUserid); } \
  NS_IMETHOD GetIs_public(char * *aIs_public) { return _to GetIs_public(aIs_public); } \
  NS_IMETHOD SetIs_public(const char * aIs_public) { return _to SetIs_public(aIs_public); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_FLOCKIPHOTO(_to) \
  NS_IMETHOD GetId(char * *aId) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetId(aId); } \
  NS_IMETHOD SetId(const char * aId) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetId(aId); } \
  NS_IMETHOD GetWebPageUrl(char * *aWebPageUrl) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetWebPageUrl(aWebPageUrl); } \
  NS_IMETHOD SetWebPageUrl(const char * aWebPageUrl) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetWebPageUrl(aWebPageUrl); } \
  NS_IMETHOD GetThumbnail(char * *aThumbnail) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetThumbnail(aThumbnail); } \
  NS_IMETHOD SetThumbnail(const char * aThumbnail) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetThumbnail(aThumbnail); } \
  NS_IMETHOD GetMidSizePhoto(char * *aMidSizePhoto) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetMidSizePhoto(aMidSizePhoto); } \
  NS_IMETHOD SetMidSizePhoto(const char * aMidSizePhoto) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetMidSizePhoto(aMidSizePhoto); } \
  NS_IMETHOD GetLargeSizePhoto(char * *aLargeSizePhoto) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetLargeSizePhoto(aLargeSizePhoto); } \
  NS_IMETHOD SetLargeSizePhoto(const char * aLargeSizePhoto) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetLargeSizePhoto(aLargeSizePhoto); } \
  NS_IMETHOD GetTitle(nsACString & aTitle) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetTitle(aTitle); } \
  NS_IMETHOD SetTitle(const nsACString & aTitle) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetTitle(aTitle); } \
  NS_IMETHOD GetUsername(nsACString & aUsername) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetUsername(aUsername); } \
  NS_IMETHOD SetUsername(const nsACString & aUsername) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetUsername(aUsername); } \
  NS_IMETHOD GetUserid(nsACString & aUserid) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetUserid(aUserid); } \
  NS_IMETHOD SetUserid(const nsACString & aUserid) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetUserid(aUserid); } \
  NS_IMETHOD GetIs_public(char * *aIs_public) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetIs_public(aIs_public); } \
  NS_IMETHOD SetIs_public(const char * aIs_public) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetIs_public(aIs_public); } 

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

/* Header file */
class _MYCLASS_ : public flockIPhoto
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_FLOCKIPHOTO

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(_MYCLASS_, flockIPhoto)

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

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

/* attribute string id; */
NS_IMETHODIMP _MYCLASS_::GetId(char * *aId)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetId(const char * aId)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string webPageUrl; */
NS_IMETHODIMP _MYCLASS_::GetWebPageUrl(char * *aWebPageUrl)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetWebPageUrl(const char * aWebPageUrl)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string thumbnail; */
NS_IMETHODIMP _MYCLASS_::GetThumbnail(char * *aThumbnail)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetThumbnail(const char * aThumbnail)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string midSizePhoto; */
NS_IMETHODIMP _MYCLASS_::GetMidSizePhoto(char * *aMidSizePhoto)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetMidSizePhoto(const char * aMidSizePhoto)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string largeSizePhoto; */
NS_IMETHODIMP _MYCLASS_::GetLargeSizePhoto(char * *aLargeSizePhoto)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetLargeSizePhoto(const char * aLargeSizePhoto)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AUTF8String title; */
NS_IMETHODIMP _MYCLASS_::GetTitle(nsACString & aTitle)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetTitle(const nsACString & aTitle)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AUTF8String username; */
NS_IMETHODIMP _MYCLASS_::GetUsername(nsACString & aUsername)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetUsername(const nsACString & aUsername)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AUTF8String userid; */
NS_IMETHODIMP _MYCLASS_::GetUserid(nsACString & aUserid)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetUserid(const nsACString & aUserid)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string is_public; */
NS_IMETHODIMP _MYCLASS_::GetIs_public(char * *aIs_public)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetIs_public(const char * aIs_public)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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


/* starting interface:    flockIPhotoAPIListener */
#define FLOCKIPHOTOAPILISTENER_IID_STR "8dd40991-9a61-4d61-bfd5-219d8939f6ef"

#define FLOCKIPHOTOAPILISTENER_IID \
  {0x8dd40991, 0x9a61, 0x4d61, \
    { 0xbf, 0xd5, 0x21, 0x9d, 0x89, 0x39, 0xf6, 0xef }}

class NS_NO_VTABLE flockIPhotoAPIListener : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(FLOCKIPHOTOAPILISTENER_IID)

  /* void onResult (in nsIDOMDocument aXML); */
  NS_IMETHOD OnResult(nsIDOMDocument *aXML) = 0;

  /* void onSearchResult (in nsISimpleEnumerator aEnumerator); */
  NS_IMETHOD OnSearchResult(nsISimpleEnumerator *aEnumerator) = 0;

  /* void onGetContactsResult (in nsISimpleEnumerator aEnumerator); */
  NS_IMETHOD OnGetContactsResult(nsISimpleEnumerator *aEnumerator) = 0;

  /* void onFindByUsernameResult (in flockIPhotoPerson aPerson); */
  NS_IMETHOD OnFindByUsernameResult(flockIPhotoPerson *aPerson) = 0;

  /* void onGetValidPerson (in flockIPhotoPerson aPerson); */
  NS_IMETHOD OnGetValidPerson(flockIPhotoPerson *aPerson) = 0;

  /* void onGetAlbumsResult (in nsISimpleEnumerator aEnumerator); */
  NS_IMETHOD OnGetAlbumsResult(nsISimpleEnumerator *aEnumerator) = 0;

  /* void onGetPhoto (in flockIPhoto aPhoto); */
  NS_IMETHOD OnGetPhoto(flockIPhoto *aPhoto) = 0;

  /* void onCreateAlbum (in flockIPhotoAlbum aAlbum); */
  NS_IMETHOD OnCreateAlbum(flockIPhotoAlbum *aAlbum) = 0;

  /* void onGetAccountStatus (in flockIPhotoAccount aAccount); */
  NS_IMETHOD OnGetAccountStatus(flockIPhotoAccount *aAccount) = 0;

  /* void onGetMostRecentPhotoForList (in long aChange); */
  NS_IMETHOD OnGetMostRecentPhotoForList(PRInt32 aChange) = 0;

  /* void onError (in flockIError aError); */
  NS_IMETHOD OnError(flockIError *aError) = 0;

  enum { LIST_NO_CHANGE = 0 };

  enum { LIST_NEED_SAVE = 1 };

  enum { LIST_HAS_NEW = 2 };

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_FLOCKIPHOTOAPILISTENER \
  NS_IMETHOD OnResult(nsIDOMDocument *aXML); \
  NS_IMETHOD OnSearchResult(nsISimpleEnumerator *aEnumerator); \
  NS_IMETHOD OnGetContactsResult(nsISimpleEnumerator *aEnumerator); \
  NS_IMETHOD OnFindByUsernameResult(flockIPhotoPerson *aPerson); \
  NS_IMETHOD OnGetValidPerson(flockIPhotoPerson *aPerson); \
  NS_IMETHOD OnGetAlbumsResult(nsISimpleEnumerator *aEnumerator); \
  NS_IMETHOD OnGetPhoto(flockIPhoto *aPhoto); \
  NS_IMETHOD OnCreateAlbum(flockIPhotoAlbum *aAlbum); \
  NS_IMETHOD OnGetAccountStatus(flockIPhotoAccount *aAccount); \
  NS_IMETHOD OnGetMostRecentPhotoForList(PRInt32 aChange); \
  NS_IMETHOD OnError(flockIError *aError); \

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_FLOCKIPHOTOAPILISTENER(_to) \
  NS_IMETHOD OnResult(nsIDOMDocument *aXML) { return _to OnResult(aXML); } \
  NS_IMETHOD OnSearchResult(nsISimpleEnumerator *aEnumerator) { return _to OnSearchResult(aEnumerator); } \
  NS_IMETHOD OnGetContactsResult(nsISimpleEnumerator *aEnumerator) { return _to OnGetContactsResult(aEnumerator); } \
  NS_IMETHOD OnFindByUsernameResult(flockIPhotoPerson *aPerson) { return _to OnFindByUsernameResult(aPerson); } \
  NS_IMETHOD OnGetValidPerson(flockIPhotoPerson *aPerson) { return _to OnGetValidPerson(aPerson); } \
  NS_IMETHOD OnGetAlbumsResult(nsISimpleEnumerator *aEnumerator) { return _to OnGetAlbumsResult(aEnumerator); } \
  NS_IMETHOD OnGetPhoto(flockIPhoto *aPhoto) { return _to OnGetPhoto(aPhoto); } \
  NS_IMETHOD OnCreateAlbum(flockIPhotoAlbum *aAlbum) { return _to OnCreateAlbum(aAlbum); } \
  NS_IMETHOD OnGetAccountStatus(flockIPhotoAccount *aAccount) { return _to OnGetAccountStatus(aAccount); } \
  NS_IMETHOD OnGetMostRecentPhotoForList(PRInt32 aChange) { return _to OnGetMostRecentPhotoForList(aChange); } \
  NS_IMETHOD OnError(flockIError *aError) { return _to OnError(aError); } \

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_FLOCKIPHOTOAPILISTENER(_to) \
  NS_IMETHOD OnResult(nsIDOMDocument *aXML) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnResult(aXML); } \
  NS_IMETHOD OnSearchResult(nsISimpleEnumerator *aEnumerator) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnSearchResult(aEnumerator); } \
  NS_IMETHOD OnGetContactsResult(nsISimpleEnumerator *aEnumerator) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnGetContactsResult(aEnumerator); } \
  NS_IMETHOD OnFindByUsernameResult(flockIPhotoPerson *aPerson) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnFindByUsernameResult(aPerson); } \
  NS_IMETHOD OnGetValidPerson(flockIPhotoPerson *aPerson) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnGetValidPerson(aPerson); } \
  NS_IMETHOD OnGetAlbumsResult(nsISimpleEnumerator *aEnumerator) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnGetAlbumsResult(aEnumerator); } \
  NS_IMETHOD OnGetPhoto(flockIPhoto *aPhoto) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnGetPhoto(aPhoto); } \
  NS_IMETHOD OnCreateAlbum(flockIPhotoAlbum *aAlbum) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnCreateAlbum(aAlbum); } \
  NS_IMETHOD OnGetAccountStatus(flockIPhotoAccount *aAccount) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnGetAccountStatus(aAccount); } \
  NS_IMETHOD OnGetMostRecentPhotoForList(PRInt32 aChange) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnGetMostRecentPhotoForList(aChange); } \
  NS_IMETHOD OnError(flockIError *aError) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnError(aError); } \

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

/* Header file */
class _MYCLASS_ : public flockIPhotoAPIListener
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_FLOCKIPHOTOAPILISTENER

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(_MYCLASS_, flockIPhotoAPIListener)

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

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

/* void onResult (in nsIDOMDocument aXML); */
NS_IMETHODIMP _MYCLASS_::OnResult(nsIDOMDocument *aXML)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onSearchResult (in nsISimpleEnumerator aEnumerator); */
NS_IMETHODIMP _MYCLASS_::OnSearchResult(nsISimpleEnumerator *aEnumerator)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onGetContactsResult (in nsISimpleEnumerator aEnumerator); */
NS_IMETHODIMP _MYCLASS_::OnGetContactsResult(nsISimpleEnumerator *aEnumerator)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onFindByUsernameResult (in flockIPhotoPerson aPerson); */
NS_IMETHODIMP _MYCLASS_::OnFindByUsernameResult(flockIPhotoPerson *aPerson)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onGetValidPerson (in flockIPhotoPerson aPerson); */
NS_IMETHODIMP _MYCLASS_::OnGetValidPerson(flockIPhotoPerson *aPerson)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onGetAlbumsResult (in nsISimpleEnumerator aEnumerator); */
NS_IMETHODIMP _MYCLASS_::OnGetAlbumsResult(nsISimpleEnumerator *aEnumerator)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onGetPhoto (in flockIPhoto aPhoto); */
NS_IMETHODIMP _MYCLASS_::OnGetPhoto(flockIPhoto *aPhoto)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onCreateAlbum (in flockIPhotoAlbum aAlbum); */
NS_IMETHODIMP _MYCLASS_::OnCreateAlbum(flockIPhotoAlbum *aAlbum)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onGetAccountStatus (in flockIPhotoAccount aAccount); */
NS_IMETHODIMP _MYCLASS_::OnGetAccountStatus(flockIPhotoAccount *aAccount)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onGetMostRecentPhotoForList (in long aChange); */
NS_IMETHODIMP _MYCLASS_::OnGetMostRecentPhotoForList(PRInt32 aChange)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onError (in flockIError aError); */
NS_IMETHODIMP _MYCLASS_::OnError(flockIError *aError)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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


/* starting interface:    flockIPhotoAPI */
#define FLOCKIPHOTOAPI_IID_STR "cae54dc1-5a17-4e18-a84d-b52c93a8319a"

#define FLOCKIPHOTOAPI_IID \
  {0xcae54dc1, 0x5a17, 0x4e18, \
    { 0xa8, 0x4d, 0xb5, 0x2c, 0x93, 0xa8, 0x31, 0x9a }}

class NS_NO_VTABLE flockIPhotoAPI : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(FLOCKIPHOTOAPI_IID)

  /* void login (in flockIPhotoAuthListener aListener); */
  NS_IMETHOD Login(flockIPhotoAuthListener *aListener) = 0;

  /* void logout (); */
  NS_IMETHOD Logout(void) = 0;

  /* flockIPhotoPerson getAuthPerson (); */
  NS_IMETHOD GetAuthPerson(flockIPhotoPerson **_retval) = 0;

  /* void upload (in flockIPhotoUploadAPIListener aListener, in AString aFile, in nsIDictionary aParams, in flockIPhotoUpload aUpload); */
  NS_IMETHOD Upload(flockIPhotoUploadAPIListener *aListener, const nsAString & aFile, nsIDictionary *aParams, flockIPhotoUpload *aUpload) = 0;

  /* void cancelUpload (); */
  NS_IMETHOD CancelUpload(void) = 0;

  /* void call (in flockIPhotoAPIListener aListener, in AString aMethod, in nsIDictionary aParams); */
  NS_IMETHOD Call(flockIPhotoAPIListener *aListener, const nsAString & aMethod, nsIDictionary *aParams) = 0;

  /* void authenticatedCall (in flockIPhotoAPIListener aListener, in AString aMethod, in nsIDictionary aParams); */
  NS_IMETHOD AuthenticatedCall(flockIPhotoAPIListener *aListener, const nsAString & aMethod, nsIDictionary *aParams) = 0;

  /* boolean supportsFeature (in AString aFeature); */
  NS_IMETHOD SupportsFeature(const nsAString & aFeature, PRBool *_retval) = 0;

  /* void getAlbums (in flockIPhotoAPIListener aListener); */
  NS_IMETHOD GetAlbums(flockIPhotoAPIListener *aListener) = 0;

  /* void createAlbum (in flockIPhotoAPIListener aListener, in AString aAlbumName); */
  NS_IMETHOD CreateAlbum(flockIPhotoAPIListener *aListener, const nsAString & aAlbumName) = 0;

  /* void getPhoto (in flockIPhotoAPIListener aListener, in AString aPhotoID); */
  NS_IMETHOD GetPhoto(flockIPhotoAPIListener *aListener, const nsAString & aPhotoID) = 0;

  /* void getContacts (in flockIPhotoAPIListener aListener); */
  NS_IMETHOD GetContacts(flockIPhotoAPIListener *aListener) = 0;

  /* void findByUsername (in flockIPhotoAPIListener aListener, in AString aUsername); */
  NS_IMETHOD FindByUsername(flockIPhotoAPIListener *aListener, const nsAString & aUsername) = 0;

  /* void getValidPerson (in flockIPhotoAPIListener aListener, in AString aURL); */
  NS_IMETHOD GetValidPerson(flockIPhotoAPIListener *aListener, const nsAString & aURL) = 0;

  /* void getMostRecentPhotoForList (in flockIPhotoAPIListener aListener, in nsISimpleEnumerator aEnumerator); */
  NS_IMETHOD GetMostRecentPhotoForList(flockIPhotoAPIListener *aListener, nsISimpleEnumerator *aEnumerator) = 0;

  /* void search (in flockIPhotoAPIListener aListener, in AString aUserid, in AString aTags, in AString aFreeText, in long aCount, in long aPage); */
  NS_IMETHOD Search(flockIPhotoAPIListener *aListener, const nsAString & aUserid, const nsAString & aTags, const nsAString & aFreeText, PRInt32 aCount, PRInt32 aPage) = 0;

  /* void getAccountStatus (in flockIPhotoAPIListener aListener); */
  NS_IMETHOD GetAccountStatus(flockIPhotoAPIListener *aListener) = 0;

  /* void upload2 (in flockIPhotoUploadAPIListener aListener, in flockIPhotoUpload aUpload, in AString aFilename); */
  NS_IMETHOD Upload2(flockIPhotoUploadAPIListener *aListener, flockIPhotoUpload *aUpload, const nsAString & aFilename) = 0;

  /* readonly attribute flockIPhotoPerson firstRunPerson; */
  NS_IMETHOD GetFirstRunPerson(flockIPhotoPerson * *aFirstRunPerson) = 0;

  /* readonly attribute AString serviceName; */
  NS_IMETHOD GetServiceName(nsAString & aServiceName) = 0;

  /* readonly attribute ACString shortName; */
  NS_IMETHOD GetShortName(nsACString & aShortName) = 0;

  /* readonly attribute boolean isLoggedIn; */
  NS_IMETHOD GetIsLoggedIn(PRBool *aIsLoggedIn) = 0;

  /* readonly attribute boolean isUploading; */
  NS_IMETHOD GetIsUploading(PRBool *aIsUploading) = 0;

  /* readonly attribute AString iconUrl; */
  NS_IMETHOD GetIconUrl(nsAString & aIconUrl) = 0;

  enum { LOGGED_OUT = 0 };

  enum { LOGGING_IN = 1 };

  enum { LOGGED_IN = 2 };

  enum { LOGIN_ERROR = 3 };

  /* readonly attribute long authState; */
  NS_IMETHOD GetAuthState(PRInt32 *aAuthState) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_FLOCKIPHOTOAPI \
  NS_IMETHOD Login(flockIPhotoAuthListener *aListener); \
  NS_IMETHOD Logout(void); \
  NS_IMETHOD GetAuthPerson(flockIPhotoPerson **_retval); \
  NS_IMETHOD Upload(flockIPhotoUploadAPIListener *aListener, const nsAString & aFile, nsIDictionary *aParams, flockIPhotoUpload *aUpload); \
  NS_IMETHOD CancelUpload(void); \
  NS_IMETHOD Call(flockIPhotoAPIListener *aListener, const nsAString & aMethod, nsIDictionary *aParams); \
  NS_IMETHOD AuthenticatedCall(flockIPhotoAPIListener *aListener, const nsAString & aMethod, nsIDictionary *aParams); \
  NS_IMETHOD SupportsFeature(const nsAString & aFeature, PRBool *_retval); \
  NS_IMETHOD GetAlbums(flockIPhotoAPIListener *aListener); \
  NS_IMETHOD CreateAlbum(flockIPhotoAPIListener *aListener, const nsAString & aAlbumName); \
  NS_IMETHOD GetPhoto(flockIPhotoAPIListener *aListener, const nsAString & aPhotoID); \
  NS_IMETHOD GetContacts(flockIPhotoAPIListener *aListener); \
  NS_IMETHOD FindByUsername(flockIPhotoAPIListener *aListener, const nsAString & aUsername); \
  NS_IMETHOD GetValidPerson(flockIPhotoAPIListener *aListener, const nsAString & aURL); \
  NS_IMETHOD GetMostRecentPhotoForList(flockIPhotoAPIListener *aListener, nsISimpleEnumerator *aEnumerator); \
  NS_IMETHOD Search(flockIPhotoAPIListener *aListener, const nsAString & aUserid, const nsAString & aTags, const nsAString & aFreeText, PRInt32 aCount, PRInt32 aPage); \
  NS_IMETHOD GetAccountStatus(flockIPhotoAPIListener *aListener); \
  NS_IMETHOD Upload2(flockIPhotoUploadAPIListener *aListener, flockIPhotoUpload *aUpload, const nsAString & aFilename); \
  NS_IMETHOD GetFirstRunPerson(flockIPhotoPerson * *aFirstRunPerson); \
  NS_IMETHOD GetServiceName(nsAString & aServiceName); \
  NS_IMETHOD GetShortName(nsACString & aShortName); \
  NS_IMETHOD GetIsLoggedIn(PRBool *aIsLoggedIn); \
  NS_IMETHOD GetIsUploading(PRBool *aIsUploading); \
  NS_IMETHOD GetIconUrl(nsAString & aIconUrl); \
  NS_IMETHOD GetAuthState(PRInt32 *aAuthState); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_FLOCKIPHOTOAPI(_to) \
  NS_IMETHOD Login(flockIPhotoAuthListener *aListener) { return _to Login(aListener); } \
  NS_IMETHOD Logout(void) { return _to Logout(); } \
  NS_IMETHOD GetAuthPerson(flockIPhotoPerson **_retval) { return _to GetAuthPerson(_retval); } \
  NS_IMETHOD Upload(flockIPhotoUploadAPIListener *aListener, const nsAString & aFile, nsIDictionary *aParams, flockIPhotoUpload *aUpload) { return _to Upload(aListener, aFile, aParams, aUpload); } \
  NS_IMETHOD CancelUpload(void) { return _to CancelUpload(); } \
  NS_IMETHOD Call(flockIPhotoAPIListener *aListener, const nsAString & aMethod, nsIDictionary *aParams) { return _to Call(aListener, aMethod, aParams); } \
  NS_IMETHOD AuthenticatedCall(flockIPhotoAPIListener *aListener, const nsAString & aMethod, nsIDictionary *aParams) { return _to AuthenticatedCall(aListener, aMethod, aParams); } \
  NS_IMETHOD SupportsFeature(const nsAString & aFeature, PRBool *_retval) { return _to SupportsFeature(aFeature, _retval); } \
  NS_IMETHOD GetAlbums(flockIPhotoAPIListener *aListener) { return _to GetAlbums(aListener); } \
  NS_IMETHOD CreateAlbum(flockIPhotoAPIListener *aListener, const nsAString & aAlbumName) { return _to CreateAlbum(aListener, aAlbumName); } \
  NS_IMETHOD GetPhoto(flockIPhotoAPIListener *aListener, const nsAString & aPhotoID) { return _to GetPhoto(aListener, aPhotoID); } \
  NS_IMETHOD GetContacts(flockIPhotoAPIListener *aListener) { return _to GetContacts(aListener); } \
  NS_IMETHOD FindByUsername(flockIPhotoAPIListener *aListener, const nsAString & aUsername) { return _to FindByUsername(aListener, aUsername); } \
  NS_IMETHOD GetValidPerson(flockIPhotoAPIListener *aListener, const nsAString & aURL) { return _to GetValidPerson(aListener, aURL); } \
  NS_IMETHOD GetMostRecentPhotoForList(flockIPhotoAPIListener *aListener, nsISimpleEnumerator *aEnumerator) { return _to GetMostRecentPhotoForList(aListener, aEnumerator); } \
  NS_IMETHOD Search(flockIPhotoAPIListener *aListener, const nsAString & aUserid, const nsAString & aTags, const nsAString & aFreeText, PRInt32 aCount, PRInt32 aPage) { return _to Search(aListener, aUserid, aTags, aFreeText, aCount, aPage); } \
  NS_IMETHOD GetAccountStatus(flockIPhotoAPIListener *aListener) { return _to GetAccountStatus(aListener); } \
  NS_IMETHOD Upload2(flockIPhotoUploadAPIListener *aListener, flockIPhotoUpload *aUpload, const nsAString & aFilename) { return _to Upload2(aListener, aUpload, aFilename); } \
  NS_IMETHOD GetFirstRunPerson(flockIPhotoPerson * *aFirstRunPerson) { return _to GetFirstRunPerson(aFirstRunPerson); } \
  NS_IMETHOD GetServiceName(nsAString & aServiceName) { return _to GetServiceName(aServiceName); } \
  NS_IMETHOD GetShortName(nsACString & aShortName) { return _to GetShortName(aShortName); } \
  NS_IMETHOD GetIsLoggedIn(PRBool *aIsLoggedIn) { return _to GetIsLoggedIn(aIsLoggedIn); } \
  NS_IMETHOD GetIsUploading(PRBool *aIsUploading) { return _to GetIsUploading(aIsUploading); } \
  NS_IMETHOD GetIconUrl(nsAString & aIconUrl) { return _to GetIconUrl(aIconUrl); } \
  NS_IMETHOD GetAuthState(PRInt32 *aAuthState) { return _to GetAuthState(aAuthState); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_FLOCKIPHOTOAPI(_to) \
  NS_IMETHOD Login(flockIPhotoAuthListener *aListener) { return !_to ? NS_ERROR_NULL_POINTER : _to->Login(aListener); } \
  NS_IMETHOD Logout(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->Logout(); } \
  NS_IMETHOD GetAuthPerson(flockIPhotoPerson **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAuthPerson(_retval); } \
  NS_IMETHOD Upload(flockIPhotoUploadAPIListener *aListener, const nsAString & aFile, nsIDictionary *aParams, flockIPhotoUpload *aUpload) { return !_to ? NS_ERROR_NULL_POINTER : _to->Upload(aListener, aFile, aParams, aUpload); } \
  NS_IMETHOD CancelUpload(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->CancelUpload(); } \
  NS_IMETHOD Call(flockIPhotoAPIListener *aListener, const nsAString & aMethod, nsIDictionary *aParams) { return !_to ? NS_ERROR_NULL_POINTER : _to->Call(aListener, aMethod, aParams); } \
  NS_IMETHOD AuthenticatedCall(flockIPhotoAPIListener *aListener, const nsAString & aMethod, nsIDictionary *aParams) { return !_to ? NS_ERROR_NULL_POINTER : _to->AuthenticatedCall(aListener, aMethod, aParams); } \
  NS_IMETHOD SupportsFeature(const nsAString & aFeature, PRBool *_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->SupportsFeature(aFeature, _retval); } \
  NS_IMETHOD GetAlbums(flockIPhotoAPIListener *aListener) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAlbums(aListener); } \
  NS_IMETHOD CreateAlbum(flockIPhotoAPIListener *aListener, const nsAString & aAlbumName) { return !_to ? NS_ERROR_NULL_POINTER : _to->CreateAlbum(aListener, aAlbumName); } \
  NS_IMETHOD GetPhoto(flockIPhotoAPIListener *aListener, const nsAString & aPhotoID) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPhoto(aListener, aPhotoID); } \
  NS_IMETHOD GetContacts(flockIPhotoAPIListener *aListener) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetContacts(aListener); } \
  NS_IMETHOD FindByUsername(flockIPhotoAPIListener *aListener, const nsAString & aUsername) { return !_to ? NS_ERROR_NULL_POINTER : _to->FindByUsername(aListener, aUsername); } \
  NS_IMETHOD GetValidPerson(flockIPhotoAPIListener *aListener, const nsAString & aURL) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetValidPerson(aListener, aURL); } \
  NS_IMETHOD GetMostRecentPhotoForList(flockIPhotoAPIListener *aListener, nsISimpleEnumerator *aEnumerator) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetMostRecentPhotoForList(aListener, aEnumerator); } \
  NS_IMETHOD Search(flockIPhotoAPIListener *aListener, const nsAString & aUserid, const nsAString & aTags, const nsAString & aFreeText, PRInt32 aCount, PRInt32 aPage) { return !_to ? NS_ERROR_NULL_POINTER : _to->Search(aListener, aUserid, aTags, aFreeText, aCount, aPage); } \
  NS_IMETHOD GetAccountStatus(flockIPhotoAPIListener *aListener) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAccountStatus(aListener); } \
  NS_IMETHOD Upload2(flockIPhotoUploadAPIListener *aListener, flockIPhotoUpload *aUpload, const nsAString & aFilename) { return !_to ? NS_ERROR_NULL_POINTER : _to->Upload2(aListener, aUpload, aFilename); } \
  NS_IMETHOD GetFirstRunPerson(flockIPhotoPerson * *aFirstRunPerson) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetFirstRunPerson(aFirstRunPerson); } \
  NS_IMETHOD GetServiceName(nsAString & aServiceName) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetServiceName(aServiceName); } \
  NS_IMETHOD GetShortName(nsACString & aShortName) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetShortName(aShortName); } \
  NS_IMETHOD GetIsLoggedIn(PRBool *aIsLoggedIn) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetIsLoggedIn(aIsLoggedIn); } \
  NS_IMETHOD GetIsUploading(PRBool *aIsUploading) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetIsUploading(aIsUploading); } \
  NS_IMETHOD GetIconUrl(nsAString & aIconUrl) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetIconUrl(aIconUrl); } \
  NS_IMETHOD GetAuthState(PRInt32 *aAuthState) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAuthState(aAuthState); } 

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

/* Header file */
class _MYCLASS_ : public flockIPhotoAPI
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_FLOCKIPHOTOAPI

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(_MYCLASS_, flockIPhotoAPI)

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

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

/* void login (in flockIPhotoAuthListener aListener); */
NS_IMETHODIMP _MYCLASS_::Login(flockIPhotoAuthListener *aListener)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void logout (); */
NS_IMETHODIMP _MYCLASS_::Logout()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* flockIPhotoPerson getAuthPerson (); */
NS_IMETHODIMP _MYCLASS_::GetAuthPerson(flockIPhotoPerson **_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void upload (in flockIPhotoUploadAPIListener aListener, in AString aFile, in nsIDictionary aParams, in flockIPhotoUpload aUpload); */
NS_IMETHODIMP _MYCLASS_::Upload(flockIPhotoUploadAPIListener *aListener, const nsAString & aFile, nsIDictionary *aParams, flockIPhotoUpload *aUpload)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void cancelUpload (); */
NS_IMETHODIMP _MYCLASS_::CancelUpload()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void call (in flockIPhotoAPIListener aListener, in AString aMethod, in nsIDictionary aParams); */
NS_IMETHODIMP _MYCLASS_::Call(flockIPhotoAPIListener *aListener, const nsAString & aMethod, nsIDictionary *aParams)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void authenticatedCall (in flockIPhotoAPIListener aListener, in AString aMethod, in nsIDictionary aParams); */
NS_IMETHODIMP _MYCLASS_::AuthenticatedCall(flockIPhotoAPIListener *aListener, const nsAString & aMethod, nsIDictionary *aParams)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* boolean supportsFeature (in AString aFeature); */
NS_IMETHODIMP _MYCLASS_::SupportsFeature(const nsAString & aFeature, PRBool *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void getAlbums (in flockIPhotoAPIListener aListener); */
NS_IMETHODIMP _MYCLASS_::GetAlbums(flockIPhotoAPIListener *aListener)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void createAlbum (in flockIPhotoAPIListener aListener, in AString aAlbumName); */
NS_IMETHODIMP _MYCLASS_::CreateAlbum(flockIPhotoAPIListener *aListener, const nsAString & aAlbumName)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void getPhoto (in flockIPhotoAPIListener aListener, in AString aPhotoID); */
NS_IMETHODIMP _MYCLASS_::GetPhoto(flockIPhotoAPIListener *aListener, const nsAString & aPhotoID)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void getContacts (in flockIPhotoAPIListener aListener); */
NS_IMETHODIMP _MYCLASS_::GetContacts(flockIPhotoAPIListener *aListener)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void findByUsername (in flockIPhotoAPIListener aListener, in AString aUsername); */
NS_IMETHODIMP _MYCLASS_::FindByUsername(flockIPhotoAPIListener *aListener, const nsAString & aUsername)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void getValidPerson (in flockIPhotoAPIListener aListener, in AString aURL); */
NS_IMETHODIMP _MYCLASS_::GetValidPerson(flockIPhotoAPIListener *aListener, const nsAString & aURL)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void getMostRecentPhotoForList (in flockIPhotoAPIListener aListener, in nsISimpleEnumerator aEnumerator); */
NS_IMETHODIMP _MYCLASS_::GetMostRecentPhotoForList(flockIPhotoAPIListener *aListener, nsISimpleEnumerator *aEnumerator)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void search (in flockIPhotoAPIListener aListener, in AString aUserid, in AString aTags, in AString aFreeText, in long aCount, in long aPage); */
NS_IMETHODIMP _MYCLASS_::Search(flockIPhotoAPIListener *aListener, const nsAString & aUserid, const nsAString & aTags, const nsAString & aFreeText, PRInt32 aCount, PRInt32 aPage)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void getAccountStatus (in flockIPhotoAPIListener aListener); */
NS_IMETHODIMP _MYCLASS_::GetAccountStatus(flockIPhotoAPIListener *aListener)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void upload2 (in flockIPhotoUploadAPIListener aListener, in flockIPhotoUpload aUpload, in AString aFilename); */
NS_IMETHODIMP _MYCLASS_::Upload2(flockIPhotoUploadAPIListener *aListener, flockIPhotoUpload *aUpload, const nsAString & aFilename)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute flockIPhotoPerson firstRunPerson; */
NS_IMETHODIMP _MYCLASS_::GetFirstRunPerson(flockIPhotoPerson * *aFirstRunPerson)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute AString serviceName; */
NS_IMETHODIMP _MYCLASS_::GetServiceName(nsAString & aServiceName)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute ACString shortName; */
NS_IMETHODIMP _MYCLASS_::GetShortName(nsACString & aShortName)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute boolean isLoggedIn; */
NS_IMETHODIMP _MYCLASS_::GetIsLoggedIn(PRBool *aIsLoggedIn)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute boolean isUploading; */
NS_IMETHODIMP _MYCLASS_::GetIsUploading(PRBool *aIsUploading)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute AString iconUrl; */
NS_IMETHODIMP _MYCLASS_::GetIconUrl(nsAString & aIconUrl)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute long authState; */
NS_IMETHODIMP _MYCLASS_::GetAuthState(PRInt32 *aAuthState)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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


/* starting interface:    flockIPhotoUploadService */
#define FLOCKIPHOTOUPLOADSERVICE_IID_STR "74a7c5a0-97d7-4ac0-8728-305e74849453"

#define FLOCKIPHOTOUPLOADSERVICE_IID \
  {0x74a7c5a0, 0x97d7, 0x4ac0, \
    { 0x87, 0x28, 0x30, 0x5e, 0x74, 0x84, 0x94, 0x53 }}

class NS_NO_VTABLE flockIPhotoUploadService : public nsIRDFDataSource {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(FLOCKIPHOTOUPLOADSERVICE_IID)

  /* void createPhotoUpload (in flockIPhotoUploadListener aListener, in AString aFileName); */
  NS_IMETHOD CreatePhotoUpload(flockIPhotoUploadListener *aListener, const nsAString & aFileName) = 0;

  /* void upload (in flockIPhotoAPI aAPI); */
  NS_IMETHOD Upload(flockIPhotoAPI *aAPI) = 0;

  /* void singleUpload (in flockIPhotoUploadAPIListener aListener, in flockIPhotoAPI aAPI, in flockIPhotoUpload aUpload); */
  NS_IMETHOD SingleUpload(flockIPhotoUploadAPIListener *aListener, flockIPhotoAPI *aAPI, flockIPhotoUpload *aUpload) = 0;

  /* void cancelUpload (); */
  NS_IMETHOD CancelUpload(void) = 0;

  /* void addPhotoUpload (in flockIPhotoUpload aReference, in flockIPhotoUpload aUpload); */
  NS_IMETHOD AddPhotoUpload(flockIPhotoUpload *aReference, flockIPhotoUpload *aUpload) = 0;

  /* void savePhotoUpload (in flockIPhotoUpload aUpload); */
  NS_IMETHOD SavePhotoUpload(flockIPhotoUpload *aUpload) = 0;

  /* void removePhotoUpload (in flockIPhotoUpload aUpload); */
  NS_IMETHOD RemovePhotoUpload(flockIPhotoUpload *aUpload) = 0;

  /* void reorderPhotoUpload (in flockIPhotoUpload aReference, in flockIPhotoUpload aUpload); */
  NS_IMETHOD ReorderPhotoUpload(flockIPhotoUpload *aReference, flockIPhotoUpload *aUpload) = 0;

  /* flockIPhotoUpload getPhotoUpload (in AString aURI); */
  NS_IMETHOD GetPhotoUpload(const nsAString & aURI, flockIPhotoUpload **_retval) = 0;

  /* void addListener (in flockIPhotoUploadListener aListener); */
  NS_IMETHOD AddListener(flockIPhotoUploadListener *aListener) = 0;

  /* void removeListener (in flockIPhotoUploadListener aListener); */
  NS_IMETHOD RemoveListener(flockIPhotoUploadListener *aListener) = 0;

  /* void cropPhotoUpload (in flockIPhotoUpload aUpload, in double aX1, in double aY1, in double aX2, in double aY2); */
  NS_IMETHOD CropPhotoUpload(flockIPhotoUpload *aUpload, double aX1, double aY1, double aX2, double aY2) = 0;

  /* void revertPhotoUpload (in flockIPhotoUpload aUpload); */
  NS_IMETHOD RevertPhotoUpload(flockIPhotoUpload *aUpload) = 0;

  /* void rotatePhotoUpload (in flockIPhotoUpload aUpload, in PRInt32 aDegrees); */
  NS_IMETHOD RotatePhotoUpload(flockIPhotoUpload *aUpload, PRInt32 aDegrees) = 0;

  /* void save (); */
  NS_IMETHOD Save(void) = 0;

  /* void cleanPhotoUploadCache (); */
  NS_IMETHOD CleanPhotoUploadCache(void) = 0;

  /* readonly attribute boolean isUploading; */
  NS_IMETHOD GetIsUploading(PRBool *aIsUploading) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_FLOCKIPHOTOUPLOADSERVICE \
  NS_IMETHOD CreatePhotoUpload(flockIPhotoUploadListener *aListener, const nsAString & aFileName); \
  NS_IMETHOD Upload(flockIPhotoAPI *aAPI); \
  NS_IMETHOD SingleUpload(flockIPhotoUploadAPIListener *aListener, flockIPhotoAPI *aAPI, flockIPhotoUpload *aUpload); \
  NS_IMETHOD CancelUpload(void); \
  NS_IMETHOD AddPhotoUpload(flockIPhotoUpload *aReference, flockIPhotoUpload *aUpload); \
  NS_IMETHOD SavePhotoUpload(flockIPhotoUpload *aUpload); \
  NS_IMETHOD RemovePhotoUpload(flockIPhotoUpload *aUpload); \
  NS_IMETHOD ReorderPhotoUpload(flockIPhotoUpload *aReference, flockIPhotoUpload *aUpload); \
  NS_IMETHOD GetPhotoUpload(const nsAString & aURI, flockIPhotoUpload **_retval); \
  NS_IMETHOD AddListener(flockIPhotoUploadListener *aListener); \
  NS_IMETHOD RemoveListener(flockIPhotoUploadListener *aListener); \
  NS_IMETHOD CropPhotoUpload(flockIPhotoUpload *aUpload, double aX1, double aY1, double aX2, double aY2); \
  NS_IMETHOD RevertPhotoUpload(flockIPhotoUpload *aUpload); \
  NS_IMETHOD RotatePhotoUpload(flockIPhotoUpload *aUpload, PRInt32 aDegrees); \
  NS_IMETHOD Save(void); \
  NS_IMETHOD CleanPhotoUploadCache(void); \
  NS_IMETHOD GetIsUploading(PRBool *aIsUploading); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_FLOCKIPHOTOUPLOADSERVICE(_to) \
  NS_IMETHOD CreatePhotoUpload(flockIPhotoUploadListener *aListener, const nsAString & aFileName) { return _to CreatePhotoUpload(aListener, aFileName); } \
  NS_IMETHOD Upload(flockIPhotoAPI *aAPI) { return _to Upload(aAPI); } \
  NS_IMETHOD SingleUpload(flockIPhotoUploadAPIListener *aListener, flockIPhotoAPI *aAPI, flockIPhotoUpload *aUpload) { return _to SingleUpload(aListener, aAPI, aUpload); } \
  NS_IMETHOD CancelUpload(void) { return _to CancelUpload(); } \
  NS_IMETHOD AddPhotoUpload(flockIPhotoUpload *aReference, flockIPhotoUpload *aUpload) { return _to AddPhotoUpload(aReference, aUpload); } \
  NS_IMETHOD SavePhotoUpload(flockIPhotoUpload *aUpload) { return _to SavePhotoUpload(aUpload); } \
  NS_IMETHOD RemovePhotoUpload(flockIPhotoUpload *aUpload) { return _to RemovePhotoUpload(aUpload); } \
  NS_IMETHOD ReorderPhotoUpload(flockIPhotoUpload *aReference, flockIPhotoUpload *aUpload) { return _to ReorderPhotoUpload(aReference, aUpload); } \
  NS_IMETHOD GetPhotoUpload(const nsAString & aURI, flockIPhotoUpload **_retval) { return _to GetPhotoUpload(aURI, _retval); } \
  NS_IMETHOD AddListener(flockIPhotoUploadListener *aListener) { return _to AddListener(aListener); } \
  NS_IMETHOD RemoveListener(flockIPhotoUploadListener *aListener) { return _to RemoveListener(aListener); } \
  NS_IMETHOD CropPhotoUpload(flockIPhotoUpload *aUpload, double aX1, double aY1, double aX2, double aY2) { return _to CropPhotoUpload(aUpload, aX1, aY1, aX2, aY2); } \
  NS_IMETHOD RevertPhotoUpload(flockIPhotoUpload *aUpload) { return _to RevertPhotoUpload(aUpload); } \
  NS_IMETHOD RotatePhotoUpload(flockIPhotoUpload *aUpload, PRInt32 aDegrees) { return _to RotatePhotoUpload(aUpload, aDegrees); } \
  NS_IMETHOD Save(void) { return _to Save(); } \
  NS_IMETHOD CleanPhotoUploadCache(void) { return _to CleanPhotoUploadCache(); } \
  NS_IMETHOD GetIsUploading(PRBool *aIsUploading) { return _to GetIsUploading(aIsUploading); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_FLOCKIPHOTOUPLOADSERVICE(_to) \
  NS_IMETHOD CreatePhotoUpload(flockIPhotoUploadListener *aListener, const nsAString & aFileName) { return !_to ? NS_ERROR_NULL_POINTER : _to->CreatePhotoUpload(aListener, aFileName); } \
  NS_IMETHOD Upload(flockIPhotoAPI *aAPI) { return !_to ? NS_ERROR_NULL_POINTER : _to->Upload(aAPI); } \
  NS_IMETHOD SingleUpload(flockIPhotoUploadAPIListener *aListener, flockIPhotoAPI *aAPI, flockIPhotoUpload *aUpload) { return !_to ? NS_ERROR_NULL_POINTER : _to->SingleUpload(aListener, aAPI, aUpload); } \
  NS_IMETHOD CancelUpload(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->CancelUpload(); } \
  NS_IMETHOD AddPhotoUpload(flockIPhotoUpload *aReference, flockIPhotoUpload *aUpload) { return !_to ? NS_ERROR_NULL_POINTER : _to->AddPhotoUpload(aReference, aUpload); } \
  NS_IMETHOD SavePhotoUpload(flockIPhotoUpload *aUpload) { return !_to ? NS_ERROR_NULL_POINTER : _to->SavePhotoUpload(aUpload); } \
  NS_IMETHOD RemovePhotoUpload(flockIPhotoUpload *aUpload) { return !_to ? NS_ERROR_NULL_POINTER : _to->RemovePhotoUpload(aUpload); } \
  NS_IMETHOD ReorderPhotoUpload(flockIPhotoUpload *aReference, flockIPhotoUpload *aUpload) { return !_to ? NS_ERROR_NULL_POINTER : _to->ReorderPhotoUpload(aReference, aUpload); } \
  NS_IMETHOD GetPhotoUpload(const nsAString & aURI, flockIPhotoUpload **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPhotoUpload(aURI, _retval); } \
  NS_IMETHOD AddListener(flockIPhotoUploadListener *aListener) { return !_to ? NS_ERROR_NULL_POINTER : _to->AddListener(aListener); } \
  NS_IMETHOD RemoveListener(flockIPhotoUploadListener *aListener) { return !_to ? NS_ERROR_NULL_POINTER : _to->RemoveListener(aListener); } \
  NS_IMETHOD CropPhotoUpload(flockIPhotoUpload *aUpload, double aX1, double aY1, double aX2, double aY2) { return !_to ? NS_ERROR_NULL_POINTER : _to->CropPhotoUpload(aUpload, aX1, aY1, aX2, aY2); } \
  NS_IMETHOD RevertPhotoUpload(flockIPhotoUpload *aUpload) { return !_to ? NS_ERROR_NULL_POINTER : _to->RevertPhotoUpload(aUpload); } \
  NS_IMETHOD RotatePhotoUpload(flockIPhotoUpload *aUpload, PRInt32 aDegrees) { return !_to ? NS_ERROR_NULL_POINTER : _to->RotatePhotoUpload(aUpload, aDegrees); } \
  NS_IMETHOD Save(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->Save(); } \
  NS_IMETHOD CleanPhotoUploadCache(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->CleanPhotoUploadCache(); } \
  NS_IMETHOD GetIsUploading(PRBool *aIsUploading) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetIsUploading(aIsUploading); } 

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

/* Header file */
class _MYCLASS_ : public flockIPhotoUploadService
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_FLOCKIPHOTOUPLOADSERVICE

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(_MYCLASS_, flockIPhotoUploadService)

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

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

/* void createPhotoUpload (in flockIPhotoUploadListener aListener, in AString aFileName); */
NS_IMETHODIMP _MYCLASS_::CreatePhotoUpload(flockIPhotoUploadListener *aListener, const nsAString & aFileName)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void upload (in flockIPhotoAPI aAPI); */
NS_IMETHODIMP _MYCLASS_::Upload(flockIPhotoAPI *aAPI)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void singleUpload (in flockIPhotoUploadAPIListener aListener, in flockIPhotoAPI aAPI, in flockIPhotoUpload aUpload); */
NS_IMETHODIMP _MYCLASS_::SingleUpload(flockIPhotoUploadAPIListener *aListener, flockIPhotoAPI *aAPI, flockIPhotoUpload *aUpload)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void cancelUpload (); */
NS_IMETHODIMP _MYCLASS_::CancelUpload()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void addPhotoUpload (in flockIPhotoUpload aReference, in flockIPhotoUpload aUpload); */
NS_IMETHODIMP _MYCLASS_::AddPhotoUpload(flockIPhotoUpload *aReference, flockIPhotoUpload *aUpload)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void savePhotoUpload (in flockIPhotoUpload aUpload); */
NS_IMETHODIMP _MYCLASS_::SavePhotoUpload(flockIPhotoUpload *aUpload)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void removePhotoUpload (in flockIPhotoUpload aUpload); */
NS_IMETHODIMP _MYCLASS_::RemovePhotoUpload(flockIPhotoUpload *aUpload)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void reorderPhotoUpload (in flockIPhotoUpload aReference, in flockIPhotoUpload aUpload); */
NS_IMETHODIMP _MYCLASS_::ReorderPhotoUpload(flockIPhotoUpload *aReference, flockIPhotoUpload *aUpload)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* flockIPhotoUpload getPhotoUpload (in AString aURI); */
NS_IMETHODIMP _MYCLASS_::GetPhotoUpload(const nsAString & aURI, flockIPhotoUpload **_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void addListener (in flockIPhotoUploadListener aListener); */
NS_IMETHODIMP _MYCLASS_::AddListener(flockIPhotoUploadListener *aListener)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void removeListener (in flockIPhotoUploadListener aListener); */
NS_IMETHODIMP _MYCLASS_::RemoveListener(flockIPhotoUploadListener *aListener)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void cropPhotoUpload (in flockIPhotoUpload aUpload, in double aX1, in double aY1, in double aX2, in double aY2); */
NS_IMETHODIMP _MYCLASS_::CropPhotoUpload(flockIPhotoUpload *aUpload, double aX1, double aY1, double aX2, double aY2)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void revertPhotoUpload (in flockIPhotoUpload aUpload); */
NS_IMETHODIMP _MYCLASS_::RevertPhotoUpload(flockIPhotoUpload *aUpload)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void rotatePhotoUpload (in flockIPhotoUpload aUpload, in PRInt32 aDegrees); */
NS_IMETHODIMP _MYCLASS_::RotatePhotoUpload(flockIPhotoUpload *aUpload, PRInt32 aDegrees)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void save (); */
NS_IMETHODIMP _MYCLASS_::Save()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void cleanPhotoUploadCache (); */
NS_IMETHODIMP _MYCLASS_::CleanPhotoUploadCache()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute boolean isUploading; */
NS_IMETHODIMP _MYCLASS_::GetIsUploading(PRBool *aIsUploading)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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


/* starting interface:    flockIPhotoAPIManagerListener */
#define FLOCKIPHOTOAPIMANAGERLISTENER_IID_STR "90ebb22d-c468-4db2-979d-9c32f5d65d78"

#define FLOCKIPHOTOAPIMANAGERLISTENER_IID \
  {0x90ebb22d, 0xc468, 0x4db2, \
    { 0x97, 0x9d, 0x9c, 0x32, 0xf5, 0xd6, 0x5d, 0x78 }}

class NS_NO_VTABLE flockIPhotoAPIManagerListener : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(FLOCKIPHOTOAPIMANAGERLISTENER_IID)

  /* void onAPIStateChange (in flockIPhotoAPI aAPI); */
  NS_IMETHOD OnAPIStateChange(flockIPhotoAPI *aAPI) = 0;

  /* void onError (in flockIError aError); */
  NS_IMETHOD OnError(flockIError *aError) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_FLOCKIPHOTOAPIMANAGERLISTENER \
  NS_IMETHOD OnAPIStateChange(flockIPhotoAPI *aAPI); \
  NS_IMETHOD OnError(flockIError *aError); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_FLOCKIPHOTOAPIMANAGERLISTENER(_to) \
  NS_IMETHOD OnAPIStateChange(flockIPhotoAPI *aAPI) { return _to OnAPIStateChange(aAPI); } \
  NS_IMETHOD OnError(flockIError *aError) { return _to OnError(aError); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_FLOCKIPHOTOAPIMANAGERLISTENER(_to) \
  NS_IMETHOD OnAPIStateChange(flockIPhotoAPI *aAPI) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnAPIStateChange(aAPI); } \
  NS_IMETHOD OnError(flockIError *aError) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnError(aError); } 

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

/* Header file */
class _MYCLASS_ : public flockIPhotoAPIManagerListener
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_FLOCKIPHOTOAPIMANAGERLISTENER

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(_MYCLASS_, flockIPhotoAPIManagerListener)

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

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

/* void onAPIStateChange (in flockIPhotoAPI aAPI); */
NS_IMETHODIMP _MYCLASS_::OnAPIStateChange(flockIPhotoAPI *aAPI)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onError (in flockIError aError); */
NS_IMETHODIMP _MYCLASS_::OnError(flockIError *aError)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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


/* starting interface:    flockIPhotoAPIManager */
#define FLOCKIPHOTOAPIMANAGER_IID_STR "932bfd1b-be5c-408b-94df-984ff37ce0da"

#define FLOCKIPHOTOAPIMANAGER_IID \
  {0x932bfd1b, 0xbe5c, 0x408b, \
    { 0x94, 0xdf, 0x98, 0x4f, 0xf3, 0x7c, 0xe0, 0xda }}

class NS_NO_VTABLE flockIPhotoAPIManager : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(FLOCKIPHOTOAPIMANAGER_IID)

  /* void addListener (in flockIPhotoAPIManagerListener aListener); */
  NS_IMETHOD AddListener(flockIPhotoAPIManagerListener *aListener) = 0;

  /* void removeListener (in flockIPhotoAPIManagerListener aListener); */
  NS_IMETHOD RemoveListener(flockIPhotoAPIManagerListener *aListener) = 0;

  /* void doLogin (in ACString aShortname); */
  NS_IMETHOD DoLogin(const nsACString & aShortname) = 0;

  /* void doLogout (in ACString aShortname); */
  NS_IMETHOD DoLogout(const nsACString & aShortname) = 0;

  /* flockIPhotoAPI getAPIFromShortname (in ACString aShortname); */
  NS_IMETHOD GetAPIFromShortname(const nsACString & aShortname, flockIPhotoAPI **_retval) = 0;

  /* AString getShortnameFromAPI (in flockIPhotoAPI aAPI); */
  NS_IMETHOD GetShortnameFromAPI(flockIPhotoAPI *aAPI, nsAString & _retval) = 0;

  /* readonly attribute nsISimpleEnumerator services; */
  NS_IMETHOD GetServices(nsISimpleEnumerator * *aServices) = 0;

  /* void addPreferredService (in ACString aShortname); */
  NS_IMETHOD AddPreferredService(const nsACString & aShortname) = 0;

  /* void removePreferredService (in ACString aShortname); */
  NS_IMETHOD RemovePreferredService(const nsACString & aShortname) = 0;

  /* readonly attribute nsISimpleEnumerator preferredServices; */
  NS_IMETHOD GetPreferredServices(nsISimpleEnumerator * *aPreferredServices) = 0;

  /* flockIPhotoAPI getDefaultService (); */
  NS_IMETHOD GetDefaultService(flockIPhotoAPI **_retval) = 0;

  /* void setDefaultService (in ACString aShortname); */
  NS_IMETHOD SetDefaultService(const nsACString & aShortname) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_FLOCKIPHOTOAPIMANAGER \
  NS_IMETHOD AddListener(flockIPhotoAPIManagerListener *aListener); \
  NS_IMETHOD RemoveListener(flockIPhotoAPIManagerListener *aListener); \
  NS_IMETHOD DoLogin(const nsACString & aShortname); \
  NS_IMETHOD DoLogout(const nsACString & aShortname); \
  NS_IMETHOD GetAPIFromShortname(const nsACString & aShortname, flockIPhotoAPI **_retval); \
  NS_IMETHOD GetShortnameFromAPI(flockIPhotoAPI *aAPI, nsAString & _retval); \
  NS_IMETHOD GetServices(nsISimpleEnumerator * *aServices); \
  NS_IMETHOD AddPreferredService(const nsACString & aShortname); \
  NS_IMETHOD RemovePreferredService(const nsACString & aShortname); \
  NS_IMETHOD GetPreferredServices(nsISimpleEnumerator * *aPreferredServices); \
  NS_IMETHOD GetDefaultService(flockIPhotoAPI **_retval); \
  NS_IMETHOD SetDefaultService(const nsACString & aShortname); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_FLOCKIPHOTOAPIMANAGER(_to) \
  NS_IMETHOD AddListener(flockIPhotoAPIManagerListener *aListener) { return _to AddListener(aListener); } \
  NS_IMETHOD RemoveListener(flockIPhotoAPIManagerListener *aListener) { return _to RemoveListener(aListener); } \
  NS_IMETHOD DoLogin(const nsACString & aShortname) { return _to DoLogin(aShortname); } \
  NS_IMETHOD DoLogout(const nsACString & aShortname) { return _to DoLogout(aShortname); } \
  NS_IMETHOD GetAPIFromShortname(const nsACString & aShortname, flockIPhotoAPI **_retval) { return _to GetAPIFromShortname(aShortname, _retval); } \
  NS_IMETHOD GetShortnameFromAPI(flockIPhotoAPI *aAPI, nsAString & _retval) { return _to GetShortnameFromAPI(aAPI, _retval); } \
  NS_IMETHOD GetServices(nsISimpleEnumerator * *aServices) { return _to GetServices(aServices); } \
  NS_IMETHOD AddPreferredService(const nsACString & aShortname) { return _to AddPreferredService(aShortname); } \
  NS_IMETHOD RemovePreferredService(const nsACString & aShortname) { return _to RemovePreferredService(aShortname); } \
  NS_IMETHOD GetPreferredServices(nsISimpleEnumerator * *aPreferredServices) { return _to GetPreferredServices(aPreferredServices); } \
  NS_IMETHOD GetDefaultService(flockIPhotoAPI **_retval) { return _to GetDefaultService(_retval); } \
  NS_IMETHOD SetDefaultService(const nsACString & aShortname) { return _to SetDefaultService(aShortname); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_FLOCKIPHOTOAPIMANAGER(_to) \
  NS_IMETHOD AddListener(flockIPhotoAPIManagerListener *aListener) { return !_to ? NS_ERROR_NULL_POINTER : _to->AddListener(aListener); } \
  NS_IMETHOD RemoveListener(flockIPhotoAPIManagerListener *aListener) { return !_to ? NS_ERROR_NULL_POINTER : _to->RemoveListener(aListener); } \
  NS_IMETHOD DoLogin(const nsACString & aShortname) { return !_to ? NS_ERROR_NULL_POINTER : _to->DoLogin(aShortname); } \
  NS_IMETHOD DoLogout(const nsACString & aShortname) { return !_to ? NS_ERROR_NULL_POINTER : _to->DoLogout(aShortname); } \
  NS_IMETHOD GetAPIFromShortname(const nsACString & aShortname, flockIPhotoAPI **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAPIFromShortname(aShortname, _retval); } \
  NS_IMETHOD GetShortnameFromAPI(flockIPhotoAPI *aAPI, nsAString & _retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetShortnameFromAPI(aAPI, _retval); } \
  NS_IMETHOD GetServices(nsISimpleEnumerator * *aServices) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetServices(aServices); } \
  NS_IMETHOD AddPreferredService(const nsACString & aShortname) { return !_to ? NS_ERROR_NULL_POINTER : _to->AddPreferredService(aShortname); } \
  NS_IMETHOD RemovePreferredService(const nsACString & aShortname) { return !_to ? NS_ERROR_NULL_POINTER : _to->RemovePreferredService(aShortname); } \
  NS_IMETHOD GetPreferredServices(nsISimpleEnumerator * *aPreferredServices) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPreferredServices(aPreferredServices); } \
  NS_IMETHOD GetDefaultService(flockIPhotoAPI **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetDefaultService(_retval); } \
  NS_IMETHOD SetDefaultService(const nsACString & aShortname) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetDefaultService(aShortname); } 

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

/* Header file */
class _MYCLASS_ : public flockIPhotoAPIManager
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_FLOCKIPHOTOAPIMANAGER

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(_MYCLASS_, flockIPhotoAPIManager)

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

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

/* void addListener (in flockIPhotoAPIManagerListener aListener); */
NS_IMETHODIMP _MYCLASS_::AddListener(flockIPhotoAPIManagerListener *aListener)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void removeListener (in flockIPhotoAPIManagerListener aListener); */
NS_IMETHODIMP _MYCLASS_::RemoveListener(flockIPhotoAPIManagerListener *aListener)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void doLogin (in ACString aShortname); */
NS_IMETHODIMP _MYCLASS_::DoLogin(const nsACString & aShortname)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void doLogout (in ACString aShortname); */
NS_IMETHODIMP _MYCLASS_::DoLogout(const nsACString & aShortname)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* flockIPhotoAPI getAPIFromShortname (in ACString aShortname); */
NS_IMETHODIMP _MYCLASS_::GetAPIFromShortname(const nsACString & aShortname, flockIPhotoAPI **_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* AString getShortnameFromAPI (in flockIPhotoAPI aAPI); */
NS_IMETHODIMP _MYCLASS_::GetShortnameFromAPI(flockIPhotoAPI *aAPI, nsAString & _retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute nsISimpleEnumerator services; */
NS_IMETHODIMP _MYCLASS_::GetServices(nsISimpleEnumerator * *aServices)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void addPreferredService (in ACString aShortname); */
NS_IMETHODIMP _MYCLASS_::AddPreferredService(const nsACString & aShortname)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void removePreferredService (in ACString aShortname); */
NS_IMETHODIMP _MYCLASS_::RemovePreferredService(const nsACString & aShortname)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute nsISimpleEnumerator preferredServices; */
NS_IMETHODIMP _MYCLASS_::GetPreferredServices(nsISimpleEnumerator * *aPreferredServices)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* flockIPhotoAPI getDefaultService (); */
NS_IMETHODIMP _MYCLASS_::GetDefaultService(flockIPhotoAPI **_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setDefaultService (in ACString aShortname); */
NS_IMETHODIMP _MYCLASS_::SetDefaultService(const nsACString & aShortname)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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


/* starting interface:    flockIPhotoPeopleServiceListener */
#define FLOCKIPHOTOPEOPLESERVICELISTENER_IID_STR "6a565280-3790-4889-b491-5e24c84a6d3a"

#define FLOCKIPHOTOPEOPLESERVICELISTENER_IID \
  {0x6a565280, 0x3790, 0x4889, \
    { 0xb4, 0x91, 0x5e, 0x24, 0xc8, 0x4a, 0x6d, 0x3a }}

class NS_NO_VTABLE flockIPhotoPeopleServiceListener : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(FLOCKIPHOTOPEOPLESERVICELISTENER_IID)

  /* void onUpdate (); */
  NS_IMETHOD OnUpdate(void) = 0;

  /* void onNewPhotos (); */
  NS_IMETHOD OnNewPhotos(void) = 0;

  /* void onNewPhotosTouched (); */
  NS_IMETHOD OnNewPhotosTouched(void) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_FLOCKIPHOTOPEOPLESERVICELISTENER \
  NS_IMETHOD OnUpdate(void); \
  NS_IMETHOD OnNewPhotos(void); \
  NS_IMETHOD OnNewPhotosTouched(void); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_FLOCKIPHOTOPEOPLESERVICELISTENER(_to) \
  NS_IMETHOD OnUpdate(void) { return _to OnUpdate(); } \
  NS_IMETHOD OnNewPhotos(void) { return _to OnNewPhotos(); } \
  NS_IMETHOD OnNewPhotosTouched(void) { return _to OnNewPhotosTouched(); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_FLOCKIPHOTOPEOPLESERVICELISTENER(_to) \
  NS_IMETHOD OnUpdate(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnUpdate(); } \
  NS_IMETHOD OnNewPhotos(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnNewPhotos(); } \
  NS_IMETHOD OnNewPhotosTouched(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnNewPhotosTouched(); } 

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

/* Header file */
class _MYCLASS_ : public flockIPhotoPeopleServiceListener
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_FLOCKIPHOTOPEOPLESERVICELISTENER

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(_MYCLASS_, flockIPhotoPeopleServiceListener)

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

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

/* void onUpdate (); */
NS_IMETHODIMP _MYCLASS_::OnUpdate()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onNewPhotos (); */
NS_IMETHODIMP _MYCLASS_::OnNewPhotos()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onNewPhotosTouched (); */
NS_IMETHODIMP _MYCLASS_::OnNewPhotosTouched()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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


/* starting interface:    flockIPhotoPeopleService */
#define FLOCKIPHOTOPEOPLESERVICE_IID_STR "6a4c4878-fd98-4e4e-97b8-06559ba934b3"

#define FLOCKIPHOTOPEOPLESERVICE_IID \
  {0x6a4c4878, 0xfd98, 0x4e4e, \
    { 0x97, 0xb8, 0x06, 0x55, 0x9b, 0xa9, 0x34, 0xb3 }}

class NS_NO_VTABLE flockIPhotoPeopleService : public nsIRDFDataSource {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(FLOCKIPHOTOPEOPLESERVICE_IID)

  /* void addListener (in flockIPhotoPeopleServiceListener aListener); */
  NS_IMETHOD AddListener(flockIPhotoPeopleServiceListener *aListener) = 0;

  /* void removeListener (in flockIPhotoPeopleServiceListener aListener); */
  NS_IMETHOD RemoveListener(flockIPhotoPeopleServiceListener *aListener) = 0;

  /* flockIPhotoPerson getPhotoPersonByURI (in AString aURI); */
  NS_IMETHOD GetPhotoPersonByURI(const nsAString & aURI, flockIPhotoPerson **_retval) = 0;

  /* flockIPhotoPerson getPhotoPersonByID (in flockIPhotoAPI aService, in AString aID); */
  NS_IMETHOD GetPhotoPersonByID(flockIPhotoAPI *aService, const nsAString & aID, flockIPhotoPerson **_retval) = 0;

  /* flockIPhotoPerson getPhotoPerson (in flockIPhotoPerson aPerson); */
  NS_IMETHOD GetPhotoPerson(flockIPhotoPerson *aPerson, flockIPhotoPerson **_retval) = 0;

  /* void addToRecent (in flockIPhotoPerson aPerson); */
  NS_IMETHOD AddToRecent(flockIPhotoPerson *aPerson) = 0;

  /* void clearRecent (); */
  NS_IMETHOD ClearRecent(void) = 0;

  /* flockIPhotoPerson getMostRecentPhotoPerson (); */
  NS_IMETHOD GetMostRecentPhotoPerson(flockIPhotoPerson **_retval) = 0;

  /* void addToList (in long aListID, in flockIPhotoPerson aPerson); */
  NS_IMETHOD AddToList(PRInt32 aListID, flockIPhotoPerson *aPerson) = 0;

  /* void removeFromList (in long aListID, in flockIPhotoPerson aPerson); */
  NS_IMETHOD RemoveFromList(PRInt32 aListID, flockIPhotoPerson *aPerson) = 0;

  /* void clearList (in long aListID); */
  NS_IMETHOD ClearList(PRInt32 aListID) = 0;

  /* boolean isInList (in long aListID, in flockIPhotoPerson aPerson); */
  NS_IMETHOD IsInList(PRInt32 aListID, flockIPhotoPerson *aPerson, PRBool *_retval) = 0;

  /* void registerList (in long aListID, in ACString aShortName, in AString aName); */
  NS_IMETHOD RegisterList(PRInt32 aListID, const nsACString & aShortName, const nsAString & aName) = 0;

  /* void removePerson (in flockIPhotoPerson aPerson); */
  NS_IMETHOD RemovePerson(flockIPhotoPerson *aPerson) = 0;

  /* boolean hasNewPhotos (in flockIPhotoPerson aPerson); */
  NS_IMETHOD HasNewPhotos(flockIPhotoPerson *aPerson, PRBool *_retval) = 0;

  /* PRTime getLastUpdated (in flockIPhotoPerson aPerson); */
  NS_IMETHOD GetLastUpdated(flockIPhotoPerson *aPerson, PRTime *_retval) = 0;

  /* void clearHasNewPhotos (in flockIPhotoPerson aPerson); */
  NS_IMETHOD ClearHasNewPhotos(flockIPhotoPerson *aPerson) = 0;

  /* void clearAllHasNewPhotos (); */
  NS_IMETHOD ClearAllHasNewPhotos(void) = 0;

  /* void findNewPhotosForList (in long aListID); */
  NS_IMETHOD FindNewPhotosForList(PRInt32 aListID) = 0;

  /* readonly attribute boolean isFindingNewPhotosForList; */
  NS_IMETHOD GetIsFindingNewPhotosForList(PRBool *aIsFindingNewPhotosForList) = 0;

  /* void syncContacts (); */
  NS_IMETHOD SyncContacts(void) = 0;

  /* nsISimpleEnumerator getListEnumerator (in long aListID); */
  NS_IMETHOD GetListEnumerator(PRInt32 aListID, nsISimpleEnumerator **_retval) = 0;

  /* void update (); */
  NS_IMETHOD Update(void) = 0;

  /* attribute long updateInterval; */
  NS_IMETHOD GetUpdateInterval(PRInt32 *aUpdateInterval) = 0;
  NS_IMETHOD SetUpdateInterval(PRInt32 aUpdateInterval) = 0;

  /* readonly attribute PRTime lastUpdate; */
  NS_IMETHOD GetLastUpdate(PRTime *aLastUpdate) = 0;

  /* readonly attribute boolean hasNew; */
  NS_IMETHOD GetHasNew(PRBool *aHasNew) = 0;

  /* readonly attribute nsISimpleEnumerator people; */
  NS_IMETHOD GetPeople(nsISimpleEnumerator * *aPeople) = 0;

  enum { LIST_WATCHED = 1 };

  enum { LIST_RECENT = 2 };

  enum { LIST_CONTACTS = 3 };

  enum { LIST_ACCOUNTS = 4 };

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_FLOCKIPHOTOPEOPLESERVICE \
  NS_IMETHOD AddListener(flockIPhotoPeopleServiceListener *aListener); \
  NS_IMETHOD RemoveListener(flockIPhotoPeopleServiceListener *aListener); \
  NS_IMETHOD GetPhotoPersonByURI(const nsAString & aURI, flockIPhotoPerson **_retval); \
  NS_IMETHOD GetPhotoPersonByID(flockIPhotoAPI *aService, const nsAString & aID, flockIPhotoPerson **_retval); \
  NS_IMETHOD GetPhotoPerson(flockIPhotoPerson *aPerson, flockIPhotoPerson **_retval); \
  NS_IMETHOD AddToRecent(flockIPhotoPerson *aPerson); \
  NS_IMETHOD ClearRecent(void); \
  NS_IMETHOD GetMostRecentPhotoPerson(flockIPhotoPerson **_retval); \
  NS_IMETHOD AddToList(PRInt32 aListID, flockIPhotoPerson *aPerson); \
  NS_IMETHOD RemoveFromList(PRInt32 aListID, flockIPhotoPerson *aPerson); \
  NS_IMETHOD ClearList(PRInt32 aListID); \
  NS_IMETHOD IsInList(PRInt32 aListID, flockIPhotoPerson *aPerson, PRBool *_retval); \
  NS_IMETHOD RegisterList(PRInt32 aListID, const nsACString & aShortName, const nsAString & aName); \
  NS_IMETHOD RemovePerson(flockIPhotoPerson *aPerson); \
  NS_IMETHOD HasNewPhotos(flockIPhotoPerson *aPerson, PRBool *_retval); \
  NS_IMETHOD GetLastUpdated(flockIPhotoPerson *aPerson, PRTime *_retval); \
  NS_IMETHOD ClearHasNewPhotos(flockIPhotoPerson *aPerson); \
  NS_IMETHOD ClearAllHasNewPhotos(void); \
  NS_IMETHOD FindNewPhotosForList(PRInt32 aListID); \
  NS_IMETHOD GetIsFindingNewPhotosForList(PRBool *aIsFindingNewPhotosForList); \
  NS_IMETHOD SyncContacts(void); \
  NS_IMETHOD GetListEnumerator(PRInt32 aListID, nsISimpleEnumerator **_retval); \
  NS_IMETHOD Update(void); \
  NS_IMETHOD GetUpdateInterval(PRInt32 *aUpdateInterval); \
  NS_IMETHOD SetUpdateInterval(PRInt32 aUpdateInterval); \
  NS_IMETHOD GetLastUpdate(PRTime *aLastUpdate); \
  NS_IMETHOD GetHasNew(PRBool *aHasNew); \
  NS_IMETHOD GetPeople(nsISimpleEnumerator * *aPeople); \

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_FLOCKIPHOTOPEOPLESERVICE(_to) \
  NS_IMETHOD AddListener(flockIPhotoPeopleServiceListener *aListener) { return _to AddListener(aListener); } \
  NS_IMETHOD RemoveListener(flockIPhotoPeopleServiceListener *aListener) { return _to RemoveListener(aListener); } \
  NS_IMETHOD GetPhotoPersonByURI(const nsAString & aURI, flockIPhotoPerson **_retval) { return _to GetPhotoPersonByURI(aURI, _retval); } \
  NS_IMETHOD GetPhotoPersonByID(flockIPhotoAPI *aService, const nsAString & aID, flockIPhotoPerson **_retval) { return _to GetPhotoPersonByID(aService, aID, _retval); } \
  NS_IMETHOD GetPhotoPerson(flockIPhotoPerson *aPerson, flockIPhotoPerson **_retval) { return _to GetPhotoPerson(aPerson, _retval); } \
  NS_IMETHOD AddToRecent(flockIPhotoPerson *aPerson) { return _to AddToRecent(aPerson); } \
  NS_IMETHOD ClearRecent(void) { return _to ClearRecent(); } \
  NS_IMETHOD GetMostRecentPhotoPerson(flockIPhotoPerson **_retval) { return _to GetMostRecentPhotoPerson(_retval); } \
  NS_IMETHOD AddToList(PRInt32 aListID, flockIPhotoPerson *aPerson) { return _to AddToList(aListID, aPerson); } \
  NS_IMETHOD RemoveFromList(PRInt32 aListID, flockIPhotoPerson *aPerson) { return _to RemoveFromList(aListID, aPerson); } \
  NS_IMETHOD ClearList(PRInt32 aListID) { return _to ClearList(aListID); } \
  NS_IMETHOD IsInList(PRInt32 aListID, flockIPhotoPerson *aPerson, PRBool *_retval) { return _to IsInList(aListID, aPerson, _retval); } \
  NS_IMETHOD RegisterList(PRInt32 aListID, const nsACString & aShortName, const nsAString & aName) { return _to RegisterList(aListID, aShortName, aName); } \
  NS_IMETHOD RemovePerson(flockIPhotoPerson *aPerson) { return _to RemovePerson(aPerson); } \
  NS_IMETHOD HasNewPhotos(flockIPhotoPerson *aPerson, PRBool *_retval) { return _to HasNewPhotos(aPerson, _retval); } \
  NS_IMETHOD GetLastUpdated(flockIPhotoPerson *aPerson, PRTime *_retval) { return _to GetLastUpdated(aPerson, _retval); } \
  NS_IMETHOD ClearHasNewPhotos(flockIPhotoPerson *aPerson) { return _to ClearHasNewPhotos(aPerson); } \
  NS_IMETHOD ClearAllHasNewPhotos(void) { return _to ClearAllHasNewPhotos(); } \
  NS_IMETHOD FindNewPhotosForList(PRInt32 aListID) { return _to FindNewPhotosForList(aListID); } \
  NS_IMETHOD GetIsFindingNewPhotosForList(PRBool *aIsFindingNewPhotosForList) { return _to GetIsFindingNewPhotosForList(aIsFindingNewPhotosForList); } \
  NS_IMETHOD SyncContacts(void) { return _to SyncContacts(); } \
  NS_IMETHOD GetListEnumerator(PRInt32 aListID, nsISimpleEnumerator **_retval) { return _to GetListEnumerator(aListID, _retval); } \
  NS_IMETHOD Update(void) { return _to Update(); } \
  NS_IMETHOD GetUpdateInterval(PRInt32 *aUpdateInterval) { return _to GetUpdateInterval(aUpdateInterval); } \
  NS_IMETHOD SetUpdateInterval(PRInt32 aUpdateInterval) { return _to SetUpdateInterval(aUpdateInterval); } \
  NS_IMETHOD GetLastUpdate(PRTime *aLastUpdate) { return _to GetLastUpdate(aLastUpdate); } \
  NS_IMETHOD GetHasNew(PRBool *aHasNew) { return _to GetHasNew(aHasNew); } \
  NS_IMETHOD GetPeople(nsISimpleEnumerator * *aPeople) { return _to GetPeople(aPeople); } \

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_FLOCKIPHOTOPEOPLESERVICE(_to) \
  NS_IMETHOD AddListener(flockIPhotoPeopleServiceListener *aListener) { return !_to ? NS_ERROR_NULL_POINTER : _to->AddListener(aListener); } \
  NS_IMETHOD RemoveListener(flockIPhotoPeopleServiceListener *aListener) { return !_to ? NS_ERROR_NULL_POINTER : _to->RemoveListener(aListener); } \
  NS_IMETHOD GetPhotoPersonByURI(const nsAString & aURI, flockIPhotoPerson **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPhotoPersonByURI(aURI, _retval); } \
  NS_IMETHOD GetPhotoPersonByID(flockIPhotoAPI *aService, const nsAString & aID, flockIPhotoPerson **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPhotoPersonByID(aService, aID, _retval); } \
  NS_IMETHOD GetPhotoPerson(flockIPhotoPerson *aPerson, flockIPhotoPerson **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPhotoPerson(aPerson, _retval); } \
  NS_IMETHOD AddToRecent(flockIPhotoPerson *aPerson) { return !_to ? NS_ERROR_NULL_POINTER : _to->AddToRecent(aPerson); } \
  NS_IMETHOD ClearRecent(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->ClearRecent(); } \
  NS_IMETHOD GetMostRecentPhotoPerson(flockIPhotoPerson **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetMostRecentPhotoPerson(_retval); } \
  NS_IMETHOD AddToList(PRInt32 aListID, flockIPhotoPerson *aPerson) { return !_to ? NS_ERROR_NULL_POINTER : _to->AddToList(aListID, aPerson); } \
  NS_IMETHOD RemoveFromList(PRInt32 aListID, flockIPhotoPerson *aPerson) { return !_to ? NS_ERROR_NULL_POINTER : _to->RemoveFromList(aListID, aPerson); } \
  NS_IMETHOD ClearList(PRInt32 aListID) { return !_to ? NS_ERROR_NULL_POINTER : _to->ClearList(aListID); } \
  NS_IMETHOD IsInList(PRInt32 aListID, flockIPhotoPerson *aPerson, PRBool *_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->IsInList(aListID, aPerson, _retval); } \
  NS_IMETHOD RegisterList(PRInt32 aListID, const nsACString & aShortName, const nsAString & aName) { return !_to ? NS_ERROR_NULL_POINTER : _to->RegisterList(aListID, aShortName, aName); } \
  NS_IMETHOD RemovePerson(flockIPhotoPerson *aPerson) { return !_to ? NS_ERROR_NULL_POINTER : _to->RemovePerson(aPerson); } \
  NS_IMETHOD HasNewPhotos(flockIPhotoPerson *aPerson, PRBool *_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->HasNewPhotos(aPerson, _retval); } \
  NS_IMETHOD GetLastUpdated(flockIPhotoPerson *aPerson, PRTime *_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetLastUpdated(aPerson, _retval); } \
  NS_IMETHOD ClearHasNewPhotos(flockIPhotoPerson *aPerson) { return !_to ? NS_ERROR_NULL_POINTER : _to->ClearHasNewPhotos(aPerson); } \
  NS_IMETHOD ClearAllHasNewPhotos(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->ClearAllHasNewPhotos(); } \
  NS_IMETHOD FindNewPhotosForList(PRInt32 aListID) { return !_to ? NS_ERROR_NULL_POINTER : _to->FindNewPhotosForList(aListID); } \
  NS_IMETHOD GetIsFindingNewPhotosForList(PRBool *aIsFindingNewPhotosForList) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetIsFindingNewPhotosForList(aIsFindingNewPhotosForList); } \
  NS_IMETHOD SyncContacts(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->SyncContacts(); } \
  NS_IMETHOD GetListEnumerator(PRInt32 aListID, nsISimpleEnumerator **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetListEnumerator(aListID, _retval); } \
  NS_IMETHOD Update(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->Update(); } \
  NS_IMETHOD GetUpdateInterval(PRInt32 *aUpdateInterval) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetUpdateInterval(aUpdateInterval); } \
  NS_IMETHOD SetUpdateInterval(PRInt32 aUpdateInterval) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetUpdateInterval(aUpdateInterval); } \
  NS_IMETHOD GetLastUpdate(PRTime *aLastUpdate) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetLastUpdate(aLastUpdate); } \
  NS_IMETHOD GetHasNew(PRBool *aHasNew) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetHasNew(aHasNew); } \
  NS_IMETHOD GetPeople(nsISimpleEnumerator * *aPeople) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPeople(aPeople); } \

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

/* Header file */
class _MYCLASS_ : public flockIPhotoPeopleService
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_FLOCKIPHOTOPEOPLESERVICE

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(_MYCLASS_, flockIPhotoPeopleService)

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

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

/* void addListener (in flockIPhotoPeopleServiceListener aListener); */
NS_IMETHODIMP _MYCLASS_::AddListener(flockIPhotoPeopleServiceListener *aListener)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void removeListener (in flockIPhotoPeopleServiceListener aListener); */
NS_IMETHODIMP _MYCLASS_::RemoveListener(flockIPhotoPeopleServiceListener *aListener)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* flockIPhotoPerson getPhotoPersonByURI (in AString aURI); */
NS_IMETHODIMP _MYCLASS_::GetPhotoPersonByURI(const nsAString & aURI, flockIPhotoPerson **_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* flockIPhotoPerson getPhotoPersonByID (in flockIPhotoAPI aService, in AString aID); */
NS_IMETHODIMP _MYCLASS_::GetPhotoPersonByID(flockIPhotoAPI *aService, const nsAString & aID, flockIPhotoPerson **_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* flockIPhotoPerson getPhotoPerson (in flockIPhotoPerson aPerson); */
NS_IMETHODIMP _MYCLASS_::GetPhotoPerson(flockIPhotoPerson *aPerson, flockIPhotoPerson **_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void addToRecent (in flockIPhotoPerson aPerson); */
NS_IMETHODIMP _MYCLASS_::AddToRecent(flockIPhotoPerson *aPerson)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void clearRecent (); */
NS_IMETHODIMP _MYCLASS_::ClearRecent()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* flockIPhotoPerson getMostRecentPhotoPerson (); */
NS_IMETHODIMP _MYCLASS_::GetMostRecentPhotoPerson(flockIPhotoPerson **_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void addToList (in long aListID, in flockIPhotoPerson aPerson); */
NS_IMETHODIMP _MYCLASS_::AddToList(PRInt32 aListID, flockIPhotoPerson *aPerson)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void removeFromList (in long aListID, in flockIPhotoPerson aPerson); */
NS_IMETHODIMP _MYCLASS_::RemoveFromList(PRInt32 aListID, flockIPhotoPerson *aPerson)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void clearList (in long aListID); */
NS_IMETHODIMP _MYCLASS_::ClearList(PRInt32 aListID)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* boolean isInList (in long aListID, in flockIPhotoPerson aPerson); */
NS_IMETHODIMP _MYCLASS_::IsInList(PRInt32 aListID, flockIPhotoPerson *aPerson, PRBool *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void registerList (in long aListID, in ACString aShortName, in AString aName); */
NS_IMETHODIMP _MYCLASS_::RegisterList(PRInt32 aListID, const nsACString & aShortName, const nsAString & aName)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void removePerson (in flockIPhotoPerson aPerson); */
NS_IMETHODIMP _MYCLASS_::RemovePerson(flockIPhotoPerson *aPerson)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* boolean hasNewPhotos (in flockIPhotoPerson aPerson); */
NS_IMETHODIMP _MYCLASS_::HasNewPhotos(flockIPhotoPerson *aPerson, PRBool *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* PRTime getLastUpdated (in flockIPhotoPerson aPerson); */
NS_IMETHODIMP _MYCLASS_::GetLastUpdated(flockIPhotoPerson *aPerson, PRTime *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void clearHasNewPhotos (in flockIPhotoPerson aPerson); */
NS_IMETHODIMP _MYCLASS_::ClearHasNewPhotos(flockIPhotoPerson *aPerson)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void clearAllHasNewPhotos (); */
NS_IMETHODIMP _MYCLASS_::ClearAllHasNewPhotos()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void findNewPhotosForList (in long aListID); */
NS_IMETHODIMP _MYCLASS_::FindNewPhotosForList(PRInt32 aListID)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute boolean isFindingNewPhotosForList; */
NS_IMETHODIMP _MYCLASS_::GetIsFindingNewPhotosForList(PRBool *aIsFindingNewPhotosForList)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void syncContacts (); */
NS_IMETHODIMP _MYCLASS_::SyncContacts()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* nsISimpleEnumerator getListEnumerator (in long aListID); */
NS_IMETHODIMP _MYCLASS_::GetListEnumerator(PRInt32 aListID, nsISimpleEnumerator **_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void update (); */
NS_IMETHODIMP _MYCLASS_::Update()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute long updateInterval; */
NS_IMETHODIMP _MYCLASS_::GetUpdateInterval(PRInt32 *aUpdateInterval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetUpdateInterval(PRInt32 aUpdateInterval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute PRTime lastUpdate; */
NS_IMETHODIMP _MYCLASS_::GetLastUpdate(PRTime *aLastUpdate)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute boolean hasNew; */
NS_IMETHODIMP _MYCLASS_::GetHasNew(PRBool *aHasNew)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute nsISimpleEnumerator people; */
NS_IMETHODIMP _MYCLASS_::GetPeople(nsISimpleEnumerator * *aPeople)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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


#endif /* __gen_flockIPhoto_h__ */
