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

#ifndef __gen_flockIPhotoUpload_h__
#define __gen_flockIPhotoUpload_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_nsIDOMNode_h__
#include "nsIDOMNode.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

#ifndef __gen_flockIPoller_h__
#include "flockIPoller.h"
#endif

#ifndef __gen_nsIWritablePropertyBag2_h__
#include "nsIWritablePropertyBag2.h"
#endif

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

class flockIMediaItem; /* forward declaration */


/* 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 notes; */
  NS_IMETHOD GetNotes(nsAString & aNotes) = 0;
  NS_IMETHOD SetNotes(const nsAString & aNotes) = 0;

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

  /* attribute AString privacy_use_batch; */
  NS_IMETHOD GetPrivacy_use_batch(nsAString & aPrivacy_use_batch) = 0;
  NS_IMETHOD SetPrivacy_use_batch(const nsAString & aPrivacy_use_batch) = 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 GetNotes(nsAString & aNotes); \
  NS_IMETHOD SetNotes(const nsAString & aNotes); \
  NS_IMETHOD GetDescription(nsAString & aDescription); \
  NS_IMETHOD SetDescription(const nsAString & aDescription); \
  NS_IMETHOD GetPrivacy_use_batch(nsAString & aPrivacy_use_batch); \
  NS_IMETHOD SetPrivacy_use_batch(const nsAString & aPrivacy_use_batch); \
  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 GetNotes(nsAString & aNotes) { return _to GetNotes(aNotes); } \
  NS_IMETHOD SetNotes(const nsAString & aNotes) { return _to SetNotes(aNotes); } \
  NS_IMETHOD GetDescription(nsAString & aDescription) { return _to GetDescription(aDescription); } \
  NS_IMETHOD SetDescription(const nsAString & aDescription) { return _to SetDescription(aDescription); } \
  NS_IMETHOD GetPrivacy_use_batch(nsAString & aPrivacy_use_batch) { return _to GetPrivacy_use_batch(aPrivacy_use_batch); } \
  NS_IMETHOD SetPrivacy_use_batch(const nsAString & aPrivacy_use_batch) { return _to SetPrivacy_use_batch(aPrivacy_use_batch); } \
  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 GetNotes(nsAString & aNotes) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetNotes(aNotes); } \
  NS_IMETHOD SetNotes(const nsAString & aNotes) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetNotes(aNotes); } \
  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 GetPrivacy_use_batch(nsAString & aPrivacy_use_batch) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPrivacy_use_batch(aPrivacy_use_batch); } \
  NS_IMETHOD SetPrivacy_use_batch(const nsAString & aPrivacy_use_batch) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetPrivacy_use_batch(aPrivacy_use_batch); } \
  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 notes; */
NS_IMETHODIMP _MYCLASS_::GetNotes(nsAString & aNotes)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetNotes(const nsAString & aNotes)
{
    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 AString privacy_use_batch; */
NS_IMETHODIMP _MYCLASS_::GetPrivacy_use_batch(nsAString & aPrivacy_use_batch)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetPrivacy_use_batch(const nsAString & aPrivacy_use_batch)
{
    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 onUploadProgress (in PRUint32 aCurrentProgress); */
  NS_IMETHOD OnUploadProgress(PRUint32 aCurrentProgress) = 0;

  /* 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 onMediaImportError (in AString aFilename); */
  NS_IMETHOD OnMediaImportError(const nsAString & aFilename) = 0;

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

  /* void onMediaImportStart (in AString filename, in long aNumInBatch); */
  NS_IMETHOD OnMediaImportStart(const nsAString & filename, PRInt32 aNumInBatch) = 0;

  /* void onMediaImportFinish (in flockIPhotoUpload aPhotoUpload, in long aCount); */
  NS_IMETHOD OnMediaImportFinish(flockIPhotoUpload *aPhotoUpload, PRInt32 aCount) = 0;

  /* void onMediaBatchImportStart (in long aBatchSize); */
  NS_IMETHOD OnMediaBatchImportStart(PRInt32 aBatchSize) = 0;

  /* void onMediaBatchImportFinish (); */
  NS_IMETHOD OnMediaBatchImportFinish(void) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_FLOCKIPHOTOUPLOADLISTENER \
  NS_IMETHOD OnUploadProgress(PRUint32 aCurrentProgress); \
  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 OnMediaImportError(const nsAString & aFilename); \
  NS_IMETHOD OnError(flockIError *aError); \
  NS_IMETHOD OnMediaImportStart(const nsAString & filename, PRInt32 aNumInBatch); \
  NS_IMETHOD OnMediaImportFinish(flockIPhotoUpload *aPhotoUpload, PRInt32 aCount); \
  NS_IMETHOD OnMediaBatchImportStart(PRInt32 aBatchSize); \
  NS_IMETHOD OnMediaBatchImportFinish(void); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_FLOCKIPHOTOUPLOADLISTENER(_to) \
  NS_IMETHOD OnUploadProgress(PRUint32 aCurrentProgress) { return _to OnUploadProgress(aCurrentProgress); } \
  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 OnMediaImportError(const nsAString & aFilename) { return _to OnMediaImportError(aFilename); } \
  NS_IMETHOD OnError(flockIError *aError) { return _to OnError(aError); } \
  NS_IMETHOD OnMediaImportStart(const nsAString & filename, PRInt32 aNumInBatch) { return _to OnMediaImportStart(filename, aNumInBatch); } \
  NS_IMETHOD OnMediaImportFinish(flockIPhotoUpload *aPhotoUpload, PRInt32 aCount) { return _to OnMediaImportFinish(aPhotoUpload, aCount); } \
  NS_IMETHOD OnMediaBatchImportStart(PRInt32 aBatchSize) { return _to OnMediaBatchImportStart(aBatchSize); } \
  NS_IMETHOD OnMediaBatchImportFinish(void) { return _to OnMediaBatchImportFinish(); } 

/* 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 OnUploadProgress(PRUint32 aCurrentProgress) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnUploadProgress(aCurrentProgress); } \
  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 OnMediaImportError(const nsAString & aFilename) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnMediaImportError(aFilename); } \
  NS_IMETHOD OnError(flockIError *aError) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnError(aError); } \
  NS_IMETHOD OnMediaImportStart(const nsAString & filename, PRInt32 aNumInBatch) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnMediaImportStart(filename, aNumInBatch); } \
  NS_IMETHOD OnMediaImportFinish(flockIPhotoUpload *aPhotoUpload, PRInt32 aCount) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnMediaImportFinish(aPhotoUpload, aCount); } \
  NS_IMETHOD OnMediaBatchImportStart(PRInt32 aBatchSize) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnMediaBatchImportStart(aBatchSize); } \
  NS_IMETHOD OnMediaBatchImportFinish(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnMediaBatchImportFinish(); } 

#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 onUploadProgress (in PRUint32 aCurrentProgress); */
NS_IMETHODIMP _MYCLASS_::OnUploadProgress(PRUint32 aCurrentProgress)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* 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 onMediaImportError (in AString aFilename); */
NS_IMETHODIMP _MYCLASS_::OnMediaImportError(const nsAString & aFilename)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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

/* void onMediaImportStart (in AString filename, in long aNumInBatch); */
NS_IMETHODIMP _MYCLASS_::OnMediaImportStart(const nsAString & filename, PRInt32 aNumInBatch)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onMediaImportFinish (in flockIPhotoUpload aPhotoUpload, in long aCount); */
NS_IMETHODIMP _MYCLASS_::OnMediaImportFinish(flockIPhotoUpload *aPhotoUpload, PRInt32 aCount)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onMediaBatchImportStart (in long aBatchSize); */
NS_IMETHODIMP _MYCLASS_::OnMediaBatchImportStart(PRInt32 aBatchSize)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onMediaBatchImportFinish (); */
NS_IMETHODIMP _MYCLASS_::OnMediaBatchImportFinish()
{
    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 onProgress (in PRUint32 aCurrentProgress); */
  NS_IMETHOD OnProgress(PRUint32 aCurrentProgress) = 0;

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

  /* void onUploadFinalized (in flockIPhotoUpload aUpload, in flockIMediaItem aMediaItem); */
  NS_IMETHOD OnUploadFinalized(flockIPhotoUpload *aUpload, flockIMediaItem *aMediaItem) = 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 OnProgress(PRUint32 aCurrentProgress); \
  NS_IMETHOD OnUploadComplete(flockIPhotoUpload *aUpload); \
  NS_IMETHOD OnUploadFinalized(flockIPhotoUpload *aUpload, flockIMediaItem *aMediaItem); \
  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 OnProgress(PRUint32 aCurrentProgress) { return _to OnProgress(aCurrentProgress); } \
  NS_IMETHOD OnUploadComplete(flockIPhotoUpload *aUpload) { return _to OnUploadComplete(aUpload); } \
  NS_IMETHOD OnUploadFinalized(flockIPhotoUpload *aUpload, flockIMediaItem *aMediaItem) { return _to OnUploadFinalized(aUpload, aMediaItem); } \
  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 OnProgress(PRUint32 aCurrentProgress) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnProgress(aCurrentProgress); } \
  NS_IMETHOD OnUploadComplete(flockIPhotoUpload *aUpload) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnUploadComplete(aUpload); } \
  NS_IMETHOD OnUploadFinalized(flockIPhotoUpload *aUpload, flockIMediaItem *aMediaItem) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnUploadFinalized(aUpload, aMediaItem); } \
  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 onProgress (in PRUint32 aCurrentProgress); */
NS_IMETHODIMP _MYCLASS_::OnProgress(PRUint32 aCurrentProgress)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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

/* void onUploadFinalized (in flockIPhotoUpload aUpload, in flockIMediaItem aMediaItem); */
NS_IMETHODIMP _MYCLASS_::OnUploadFinalized(flockIPhotoUpload *aUpload, flockIMediaItem *aMediaItem)
{
    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:    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)

  /* boolean hasOnePhotoAccount (); */
  NS_IMETHOD HasOnePhotoAccount(PRBool *_retval) = 0;

  /* string getDefaultService (); */
  NS_IMETHOD GetDefaultService(char **_retval) = 0;

  /* void setDefaultService (in string aServiceId); */
  NS_IMETHOD SetDefaultService(const char *aServiceId) = 0;

  /* void promptForAccount (); */
  NS_IMETHOD PromptForAccount(void) = 0;

  /* void launchUploader (); */
  NS_IMETHOD LaunchUploader(void) = 0;

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

  /* void addMediaToImportQueue (in AString aUrl, in flockIPhotoUploadListener aListener); */
  NS_IMETHOD AddMediaToImportQueue(const nsAString & aUrl, flockIPhotoUploadListener *aListener) = 0;

  /* void startImportQueue (in flockIPhotoUploadListener aListener); */
  NS_IMETHOD StartImportQueue(flockIPhotoUploadListener *aListener) = 0;

  /* void cancelImport (); */
  NS_IMETHOD CancelImport(void) = 0;

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

  /* void singleUpload (in flockIPhotoUploadAPIListener aListener, in flockIMediaWebService aAPI, in flockIPhotoUpload aUpload); */
  NS_IMETHOD SingleUpload(flockIPhotoUploadAPIListener *aListener, flockIMediaWebService *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;

  /* readonly attribute boolean isImporting; */
  NS_IMETHOD GetIsImporting(PRBool *aIsImporting) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_FLOCKIPHOTOUPLOADSERVICE \
  NS_IMETHOD HasOnePhotoAccount(PRBool *_retval); \
  NS_IMETHOD GetDefaultService(char **_retval); \
  NS_IMETHOD SetDefaultService(const char *aServiceId); \
  NS_IMETHOD PromptForAccount(void); \
  NS_IMETHOD LaunchUploader(void); \
  NS_IMETHOD ImportSingleMediaItem(flockIPhotoUploadListener *aListener, const nsAString & aFileName); \
  NS_IMETHOD AddMediaToImportQueue(const nsAString & aUrl, flockIPhotoUploadListener *aListener); \
  NS_IMETHOD StartImportQueue(flockIPhotoUploadListener *aListener); \
  NS_IMETHOD CancelImport(void); \
  NS_IMETHOD Upload(flockIMediaWebService *aAPI); \
  NS_IMETHOD SingleUpload(flockIPhotoUploadAPIListener *aListener, flockIMediaWebService *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); \
  NS_IMETHOD GetIsImporting(PRBool *aIsImporting); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_FLOCKIPHOTOUPLOADSERVICE(_to) \
  NS_IMETHOD HasOnePhotoAccount(PRBool *_retval) { return _to HasOnePhotoAccount(_retval); } \
  NS_IMETHOD GetDefaultService(char **_retval) { return _to GetDefaultService(_retval); } \
  NS_IMETHOD SetDefaultService(const char *aServiceId) { return _to SetDefaultService(aServiceId); } \
  NS_IMETHOD PromptForAccount(void) { return _to PromptForAccount(); } \
  NS_IMETHOD LaunchUploader(void) { return _to LaunchUploader(); } \
  NS_IMETHOD ImportSingleMediaItem(flockIPhotoUploadListener *aListener, const nsAString & aFileName) { return _to ImportSingleMediaItem(aListener, aFileName); } \
  NS_IMETHOD AddMediaToImportQueue(const nsAString & aUrl, flockIPhotoUploadListener *aListener) { return _to AddMediaToImportQueue(aUrl, aListener); } \
  NS_IMETHOD StartImportQueue(flockIPhotoUploadListener *aListener) { return _to StartImportQueue(aListener); } \
  NS_IMETHOD CancelImport(void) { return _to CancelImport(); } \
  NS_IMETHOD Upload(flockIMediaWebService *aAPI) { return _to Upload(aAPI); } \
  NS_IMETHOD SingleUpload(flockIPhotoUploadAPIListener *aListener, flockIMediaWebService *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); } \
  NS_IMETHOD GetIsImporting(PRBool *aIsImporting) { return _to GetIsImporting(aIsImporting); } 

/* 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 HasOnePhotoAccount(PRBool *_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->HasOnePhotoAccount(_retval); } \
  NS_IMETHOD GetDefaultService(char **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetDefaultService(_retval); } \
  NS_IMETHOD SetDefaultService(const char *aServiceId) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetDefaultService(aServiceId); } \
  NS_IMETHOD PromptForAccount(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->PromptForAccount(); } \
  NS_IMETHOD LaunchUploader(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->LaunchUploader(); } \
  NS_IMETHOD ImportSingleMediaItem(flockIPhotoUploadListener *aListener, const nsAString & aFileName) { return !_to ? NS_ERROR_NULL_POINTER : _to->ImportSingleMediaItem(aListener, aFileName); } \
  NS_IMETHOD AddMediaToImportQueue(const nsAString & aUrl, flockIPhotoUploadListener *aListener) { return !_to ? NS_ERROR_NULL_POINTER : _to->AddMediaToImportQueue(aUrl, aListener); } \
  NS_IMETHOD StartImportQueue(flockIPhotoUploadListener *aListener) { return !_to ? NS_ERROR_NULL_POINTER : _to->StartImportQueue(aListener); } \
  NS_IMETHOD CancelImport(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->CancelImport(); } \
  NS_IMETHOD Upload(flockIMediaWebService *aAPI) { return !_to ? NS_ERROR_NULL_POINTER : _to->Upload(aAPI); } \
  NS_IMETHOD SingleUpload(flockIPhotoUploadAPIListener *aListener, flockIMediaWebService *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); } \
  NS_IMETHOD GetIsImporting(PRBool *aIsImporting) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetIsImporting(aIsImporting); } 

#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 */
}

/* boolean hasOnePhotoAccount (); */
NS_IMETHODIMP _MYCLASS_::HasOnePhotoAccount(PRBool *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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

/* void setDefaultService (in string aServiceId); */
NS_IMETHODIMP _MYCLASS_::SetDefaultService(const char *aServiceId)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void promptForAccount (); */
NS_IMETHODIMP _MYCLASS_::PromptForAccount()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void launchUploader (); */
NS_IMETHODIMP _MYCLASS_::LaunchUploader()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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

/* void addMediaToImportQueue (in AString aUrl, in flockIPhotoUploadListener aListener); */
NS_IMETHODIMP _MYCLASS_::AddMediaToImportQueue(const nsAString & aUrl, flockIPhotoUploadListener *aListener)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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

/* void cancelImport (); */
NS_IMETHODIMP _MYCLASS_::CancelImport()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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

/* void singleUpload (in flockIPhotoUploadAPIListener aListener, in flockIMediaWebService aAPI, in flockIPhotoUpload aUpload); */
NS_IMETHODIMP _MYCLASS_::SingleUpload(flockIPhotoUploadAPIListener *aListener, flockIMediaWebService *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;
}

/* readonly attribute boolean isImporting; */
NS_IMETHODIMP _MYCLASS_::GetIsImporting(PRBool *aIsImporting)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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


#endif /* __gen_flockIPhotoUpload_h__ */
