if (typeof IssuePriority != "function") {
  function IssuePriority() {
  }
}

if (typeof ListingPlaceholderElement != "function") {
  function ListingPlaceholderElement() {
  }
}

if (typeof Community != "function") {
  function Community() {
  }
}

if (typeof Contract != "function") {
  function Contract() {
  }
}

if (typeof City != "function") {
  function City() {
  }
}

if (typeof DressCodeType != "function") {
  function DressCodeType() {
  }
}

if (typeof TOC != "function") {
  function TOC() {
  }
}

if (typeof Market != "function") {
  function Market() {
  }
}

if (typeof State != "function") {
  function State() {
  }
}

if (typeof ContractDetail != "function") {
  function ContractDetail() {
  }
}

if (typeof HeadingLine != "function") {
  function HeadingLine() {
  }
}

if (typeof EntityBatch != "function") {
  function EntityBatch() {
  }
}

if (typeof IntroductionImage != "function") {
  function IntroductionImage() {
  }
}

if (typeof ListBatch != "function") {
  function ListBatch() {
  }
}

if (typeof CompositeEntityDto != "function") {
  function CompositeEntityDto() {
  }
}

if (typeof Issue != "function") {
  function Issue() {
  }
}

if (typeof IndustryCategory != "function") {
  function IndustryCategory() {
  }
}

if (typeof UserGroup != "function") {
  function UserGroup() {
  }
}

if (typeof SalesPromotion != "function") {
  function SalesPromotion() {
  }
}

if (typeof PublicationIssue != "function") {
  function PublicationIssue() {
  }
}

if (typeof TOCCategory != "function") {
  function TOCCategory() {
  }
}

if (typeof SpecialtyType != "function") {
  function SpecialtyType() {
  }
}

if (typeof Announcement != "function") {
  function Announcement() {
  }
}

if (typeof IssueHistoryDetail != "function") {
  function IssueHistoryDetail() {
  }
}

if (typeof PublicationType != "function") {
  function PublicationType() {
  }
}

if (typeof IssueHistory != "function") {
  function IssueHistory() {
  }
}

if (typeof ListingDisplaySettings != "function") {
  function ListingDisplaySettings() {
  }
}

if (typeof LocationIdentifier != "function") {
  function LocationIdentifier() {
  }
}

if (typeof World != "function") {
  function World() {
  }
}

if (typeof Area != "function") {
  function Area() {
  }
}

if (typeof Editorial != "function") {
  function Editorial() {
  }
}

if (typeof User != "function") {
  function User() {
  }
}

if (typeof OperatingHours != "function") {
  function OperatingHours() {
  }
}

if (typeof ApStaff != "function") {
  function ApStaff() {
  }
}

if (typeof ListingCriteriaDto != "function") {
  function ListingCriteriaDto() {
  }
}

if (typeof EditorialImage != "function") {
  function EditorialImage() {
  }
}

if (typeof CoverCategory != "function") {
  function CoverCategory() {
  }
}

if (typeof IssueType != "function") {
  function IssueType() {
  }
}

if (typeof ProductType != "function") {
  function ProductType() {
  }
}

if (typeof CustomListingCriteriaDto != "function") {
  function CustomListingCriteriaDto() {
  }
}

if (typeof SearchDetail != "function") {
  function SearchDetail() {
  }
}

if (typeof InsideBackCover != "function") {
  function InsideBackCover() {
  }
}

if (typeof IssueStatus != "function") {
  function IssueStatus() {
  }
}

if (typeof PublicationFormat != "function") {
  function PublicationFormat() {
  }
}

if (typeof ListingPlaceholder != "function") {
  function ListingPlaceholder() {
  }
}

if (typeof Recurrence != "function") {
  function Recurrence() {
  }
}

if (typeof ReservationType != "function") {
  function ReservationType() {
  }
}

if (typeof TravelMode != "function") {
  function TravelMode() {
  }
}

if (typeof PhysicalRequirementType != "function") {
  function PhysicalRequirementType() {
  }
}

if (typeof HotelChain != "function") {
  function HotelChain() {
  }
}

if (typeof FrontCover != "function") {
  function FrontCover() {
  }
}

if (typeof Category != "function") {
  function Category() {
  }
}

if (typeof Advertiser != "function") {
  function Advertiser() {
  }
}

if (typeof IssueUpdateDto != "function") {
  function IssueUpdateDto() {
  }
}

if (typeof Ap != "function") {
  function Ap() {
  }
}

if (typeof Country != "function") {
  function Country() {
  }
}

if (typeof AssetType != "function") {
  function AssetType() {
  }
}

if (typeof FeatureType != "function") {
  function FeatureType() {
  }
}

if (typeof Billing != "function") {
  function Billing() {
  }
}

if (typeof AgendaGeographyNode != "function") {
  function AgendaGeographyNode() {
  }
}

if (typeof PresetColor != "function") {
  function PresetColor() {
  }
}

if (typeof FrontCoverData != "function") {
  function FrontCoverData() {
  }
}

if (typeof ClubAffiliation != "function") {
  function ClubAffiliation() {
  }
}

if (typeof AgendaDates != "function") {
  function AgendaDates() {
  }
}

if (typeof InsideBackCoverData != "function") {
  function InsideBackCoverData() {
  }
}

if (typeof PaymentType != "function") {
  function PaymentType() {
  }
}

if (typeof Listing != "function") {
  function Listing() {
  }
}

if (typeof AssetLayout != "function") {
  function AssetLayout() {
  }
}

if (typeof PageInsert != "function") {
  function PageInsert() {
  }
}

if (typeof WelcomeLetter != "function") {
  function WelcomeLetter() {
  }
}

if (typeof IssueCriteriaDto != "function") {
  function IssueCriteriaDto() {
  }
}

if (typeof DoubleEntityDto != "function") {
  function DoubleEntityDto() {
  }
}

if (typeof Search != "function") {
  function Search() {
  }
}

if (typeof Placeholder != "function") {
  function Placeholder() {
  }
}

if (typeof DisplayCalendar != "function") {
  function DisplayCalendar() {
  }
}

if (typeof AveragePriceType != "function") {
  function AveragePriceType() {
  }
}

if (typeof Agenda != "function") {
  function Agenda() {
  }
}

if (typeof Introduction != "function") {
  function Introduction() {
  }
}

if (typeof UserCriteriaDto != "function") {
  function UserCriteriaDto() {
  }
}

if (typeof ImageAsset != "function") {
  function ImageAsset() {
  }
}

if (typeof IssueWatcher != "function") {
  function IssueWatcher() {
  }
}

if (typeof ParkingMultitype != "function") {
  function ParkingMultitype() {
  }
}

if (typeof ThUniversityCredit != "function") {
  function ThUniversityCredit() {
  }
}

if (typeof AgendaDatesGeographyNode != "function") {
  function AgendaDatesGeographyNode() {
  }
}

if (typeof AgendaItem != "function") {
  function AgendaItem() {
  }
}

if (typeof Page != "function") {
  function Page() {
  }
}

if (typeof Ad != "function") {
  function Ad() {
  }
}

if (typeof Region != "function") {
  function Region() {
  }
}

if (typeof ListingViewFormat != "function") {
  function ListingViewFormat() {
  }
}

if (typeof DisplayCalendarEvent != "function") {
  function DisplayCalendarEvent() {
  }
}

if (typeof Hotel != "function") {
  function Hotel() {
  }
}

if (typeof MarketRegion != "function") {
  function MarketRegion() {
  }
}

if (typeof AgeSensitiveType != "function") {
  function AgeSensitiveType() {
  }
}

if (typeof LayoutElement != "function") {
  function LayoutElement() {
  }
}

if (typeof RestrictionType != "function") {
  function RestrictionType() {
  }
}

if (typeof SetBatch != "function") {
  function SetBatch() {
  }
}

if (typeof SearchTypeInfo != "function") {
  function SearchTypeInfo() {
  }
}

// Provide a default path to dwr.engine
if (dwr == null) var dwr = {};
if (dwr.engine == null) dwr.engine = {};
if (DWREngine == null) var DWREngine = dwr.engine;

if (AdvertiserService == null) var AdvertiserService = {};
AdvertiserService._path = '/dwr';
AdvertiserService.create = function(p0, callback) {
  dwr.engine._execute(AdvertiserService._path, 'AdvertiserService', 'create', p0, callback);
}
AdvertiserService.update = function(p0, callback) {
  dwr.engine._execute(AdvertiserService._path, 'AdvertiserService', 'update', p0, callback);
}
AdvertiserService.findByName = function(p0, p1, p2, p3, p4, callback) {
  dwr.engine._execute(AdvertiserService._path, 'AdvertiserService', 'findByName', p0, p1, p2, p3, p4, callback);
}
AdvertiserService.findAll = function(callback) {
  dwr.engine._execute(AdvertiserService._path, 'AdvertiserService', 'findAll', callback);
}
AdvertiserService.findAdvertisersByApId = function(p0, callback) {
  dwr.engine._execute(AdvertiserService._path, 'AdvertiserService', 'findAdvertisersByApId', p0, callback);
}
AdvertiserService.findAdvertiserById = function(p0, callback) {
  dwr.engine._execute(AdvertiserService._path, 'AdvertiserService', 'findAdvertiserById', p0, callback);
}
AdvertiserService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(AdvertiserService._path, 'AdvertiserService', 'deleteByIdsNew', p0, callback);
}
AdvertiserService.findById = function(p0, callback) {
  dwr.engine._execute(AdvertiserService._path, 'AdvertiserService', 'findById', p0, callback);
}
AdvertiserService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(AdvertiserService._path, 'AdvertiserService', 'deleteByIds', p0, callback);
}
AdvertiserService.checkAdvertiserFileExistence = function(p0, p1, callback) {
  dwr.engine._execute(AdvertiserService._path, 'AdvertiserService', 'checkAdvertiserFileExistence', p0, p1, callback);
}
AdvertiserService.findAdvertisersByNameForCurrentAp = function(p0, p1, p2, p3, callback) {
  dwr.engine._execute(AdvertiserService._path, 'AdvertiserService', 'findAdvertisersByNameForCurrentAp', p0, p1, p2, p3, callback);
}
if (AgeSensitiveTypeService == null) var AgeSensitiveTypeService = {};
AgeSensitiveTypeService._path = '/dwr';
AgeSensitiveTypeService.create = function(p0, callback) {
  dwr.engine._execute(AgeSensitiveTypeService._path, 'AgeSensitiveTypeService', 'create', p0, callback);
}
AgeSensitiveTypeService.update = function(p0, callback) {
  dwr.engine._execute(AgeSensitiveTypeService._path, 'AgeSensitiveTypeService', 'update', p0, callback);
}
AgeSensitiveTypeService.findAll = function(callback) {
  dwr.engine._execute(AgeSensitiveTypeService._path, 'AgeSensitiveTypeService', 'findAll', callback);
}
AgeSensitiveTypeService.findAssignedIds = function(p0, callback) {
  dwr.engine._execute(AgeSensitiveTypeService._path, 'AgeSensitiveTypeService', 'findAssignedIds', p0, callback);
}
AgeSensitiveTypeService.findAvailable = function(p0, callback) {
  dwr.engine._execute(AgeSensitiveTypeService._path, 'AgeSensitiveTypeService', 'findAvailable', p0, callback);
}
AgeSensitiveTypeService.findAgeSensitiveTypesByName = function(p0, p1, p2, p3, p4, callback) {
  dwr.engine._execute(AgeSensitiveTypeService._path, 'AgeSensitiveTypeService', 'findAgeSensitiveTypesByName', p0, p1, p2, p3, p4, callback);
}
AgeSensitiveTypeService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(AgeSensitiveTypeService._path, 'AgeSensitiveTypeService', 'deleteByIdsNew', p0, callback);
}
AgeSensitiveTypeService.findById = function(p0, callback) {
  dwr.engine._execute(AgeSensitiveTypeService._path, 'AgeSensitiveTypeService', 'findById', p0, callback);
}
AgeSensitiveTypeService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(AgeSensitiveTypeService._path, 'AgeSensitiveTypeService', 'deleteByIds', p0, callback);
}
AgeSensitiveTypeService.assignAgeSensitiveTypes = function(p0, p1, p2, callback) {
  dwr.engine._execute(AgeSensitiveTypeService._path, 'AgeSensitiveTypeService', 'assignAgeSensitiveTypes', p0, p1, p2, callback);
}
if (AdvancedSearchService == null) var AdvancedSearchService = {};
AdvancedSearchService._path = '/dwr';
AdvancedSearchService.findSearchDetails = function(p0, callback) {
  dwr.engine._execute(AdvancedSearchService._path, 'AdvancedSearchService', 'findSearchDetails', p0, callback);
}
AdvancedSearchService.findSearchesForUserAndType = function(p0, callback) {
  dwr.engine._execute(AdvancedSearchService._path, 'AdvancedSearchService', 'findSearchesForUserAndType', p0, callback);
}
AdvancedSearchService.findRefs = function(p0, p1, callback) {
  dwr.engine._execute(AdvancedSearchService._path, 'AdvancedSearchService', 'findRefs', p0, p1, callback);
}
AdvancedSearchService.deleteSearch = function(p0, callback) {
  dwr.engine._execute(AdvancedSearchService._path, 'AdvancedSearchService', 'deleteSearch', p0, callback);
}
AdvancedSearchService.findSearchTypeInfos = function(p0, callback) {
  dwr.engine._execute(AdvancedSearchService._path, 'AdvancedSearchService', 'findSearchTypeInfos', p0, callback);
}
AdvancedSearchService.saveSearch = function(p0, p1, p2, p3, p4, callback) {
  dwr.engine._execute(AdvancedSearchService._path, 'AdvancedSearchService', 'saveSearch', p0, p1, p2, p3, p4, callback);
}
if (AveragePriceTypeService == null) var AveragePriceTypeService = {};
AveragePriceTypeService._path = '/dwr';
AveragePriceTypeService.create = function(p0, callback) {
  dwr.engine._execute(AveragePriceTypeService._path, 'AveragePriceTypeService', 'create', p0, callback);
}
AveragePriceTypeService.update = function(p0, callback) {
  dwr.engine._execute(AveragePriceTypeService._path, 'AveragePriceTypeService', 'update', p0, callback);
}
AveragePriceTypeService.findAll = function(callback) {
  dwr.engine._execute(AveragePriceTypeService._path, 'AveragePriceTypeService', 'findAll', callback);
}
AveragePriceTypeService.findAvailable = function(p0, callback) {
  dwr.engine._execute(AveragePriceTypeService._path, 'AveragePriceTypeService', 'findAvailable', p0, callback);
}
AveragePriceTypeService.findAveragePriceTypesByName = function(p0, p1, p2, p3, p4, callback) {
  dwr.engine._execute(AveragePriceTypeService._path, 'AveragePriceTypeService', 'findAveragePriceTypesByName', p0, p1, p2, p3, p4, callback);
}
AveragePriceTypeService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(AveragePriceTypeService._path, 'AveragePriceTypeService', 'deleteByIdsNew', p0, callback);
}
AveragePriceTypeService.findById = function(p0, callback) {
  dwr.engine._execute(AveragePriceTypeService._path, 'AveragePriceTypeService', 'findById', p0, callback);
}
AveragePriceTypeService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(AveragePriceTypeService._path, 'AveragePriceTypeService', 'deleteByIds', p0, callback);
}
if (BatchEntityService == null) var BatchEntityService = {};
BatchEntityService._path = '/dwr';
BatchEntityService.execute = function(p0, p1, p2, callback) {
  dwr.engine._execute(BatchEntityService._path, 'BatchEntityService', 'execute', p0, p1, p2, callback);
}
if (CategoryService == null) var CategoryService = {};
CategoryService._path = '/dwr';
CategoryService.create = function(p0, callback) {
  dwr.engine._execute(CategoryService._path, 'CategoryService', 'create', p0, callback);
}
CategoryService.update = function(p0, callback) {
  dwr.engine._execute(CategoryService._path, 'CategoryService', 'update', p0, callback);
}
CategoryService.findAll = function(callback) {
  dwr.engine._execute(CategoryService._path, 'CategoryService', 'findAll', callback);
}
CategoryService.findCategoriesByName = function(p0, p1, p2, p3, callback) {
  dwr.engine._execute(CategoryService._path, 'CategoryService', 'findCategoriesByName', p0, p1, p2, p3, callback);
}
CategoryService.findAssignedCategoryIds = function(p0, callback) {
  dwr.engine._execute(CategoryService._path, 'CategoryService', 'findAssignedCategoryIds', p0, callback);
}
CategoryService.findNonEmptyIdNameUrlDtos = function(callback) {
  dwr.engine._execute(CategoryService._path, 'CategoryService', 'findNonEmptyIdNameUrlDtos', callback);
}
CategoryService.findAssignedSubcategoryIds = function(p0, callback) {
  dwr.engine._execute(CategoryService._path, 'CategoryService', 'findAssignedSubcategoryIds', p0, callback);
}
CategoryService.isCategoryUrlUnique = function(p0, p1, callback) {
  dwr.engine._execute(CategoryService._path, 'CategoryService', 'isCategoryUrlUnique', p0, p1, callback);
}
CategoryService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(CategoryService._path, 'CategoryService', 'deleteByIdsNew', p0, callback);
}
CategoryService.findById = function(p0, callback) {
  dwr.engine._execute(CategoryService._path, 'CategoryService', 'findById', p0, callback);
}
CategoryService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(CategoryService._path, 'CategoryService', 'deleteByIds', p0, callback);
}
CategoryService.findAllWithAll = function(callback) {
  dwr.engine._execute(CategoryService._path, 'CategoryService', 'findAllWithAll', callback);
}
CategoryService.findCategoriesWithAll = function(p0, p1, p2, p3, p4, callback) {
  dwr.engine._execute(CategoryService._path, 'CategoryService', 'findCategoriesWithAll', p0, p1, p2, p3, p4, callback);
}
CategoryService.assignCategories = function(p0, p1, p2, callback) {
  dwr.engine._execute(CategoryService._path, 'CategoryService', 'assignCategories', p0, p1, p2, callback);
}
if (ClubAffiliationService == null) var ClubAffiliationService = {};
ClubAffiliationService._path = '/dwr';
ClubAffiliationService.create = function(p0, callback) {
  dwr.engine._execute(ClubAffiliationService._path, 'ClubAffiliationService', 'create', p0, callback);
}
ClubAffiliationService.update = function(p0, callback) {
  dwr.engine._execute(ClubAffiliationService._path, 'ClubAffiliationService', 'update', p0, callback);
}
ClubAffiliationService.findAll = function(callback) {
  dwr.engine._execute(ClubAffiliationService._path, 'ClubAffiliationService', 'findAll', callback);
}
ClubAffiliationService.findAssignedIds = function(p0, callback) {
  dwr.engine._execute(ClubAffiliationService._path, 'ClubAffiliationService', 'findAssignedIds', p0, callback);
}
ClubAffiliationService.findAvailable = function(p0, callback) {
  dwr.engine._execute(ClubAffiliationService._path, 'ClubAffiliationService', 'findAvailable', p0, callback);
}
ClubAffiliationService.findClubAffiliationsByName = function(p0, p1, p2, p3, p4, callback) {
  dwr.engine._execute(ClubAffiliationService._path, 'ClubAffiliationService', 'findClubAffiliationsByName', p0, p1, p2, p3, p4, callback);
}
ClubAffiliationService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(ClubAffiliationService._path, 'ClubAffiliationService', 'deleteByIdsNew', p0, callback);
}
ClubAffiliationService.findById = function(p0, callback) {
  dwr.engine._execute(ClubAffiliationService._path, 'ClubAffiliationService', 'findById', p0, callback);
}
ClubAffiliationService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(ClubAffiliationService._path, 'ClubAffiliationService', 'deleteByIds', p0, callback);
}
ClubAffiliationService.assignClubAffiliations = function(p0, p1, p2, callback) {
  dwr.engine._execute(ClubAffiliationService._path, 'ClubAffiliationService', 'assignClubAffiliations', p0, p1, p2, callback);
}
if (ContactUsInfoService == null) var ContactUsInfoService = {};
ContactUsInfoService._path = '/dwr';
ContactUsInfoService.create = function(p0, callback) {
  dwr.engine._execute(ContactUsInfoService._path, 'ContactUsInfoService', 'create', p0, callback);
}
ContactUsInfoService.update = function(p0, callback) {
  dwr.engine._execute(ContactUsInfoService._path, 'ContactUsInfoService', 'update', p0, callback);
}
ContactUsInfoService.findAll = function(callback) {
  dwr.engine._execute(ContactUsInfoService._path, 'ContactUsInfoService', 'findAll', callback);
}
ContactUsInfoService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(ContactUsInfoService._path, 'ContactUsInfoService', 'deleteByIdsNew', p0, callback);
}
ContactUsInfoService.findById = function(p0, callback) {
  dwr.engine._execute(ContactUsInfoService._path, 'ContactUsInfoService', 'findById', p0, callback);
}
ContactUsInfoService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(ContactUsInfoService._path, 'ContactUsInfoService', 'deleteByIds', p0, callback);
}
if (DressCodeTypeService == null) var DressCodeTypeService = {};
DressCodeTypeService._path = '/dwr';
DressCodeTypeService.create = function(p0, callback) {
  dwr.engine._execute(DressCodeTypeService._path, 'DressCodeTypeService', 'create', p0, callback);
}
DressCodeTypeService.update = function(p0, callback) {
  dwr.engine._execute(DressCodeTypeService._path, 'DressCodeTypeService', 'update', p0, callback);
}
DressCodeTypeService.findAll = function(callback) {
  dwr.engine._execute(DressCodeTypeService._path, 'DressCodeTypeService', 'findAll', callback);
}
DressCodeTypeService.findAssignedIds = function(p0, callback) {
  dwr.engine._execute(DressCodeTypeService._path, 'DressCodeTypeService', 'findAssignedIds', p0, callback);
}
DressCodeTypeService.findAvailable = function(p0, callback) {
  dwr.engine._execute(DressCodeTypeService._path, 'DressCodeTypeService', 'findAvailable', p0, callback);
}
DressCodeTypeService.findDressCodeTypesByName = function(p0, p1, p2, p3, p4, callback) {
  dwr.engine._execute(DressCodeTypeService._path, 'DressCodeTypeService', 'findDressCodeTypesByName', p0, p1, p2, p3, p4, callback);
}
DressCodeTypeService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(DressCodeTypeService._path, 'DressCodeTypeService', 'deleteByIdsNew', p0, callback);
}
DressCodeTypeService.findById = function(p0, callback) {
  dwr.engine._execute(DressCodeTypeService._path, 'DressCodeTypeService', 'findById', p0, callback);
}
DressCodeTypeService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(DressCodeTypeService._path, 'DressCodeTypeService', 'deleteByIds', p0, callback);
}
DressCodeTypeService.assignDressCodeTypes = function(p0, p1, p2, callback) {
  dwr.engine._execute(DressCodeTypeService._path, 'DressCodeTypeService', 'assignDressCodeTypes', p0, p1, p2, callback);
}
if (FeatureTypeService == null) var FeatureTypeService = {};
FeatureTypeService._path = '/dwr';
FeatureTypeService.create = function(p0, callback) {
  dwr.engine._execute(FeatureTypeService._path, 'FeatureTypeService', 'create', p0, callback);
}
FeatureTypeService.update = function(p0, callback) {
  dwr.engine._execute(FeatureTypeService._path, 'FeatureTypeService', 'update', p0, callback);
}
FeatureTypeService.findAll = function(callback) {
  dwr.engine._execute(FeatureTypeService._path, 'FeatureTypeService', 'findAll', callback);
}
FeatureTypeService.findAssignedIds = function(p0, callback) {
  dwr.engine._execute(FeatureTypeService._path, 'FeatureTypeService', 'findAssignedIds', p0, callback);
}
FeatureTypeService.findAvailable = function(p0, callback) {
  dwr.engine._execute(FeatureTypeService._path, 'FeatureTypeService', 'findAvailable', p0, callback);
}
FeatureTypeService.findFeatureTypesByName = function(p0, p1, p2, p3, p4, callback) {
  dwr.engine._execute(FeatureTypeService._path, 'FeatureTypeService', 'findFeatureTypesByName', p0, p1, p2, p3, p4, callback);
}
FeatureTypeService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(FeatureTypeService._path, 'FeatureTypeService', 'deleteByIdsNew', p0, callback);
}
FeatureTypeService.findById = function(p0, callback) {
  dwr.engine._execute(FeatureTypeService._path, 'FeatureTypeService', 'findById', p0, callback);
}
FeatureTypeService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(FeatureTypeService._path, 'FeatureTypeService', 'deleteByIds', p0, callback);
}
FeatureTypeService.assignFeatureTypes = function(p0, p1, p2, callback) {
  dwr.engine._execute(FeatureTypeService._path, 'FeatureTypeService', 'assignFeatureTypes', p0, p1, p2, callback);
}
if (GeographyService == null) var GeographyService = {};
GeographyService._path = '/dwr';
GeographyService.create = function(p0, callback) {
  dwr.engine._execute(GeographyService._path, 'GeographyService', 'create', p0, callback);
}
GeographyService.update = function(p0, callback) {
  dwr.engine._execute(GeographyService._path, 'GeographyService', 'update', p0, callback);
}
GeographyService.findChildren = function(p0, callback) {
  dwr.engine._execute(GeographyService._path, 'GeographyService', 'findChildren', p0, callback);
}
GeographyService.findByName = function(p0, callback) {
  dwr.engine._execute(GeographyService._path, 'GeographyService', 'findByName', p0, callback);
}
GeographyService.findAssignedGeographyNodes = function(p0, callback) {
  dwr.engine._execute(GeographyService._path, 'GeographyService', 'findAssignedGeographyNodes', p0, callback);
}
GeographyService.findListingGeographyNodes = function(p0, callback) {
  dwr.engine._execute(GeographyService._path, 'GeographyService', 'findListingGeographyNodes', p0, callback);
}
GeographyService.findNodes = function(p0, callback) {
  dwr.engine._execute(GeographyService._path, 'GeographyService', 'findNodes', p0, callback);
}
GeographyService.findPhoneNumberFormat = function(p0, callback) {
  dwr.engine._execute(GeographyService._path, 'GeographyService', 'findPhoneNumberFormat', p0, callback);
}
GeographyService.findCountryByAbbreviation = function(p0, callback) {
  dwr.engine._execute(GeographyService._path, 'GeographyService', 'findCountryByAbbreviation', p0, callback);
}
GeographyService.findAll = function(callback) {
  dwr.engine._execute(GeographyService._path, 'GeographyService', 'findAll', callback);
}
GeographyService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(GeographyService._path, 'GeographyService', 'deleteByIdsNew', p0, callback);
}
GeographyService.findById = function(p0, callback) {
  dwr.engine._execute(GeographyService._path, 'GeographyService', 'findById', p0, callback);
}
GeographyService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(GeographyService._path, 'GeographyService', 'deleteByIds', p0, callback);
}
GeographyService.getAbbreviation = function(p0, p1, callback) {
  dwr.engine._execute(GeographyService._path, 'GeographyService', 'getAbbreviation', p0, p1, callback);
}
GeographyService.findAllCountries = function(p0, p1, p2, callback) {
  dwr.engine._execute(GeographyService._path, 'GeographyService', 'findAllCountries', p0, p1, p2, callback);
}
GeographyService.findAllCountriesList = function(callback) {
  dwr.engine._execute(GeographyService._path, 'GeographyService', 'findAllCountriesList', callback);
}
GeographyService.findCountryStates = function(p0, callback) {
  dwr.engine._execute(GeographyService._path, 'GeographyService', 'findCountryStates', p0, callback);
}
GeographyService.getNodeTreePath = function(p0, callback) {
  dwr.engine._execute(GeographyService._path, 'GeographyService', 'getNodeTreePath', p0, callback);
}
GeographyService.createGeoObject = function(p0, p1, p2, callback) {
  dwr.engine._execute(GeographyService._path, 'GeographyService', 'createGeoObject', p0, p1, p2, callback);
}
GeographyService.updateGeoObject = function(p0, p1, p2, callback) {
  dwr.engine._execute(GeographyService._path, 'GeographyService', 'updateGeoObject', p0, p1, p2, callback);
}
GeographyService.deleteBranches = function(p0, callback) {
  dwr.engine._execute(GeographyService._path, 'GeographyService', 'deleteBranches', p0, callback);
}
GeographyService.assignMarketGeographies = function(p0, p1, p2, callback) {
  dwr.engine._execute(GeographyService._path, 'GeographyService', 'assignMarketGeographies', p0, p1, p2, callback);
}
GeographyService.assignListingGeographies = function(p0, p1, p2, callback) {
  dwr.engine._execute(GeographyService._path, 'GeographyService', 'assignListingGeographies', p0, p1, p2, callback);
}
GeographyService.moveNodes = function(p0, p1, callback) {
  dwr.engine._execute(GeographyService._path, 'GeographyService', 'moveNodes', p0, p1, callback);
}
if (HotelService == null) var HotelService = {};
HotelService._path = '/dwr';
HotelService.create = function(p0, callback) {
  dwr.engine._execute(HotelService._path, 'HotelService', 'create', p0, callback);
}
HotelService.update = function(p0, callback) {
  dwr.engine._execute(HotelService._path, 'HotelService', 'update', p0, callback);
}
HotelService.findByName = function(p0, p1, p2, p3, p4, callback) {
  dwr.engine._execute(HotelService._path, 'HotelService', 'findByName', p0, p1, p2, p3, p4, callback);
}
HotelService.findAll = function(callback) {
  dwr.engine._execute(HotelService._path, 'HotelService', 'findAll', callback);
}
HotelService.findByMarketId = function(p0, p1, p2, p3, p4, callback) {
  dwr.engine._execute(HotelService._path, 'HotelService', 'findByMarketId', p0, p1, p2, p3, p4, callback);
}
HotelService.findListingNameByHotelId = function(p0, callback) {
  dwr.engine._execute(HotelService._path, 'HotelService', 'findListingNameByHotelId', p0, callback);
}
HotelService.findHotelByListingId = function(p0, callback) {
  dwr.engine._execute(HotelService._path, 'HotelService', 'findHotelByListingId', p0, callback);
}
HotelService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(HotelService._path, 'HotelService', 'deleteByIdsNew', p0, callback);
}
HotelService.findById = function(p0, callback) {
  dwr.engine._execute(HotelService._path, 'HotelService', 'findById', p0, callback);
}
HotelService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(HotelService._path, 'HotelService', 'deleteByIds', p0, callback);
}
HotelService.assignHotel = function(p0, p1, p2, callback) {
  dwr.engine._execute(HotelService._path, 'HotelService', 'assignHotel', p0, p1, p2, callback);
}
if (IndustryCategoryService == null) var IndustryCategoryService = {};
IndustryCategoryService._path = '/dwr';
IndustryCategoryService.create = function(p0, callback) {
  dwr.engine._execute(IndustryCategoryService._path, 'IndustryCategoryService', 'create', p0, callback);
}
IndustryCategoryService.update = function(p0, callback) {
  dwr.engine._execute(IndustryCategoryService._path, 'IndustryCategoryService', 'update', p0, callback);
}
IndustryCategoryService.findAll = function(callback) {
  dwr.engine._execute(IndustryCategoryService._path, 'IndustryCategoryService', 'findAll', callback);
}
IndustryCategoryService.findAssignedIds = function(p0, callback) {
  dwr.engine._execute(IndustryCategoryService._path, 'IndustryCategoryService', 'findAssignedIds', p0, callback);
}
IndustryCategoryService.findAvailable = function(p0, callback) {
  dwr.engine._execute(IndustryCategoryService._path, 'IndustryCategoryService', 'findAvailable', p0, callback);
}
IndustryCategoryService.findIndustryCategoriesByName = function(p0, p1, p2, p3, p4, callback) {
  dwr.engine._execute(IndustryCategoryService._path, 'IndustryCategoryService', 'findIndustryCategoriesByName', p0, p1, p2, p3, p4, callback);
}
IndustryCategoryService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(IndustryCategoryService._path, 'IndustryCategoryService', 'deleteByIdsNew', p0, callback);
}
IndustryCategoryService.findById = function(p0, callback) {
  dwr.engine._execute(IndustryCategoryService._path, 'IndustryCategoryService', 'findById', p0, callback);
}
IndustryCategoryService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(IndustryCategoryService._path, 'IndustryCategoryService', 'deleteByIds', p0, callback);
}
IndustryCategoryService.assignIndustryCategories = function(p0, p1, p2, callback) {
  dwr.engine._execute(IndustryCategoryService._path, 'IndustryCategoryService', 'assignIndustryCategories', p0, p1, p2, callback);
}
if (ListingService == null) var ListingService = {};
ListingService._path = '/dwr';
ListingService.create = function(p0, callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'create', p0, callback);
}
ListingService.update = function(p0, callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'update', p0, callback);
}
ListingService.findAll = function(callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'findAll', callback);
}
ListingService.findListingNameByHotelId = function(p0, callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'findListingNameByHotelId', p0, callback);
}
ListingService.findListingsByName = function(p0, p1, p2, p3, p4, callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'findListingsByName', p0, p1, p2, p3, p4, callback);
}
ListingService.findListingsByParams = function(p0, p1, p2, p3, callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'findListingsByParams', p0, p1, p2, p3, callback);
}
ListingService.findListingsByAp = function(p0, callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'findListingsByAp', p0, callback);
}
ListingService.findListingsByClientId = function(p0, p1, p2, p3, p4, callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'findListingsByClientId', p0, p1, p2, p3, p4, callback);
}
ListingService.findNameByAdId = function(p0, callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'findNameByAdId', p0, callback);
}
ListingService.findListingNameByEventId = function(p0, callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'findListingNameByEventId', p0, callback);
}
ListingService.findListingNameByListingId = function(p0, callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'findListingNameByListingId', p0, callback);
}
ListingService.findClientListings = function(callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'findClientListings', callback);
}
ListingService.findCustomListingDtos = function(p0, p1, p2, p3, callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'findCustomListingDtos', p0, p1, p2, p3, callback);
}
ListingService.isListingUrlUnique = function(p0, p1, p2, callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'isListingUrlUnique', p0, p1, p2, callback);
}
ListingService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'deleteByIdsNew', p0, callback);
}
ListingService.findById = function(p0, callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'findById', p0, callback);
}
ListingService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'deleteByIds', p0, callback);
}
ListingService.checkListingModifiable = function(p0, callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'checkListingModifiable', p0, callback);
}
ListingService.findListingDtosByNameForCurrentAp = function(p0, p1, p2, p3, callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'findListingDtosByNameForCurrentAp', p0, p1, p2, p3, callback);
}
ListingService.findEventDtosByNameForCurrentAp = function(p0, p1, p2, p3, callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'findEventDtosByNameForCurrentAp', p0, p1, p2, p3, callback);
}
ListingService.findListingDtosByCriteriaForCurrentAp = function(p0, p1, p2, p3, callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'findListingDtosByCriteriaForCurrentAp', p0, p1, p2, p3, callback);
}
ListingService.findEventDtosByCriteriaForCurrentAp = function(p0, p1, p2, p3, callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'findEventDtosByCriteriaForCurrentAp', p0, p1, p2, p3, callback);
}
ListingService.removeImage = function(p0, callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'removeImage', p0, callback);
}
ListingService.findListingsForCurrentAp = function(p0, p1, p2, p3, callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'findListingsForCurrentAp', p0, p1, p2, p3, callback);
}
ListingService.findVenueNameAndAddress = function(p0, callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'findVenueNameAndAddress', p0, callback);
}
ListingService.findMyListings = function(p0, p1, p2, p3, p4, callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'findMyListings', p0, p1, p2, p3, p4, callback);
}
ListingService.copyListing = function(p0, callback) {
  dwr.engine._execute(ListingService._path, 'ListingService', 'copyListing', p0, callback);
}
if (MarketService == null) var MarketService = {};
MarketService._path = '/dwr';
MarketService.create = function(p0, callback) {
  dwr.engine._execute(MarketService._path, 'MarketService', 'create', p0, callback);
}
MarketService.update = function(p0, callback) {
  dwr.engine._execute(MarketService._path, 'MarketService', 'update', p0, callback);
}
MarketService.findAll = function(callback) {
  dwr.engine._execute(MarketService._path, 'MarketService', 'findAll', callback);
}
MarketService.findMarketsByName = function(p0, p1, p2, p3, callback) {
  dwr.engine._execute(MarketService._path, 'MarketService', 'findMarketsByName', p0, p1, p2, p3, callback);
}
MarketService.findMarketsByCity = function(p0, p1, p2, p3, callback) {
  dwr.engine._execute(MarketService._path, 'MarketService', 'findMarketsByCity', p0, p1, p2, p3, callback);
}
MarketService.findIdAndName = function(callback) {
  dwr.engine._execute(MarketService._path, 'MarketService', 'findIdAndName', callback);
}
MarketService.findIdNameUrl = function(callback) {
  dwr.engine._execute(MarketService._path, 'MarketService', 'findIdNameUrl', callback);
}
MarketService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(MarketService._path, 'MarketService', 'deleteByIdsNew', p0, callback);
}
MarketService.findById = function(p0, callback) {
  dwr.engine._execute(MarketService._path, 'MarketService', 'findById', p0, callback);
}
MarketService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(MarketService._path, 'MarketService', 'deleteByIds', p0, callback);
}
MarketService.findMarketsByApId = function(p0, callback) {
  dwr.engine._execute(MarketService._path, 'MarketService', 'findMarketsByApId', p0, callback);
}
MarketService.findMarketsForCurrentAp = function(callback) {
  dwr.engine._execute(MarketService._path, 'MarketService', 'findMarketsForCurrentAp', callback);
}
MarketService.changeCurrentMarketId = function(p0, callback) {
  dwr.engine._execute(MarketService._path, 'MarketService', 'changeCurrentMarketId', p0, callback);
}
MarketService.changeCurrentMarketIdByName = function(p0, callback) {
  dwr.engine._execute(MarketService._path, 'MarketService', 'changeCurrentMarketIdByName', p0, callback);
}
MarketService.changeCurrentMarketIdByUrl = function(p0, callback) {
  dwr.engine._execute(MarketService._path, 'MarketService', 'changeCurrentMarketIdByUrl', p0, callback);
}
MarketService.findMarketsForCurrentAdvertiser = function(callback) {
  dwr.engine._execute(MarketService._path, 'MarketService', 'findMarketsForCurrentAdvertiser', callback);
}
if (MemberService == null) var MemberService = {};
MemberService._path = '/dwr';
MemberService.create = function(p0, callback) {
  dwr.engine._execute(MemberService._path, 'MemberService', 'create', p0, callback);
}
MemberService.update = function(p0, callback) {
  dwr.engine._execute(MemberService._path, 'MemberService', 'update', p0, callback);
}
MemberService.findAll = function(callback) {
  dwr.engine._execute(MemberService._path, 'MemberService', 'findAll', callback);
}
MemberService.findProxyLogonUsers = function(callback) {
  dwr.engine._execute(MemberService._path, 'MemberService', 'findProxyLogonUsers', callback);
}
MemberService.findUserDtosByCriteria = function(p0, p1, p2, p3, callback) {
  dwr.engine._execute(MemberService._path, 'MemberService', 'findUserDtosByCriteria', p0, p1, p2, p3, callback);
}
MemberService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(MemberService._path, 'MemberService', 'deleteByIdsNew', p0, callback);
}
MemberService.findById = function(p0, callback) {
  dwr.engine._execute(MemberService._path, 'MemberService', 'findById', p0, callback);
}
MemberService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(MemberService._path, 'MemberService', 'deleteByIds', p0, callback);
}
MemberService.getSourceLogon = function(callback) {
  dwr.engine._execute(MemberService._path, 'MemberService', 'getSourceLogon', callback);
}
MemberService.changePassword = function(p0, p1, callback) {
  dwr.engine._execute(MemberService._path, 'MemberService', 'changePassword', p0, p1, callback);
}
MemberService.refreshSession = function(callback) {
  dwr.engine._execute(MemberService._path, 'MemberService', 'refreshSession', callback);
}
MemberService.validateUser = function(p0, callback) {
  dwr.engine._execute(MemberService._path, 'MemberService', 'validateUser', p0, callback);
}
MemberService.findUsersToChangePassword = function(callback) {
  dwr.engine._execute(MemberService._path, 'MemberService', 'findUsersToChangePassword', callback);
}
MemberService.getCurrentUserProfileData = function(callback) {
  dwr.engine._execute(MemberService._path, 'MemberService', 'getCurrentUserProfileData', callback);
}
MemberService.remindLogon = function(p0, p1, callback) {
  dwr.engine._execute(MemberService._path, 'MemberService', 'remindLogon', p0, p1, callback);
}
MemberService.remindPassword = function(p0, callback) {
  dwr.engine._execute(MemberService._path, 'MemberService', 'remindPassword', p0, callback);
}
MemberService.createPassword = function(p0, p1, callback) {
  dwr.engine._execute(MemberService._path, 'MemberService', 'createPassword', p0, p1, callback);
}
MemberService.deactivate = function(callback) {
  dwr.engine._execute(MemberService._path, 'MemberService', 'deactivate', false, callback);
}
if (OperatingHoursService == null) var OperatingHoursService = {};
OperatingHoursService._path = '/dwr';
OperatingHoursService.findAll = function(callback) {
  dwr.engine._execute(OperatingHoursService._path, 'OperatingHoursService', 'findAll', callback);
}
OperatingHoursService.findOperatingHoursByListingId = function(p0, callback) {
  dwr.engine._execute(OperatingHoursService._path, 'OperatingHoursService', 'findOperatingHoursByListingId', p0, callback);
}
OperatingHoursService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(OperatingHoursService._path, 'OperatingHoursService', 'deleteByIdsNew', p0, callback);
}
OperatingHoursService.findById = function(p0, callback) {
  dwr.engine._execute(OperatingHoursService._path, 'OperatingHoursService', 'findById', p0, callback);
}
OperatingHoursService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(OperatingHoursService._path, 'OperatingHoursService', 'deleteByIds', p0, callback);
}
if (ParkingMultitypeService == null) var ParkingMultitypeService = {};
ParkingMultitypeService._path = '/dwr';
ParkingMultitypeService.create = function(p0, callback) {
  dwr.engine._execute(ParkingMultitypeService._path, 'ParkingMultitypeService', 'create', p0, callback);
}
ParkingMultitypeService.update = function(p0, callback) {
  dwr.engine._execute(ParkingMultitypeService._path, 'ParkingMultitypeService', 'update', p0, callback);
}
ParkingMultitypeService.findAll = function(callback) {
  dwr.engine._execute(ParkingMultitypeService._path, 'ParkingMultitypeService', 'findAll', callback);
}
ParkingMultitypeService.findAssignedIds = function(p0, callback) {
  dwr.engine._execute(ParkingMultitypeService._path, 'ParkingMultitypeService', 'findAssignedIds', p0, callback);
}
ParkingMultitypeService.findAvailable = function(p0, callback) {
  dwr.engine._execute(ParkingMultitypeService._path, 'ParkingMultitypeService', 'findAvailable', p0, callback);
}
ParkingMultitypeService.findParkingMultitypesByName = function(p0, p1, p2, p3, p4, callback) {
  dwr.engine._execute(ParkingMultitypeService._path, 'ParkingMultitypeService', 'findParkingMultitypesByName', p0, p1, p2, p3, p4, callback);
}
ParkingMultitypeService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(ParkingMultitypeService._path, 'ParkingMultitypeService', 'deleteByIdsNew', p0, callback);
}
ParkingMultitypeService.findById = function(p0, callback) {
  dwr.engine._execute(ParkingMultitypeService._path, 'ParkingMultitypeService', 'findById', p0, callback);
}
ParkingMultitypeService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(ParkingMultitypeService._path, 'ParkingMultitypeService', 'deleteByIds', p0, callback);
}
ParkingMultitypeService.assignParkingMultitypes = function(p0, p1, p2, callback) {
  dwr.engine._execute(ParkingMultitypeService._path, 'ParkingMultitypeService', 'assignParkingMultitypes', p0, p1, p2, callback);
}
if (PaymentTypeService == null) var PaymentTypeService = {};
PaymentTypeService._path = '/dwr';
PaymentTypeService.create = function(p0, callback) {
  dwr.engine._execute(PaymentTypeService._path, 'PaymentTypeService', 'create', p0, callback);
}
PaymentTypeService.update = function(p0, callback) {
  dwr.engine._execute(PaymentTypeService._path, 'PaymentTypeService', 'update', p0, callback);
}
PaymentTypeService.findAll = function(callback) {
  dwr.engine._execute(PaymentTypeService._path, 'PaymentTypeService', 'findAll', callback);
}
PaymentTypeService.findAssignedIds = function(p0, callback) {
  dwr.engine._execute(PaymentTypeService._path, 'PaymentTypeService', 'findAssignedIds', p0, callback);
}
PaymentTypeService.findAvailable = function(p0, callback) {
  dwr.engine._execute(PaymentTypeService._path, 'PaymentTypeService', 'findAvailable', p0, callback);
}
PaymentTypeService.findPaymentTypesByName = function(p0, p1, p2, p3, p4, callback) {
  dwr.engine._execute(PaymentTypeService._path, 'PaymentTypeService', 'findPaymentTypesByName', p0, p1, p2, p3, p4, callback);
}
PaymentTypeService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(PaymentTypeService._path, 'PaymentTypeService', 'deleteByIdsNew', p0, callback);
}
PaymentTypeService.findById = function(p0, callback) {
  dwr.engine._execute(PaymentTypeService._path, 'PaymentTypeService', 'findById', p0, callback);
}
PaymentTypeService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(PaymentTypeService._path, 'PaymentTypeService', 'deleteByIds', p0, callback);
}
PaymentTypeService.assignPaymentTypes = function(p0, p1, p2, callback) {
  dwr.engine._execute(PaymentTypeService._path, 'PaymentTypeService', 'assignPaymentTypes', p0, p1, p2, callback);
}
if (PdfService == null) var PdfService = {};
PdfService._path = '/dwr';
PdfService.generateIssuePreview = function(p0, p1, callback) {
  dwr.engine._execute(PdfService._path, 'PdfService', 'generateIssuePreview', p0, p1, callback);
}
PdfService.checkLastLineLength = function(p0, p1, callback) {
  dwr.engine._execute(PdfService._path, 'PdfService', 'checkLastLineLength', p0, p1, callback);
}
PdfService.checkEventDescriptionLength = function(p0, callback) {
  dwr.engine._execute(PdfService._path, 'PdfService', 'checkEventDescriptionLength', p0, callback);
}
if (PhysicalRequirementTypeService == null) var PhysicalRequirementTypeService = {};
PhysicalRequirementTypeService._path = '/dwr';
PhysicalRequirementTypeService.create = function(p0, callback) {
  dwr.engine._execute(PhysicalRequirementTypeService._path, 'PhysicalRequirementTypeService', 'create', p0, callback);
}
PhysicalRequirementTypeService.update = function(p0, callback) {
  dwr.engine._execute(PhysicalRequirementTypeService._path, 'PhysicalRequirementTypeService', 'update', p0, callback);
}
PhysicalRequirementTypeService.findAll = function(callback) {
  dwr.engine._execute(PhysicalRequirementTypeService._path, 'PhysicalRequirementTypeService', 'findAll', callback);
}
PhysicalRequirementTypeService.findAssignedIds = function(p0, callback) {
  dwr.engine._execute(PhysicalRequirementTypeService._path, 'PhysicalRequirementTypeService', 'findAssignedIds', p0, callback);
}
PhysicalRequirementTypeService.findAvailable = function(p0, callback) {
  dwr.engine._execute(PhysicalRequirementTypeService._path, 'PhysicalRequirementTypeService', 'findAvailable', p0, callback);
}
PhysicalRequirementTypeService.findPhysicalRequirementTypesByName = function(p0, p1, p2, p3, p4, callback) {
  dwr.engine._execute(PhysicalRequirementTypeService._path, 'PhysicalRequirementTypeService', 'findPhysicalRequirementTypesByName', p0, p1, p2, p3, p4, callback);
}
PhysicalRequirementTypeService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(PhysicalRequirementTypeService._path, 'PhysicalRequirementTypeService', 'deleteByIdsNew', p0, callback);
}
PhysicalRequirementTypeService.findById = function(p0, callback) {
  dwr.engine._execute(PhysicalRequirementTypeService._path, 'PhysicalRequirementTypeService', 'findById', p0, callback);
}
PhysicalRequirementTypeService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(PhysicalRequirementTypeService._path, 'PhysicalRequirementTypeService', 'deleteByIds', p0, callback);
}
PhysicalRequirementTypeService.assignPhysicalRequirementTypes = function(p0, p1, p2, callback) {
  dwr.engine._execute(PhysicalRequirementTypeService._path, 'PhysicalRequirementTypeService', 'assignPhysicalRequirementTypes', p0, p1, p2, callback);
}
if (PlaceholderService == null) var PlaceholderService = {};
PlaceholderService._path = '/dwr';
PlaceholderService.create = function(p0, callback) {
  dwr.engine._execute(PlaceholderService._path, 'PlaceholderService', 'create', p0, callback);
}
PlaceholderService.update = function(p0, callback) {
  dwr.engine._execute(PlaceholderService._path, 'PlaceholderService', 'update', p0, callback);
}
PlaceholderService.findAll = function(callback) {
  dwr.engine._execute(PlaceholderService._path, 'PlaceholderService', 'findAll', callback);
}
PlaceholderService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(PlaceholderService._path, 'PlaceholderService', 'deleteByIdsNew', p0, callback);
}
PlaceholderService.findById = function(p0, callback) {
  dwr.engine._execute(PlaceholderService._path, 'PlaceholderService', 'findById', p0, callback);
}
PlaceholderService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(PlaceholderService._path, 'PlaceholderService', 'deleteByIds', p0, callback);
}
if (ProductTypeService == null) var ProductTypeService = {};
ProductTypeService._path = '/dwr';
ProductTypeService.create = function(p0, callback) {
  dwr.engine._execute(ProductTypeService._path, 'ProductTypeService', 'create', p0, callback);
}
ProductTypeService.update = function(p0, callback) {
  dwr.engine._execute(ProductTypeService._path, 'ProductTypeService', 'update', p0, callback);
}
ProductTypeService.findAll = function(callback) {
  dwr.engine._execute(ProductTypeService._path, 'ProductTypeService', 'findAll', callback);
}
ProductTypeService.findAssignedIds = function(p0, callback) {
  dwr.engine._execute(ProductTypeService._path, 'ProductTypeService', 'findAssignedIds', p0, callback);
}
ProductTypeService.findAvailable = function(p0, callback) {
  dwr.engine._execute(ProductTypeService._path, 'ProductTypeService', 'findAvailable', p0, callback);
}
ProductTypeService.findProductTypesByName = function(p0, p1, p2, p3, p4, callback) {
  dwr.engine._execute(ProductTypeService._path, 'ProductTypeService', 'findProductTypesByName', p0, p1, p2, p3, p4, callback);
}
ProductTypeService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(ProductTypeService._path, 'ProductTypeService', 'deleteByIdsNew', p0, callback);
}
ProductTypeService.findById = function(p0, callback) {
  dwr.engine._execute(ProductTypeService._path, 'ProductTypeService', 'findById', p0, callback);
}
ProductTypeService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(ProductTypeService._path, 'ProductTypeService', 'deleteByIds', p0, callback);
}
ProductTypeService.assignProductTypes = function(p0, p1, p2, callback) {
  dwr.engine._execute(ProductTypeService._path, 'ProductTypeService', 'assignProductTypes', p0, p1, p2, callback);
}
if (PublicSiteService == null) var PublicSiteService = {};
PublicSiteService._path = '/dwr';
PublicSiteService.create = function(p0, callback) {
  dwr.engine._execute(PublicSiteService._path, 'PublicSiteService', 'create', p0, callback);
}
PublicSiteService.update = function(p0, callback) {
  dwr.engine._execute(PublicSiteService._path, 'PublicSiteService', 'update', p0, callback);
}
PublicSiteService.findAll = function(callback) {
  dwr.engine._execute(PublicSiteService._path, 'PublicSiteService', 'findAll', callback);
}
PublicSiteService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(PublicSiteService._path, 'PublicSiteService', 'deleteByIdsNew', p0, callback);
}
PublicSiteService.findById = function(p0, callback) {
  dwr.engine._execute(PublicSiteService._path, 'PublicSiteService', 'findById', p0, callback);
}
PublicSiteService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(PublicSiteService._path, 'PublicSiteService', 'deleteByIds', p0, callback);
}
PublicSiteService.getPageBg = function(callback) {
  dwr.engine._execute(PublicSiteService._path, 'PublicSiteService', 'getPageBg', callback);
}
PublicSiteService.getFooterBg = function(callback) {
  dwr.engine._execute(PublicSiteService._path, 'PublicSiteService', 'getFooterBg', callback);
}
PublicSiteService.saveSiteStyle = function(p0, p1, callback) {
  dwr.engine._execute(PublicSiteService._path, 'PublicSiteService', 'saveSiteStyle', p0, p1, callback);
}
if (PublicUserPreferencesService == null) var PublicUserPreferencesService = {};
PublicUserPreferencesService._path = '/dwr';
PublicUserPreferencesService.getMarketId = function(callback) {
  dwr.engine._execute(PublicUserPreferencesService._path, 'PublicUserPreferencesService', 'getMarketId', callback);
}
PublicUserPreferencesService.changeMarketByUrl = function(p0, callback) {
  dwr.engine._execute(PublicUserPreferencesService._path, 'PublicUserPreferencesService', 'changeMarketByUrl', p0, callback);
}
PublicUserPreferencesService.changeMarketById = function(p0, callback) {
  dwr.engine._execute(PublicUserPreferencesService._path, 'PublicUserPreferencesService', 'changeMarketById', p0, callback);
}
if (ReservationTypeService == null) var ReservationTypeService = {};
ReservationTypeService._path = '/dwr';
ReservationTypeService.create = function(p0, callback) {
  dwr.engine._execute(ReservationTypeService._path, 'ReservationTypeService', 'create', p0, callback);
}
ReservationTypeService.update = function(p0, callback) {
  dwr.engine._execute(ReservationTypeService._path, 'ReservationTypeService', 'update', p0, callback);
}
ReservationTypeService.findAll = function(callback) {
  dwr.engine._execute(ReservationTypeService._path, 'ReservationTypeService', 'findAll', callback);
}
ReservationTypeService.findReservationTypesByName = function(p0, p1, p2, p3, p4, callback) {
  dwr.engine._execute(ReservationTypeService._path, 'ReservationTypeService', 'findReservationTypesByName', p0, p1, p2, p3, p4, callback);
}
ReservationTypeService.findAssignedIds = function(p0, callback) {
  dwr.engine._execute(ReservationTypeService._path, 'ReservationTypeService', 'findAssignedIds', p0, callback);
}
ReservationTypeService.findAvailable = function(p0, callback) {
  dwr.engine._execute(ReservationTypeService._path, 'ReservationTypeService', 'findAvailable', p0, callback);
}
ReservationTypeService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(ReservationTypeService._path, 'ReservationTypeService', 'deleteByIdsNew', p0, callback);
}
ReservationTypeService.findById = function(p0, callback) {
  dwr.engine._execute(ReservationTypeService._path, 'ReservationTypeService', 'findById', p0, callback);
}
ReservationTypeService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(ReservationTypeService._path, 'ReservationTypeService', 'deleteByIds', p0, callback);
}
ReservationTypeService.assignReservationTypes = function(p0, p1, p2, callback) {
  dwr.engine._execute(ReservationTypeService._path, 'ReservationTypeService', 'assignReservationTypes', p0, p1, p2, callback);
}
if (ResourceService == null) var ResourceService = {};
ResourceService._path = '/dwr';
ResourceService.findAll = function(callback) {
  dwr.engine._execute(ResourceService._path, 'ResourceService', 'findAll', callback);
}
ResourceService.findById = function(p0, callback) {
  dwr.engine._execute(ResourceService._path, 'ResourceService', 'findById', p0, callback);
}
ResourceService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(ResourceService._path, 'ResourceService', 'deleteByIds', p0, callback);
}
ResourceService.getResourceAssetLayoutId = function(p0, callback) {
  dwr.engine._execute(ResourceService._path, 'ResourceService', 'getResourceAssetLayoutId', p0, callback);
}
ResourceService.cropAndCreateResource = function(p0, p1, p2, p3, p4, p5, callback) {
  dwr.engine._execute(ResourceService._path, 'ResourceService', 'cropAndCreateResource', p0, p1, p2, p3, p4, p5, callback);
}
if (RestrictionTypeService == null) var RestrictionTypeService = {};
RestrictionTypeService._path = '/dwr';
RestrictionTypeService.create = function(p0, callback) {
  dwr.engine._execute(RestrictionTypeService._path, 'RestrictionTypeService', 'create', p0, callback);
}
RestrictionTypeService.update = function(p0, callback) {
  dwr.engine._execute(RestrictionTypeService._path, 'RestrictionTypeService', 'update', p0, callback);
}
RestrictionTypeService.findAll = function(callback) {
  dwr.engine._execute(RestrictionTypeService._path, 'RestrictionTypeService', 'findAll', callback);
}
RestrictionTypeService.findAssignedIds = function(p0, callback) {
  dwr.engine._execute(RestrictionTypeService._path, 'RestrictionTypeService', 'findAssignedIds', p0, callback);
}
RestrictionTypeService.findAvailable = function(p0, callback) {
  dwr.engine._execute(RestrictionTypeService._path, 'RestrictionTypeService', 'findAvailable', p0, callback);
}
RestrictionTypeService.findRestrictionTypesByName = function(p0, p1, p2, p3, p4, callback) {
  dwr.engine._execute(RestrictionTypeService._path, 'RestrictionTypeService', 'findRestrictionTypesByName', p0, p1, p2, p3, p4, callback);
}
RestrictionTypeService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(RestrictionTypeService._path, 'RestrictionTypeService', 'deleteByIdsNew', p0, callback);
}
RestrictionTypeService.findById = function(p0, callback) {
  dwr.engine._execute(RestrictionTypeService._path, 'RestrictionTypeService', 'findById', p0, callback);
}
RestrictionTypeService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(RestrictionTypeService._path, 'RestrictionTypeService', 'deleteByIds', p0, callback);
}
RestrictionTypeService.assignRestrictionTypes = function(p0, p1, p2, callback) {
  dwr.engine._execute(RestrictionTypeService._path, 'RestrictionTypeService', 'assignRestrictionTypes', p0, p1, p2, callback);
}
if (SalesPromotionService == null) var SalesPromotionService = {};
SalesPromotionService._path = '/dwr';
SalesPromotionService.create = function(p0, callback) {
  dwr.engine._execute(SalesPromotionService._path, 'SalesPromotionService', 'create', p0, callback);
}
SalesPromotionService.update = function(p0, callback) {
  dwr.engine._execute(SalesPromotionService._path, 'SalesPromotionService', 'update', p0, callback);
}
SalesPromotionService.findAll = function(callback) {
  dwr.engine._execute(SalesPromotionService._path, 'SalesPromotionService', 'findAll', callback);
}
SalesPromotionService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(SalesPromotionService._path, 'SalesPromotionService', 'deleteByIdsNew', p0, callback);
}
SalesPromotionService.findById = function(p0, callback) {
  dwr.engine._execute(SalesPromotionService._path, 'SalesPromotionService', 'findById', p0, callback);
}
SalesPromotionService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(SalesPromotionService._path, 'SalesPromotionService', 'deleteByIds', p0, callback);
}
SalesPromotionService.findSalesPromotionsByListingId = function(p0, p1, p2, p3, p4, callback) {
  dwr.engine._execute(SalesPromotionService._path, 'SalesPromotionService', 'findSalesPromotionsByListingId', p0, p1, p2, p3, p4, callback);
}
if (SpecialtyTypeService == null) var SpecialtyTypeService = {};
SpecialtyTypeService._path = '/dwr';
SpecialtyTypeService.create = function(p0, callback) {
  dwr.engine._execute(SpecialtyTypeService._path, 'SpecialtyTypeService', 'create', p0, callback);
}
SpecialtyTypeService.update = function(p0, callback) {
  dwr.engine._execute(SpecialtyTypeService._path, 'SpecialtyTypeService', 'update', p0, callback);
}
SpecialtyTypeService.findAll = function(callback) {
  dwr.engine._execute(SpecialtyTypeService._path, 'SpecialtyTypeService', 'findAll', callback);
}
SpecialtyTypeService.findAssignedIds = function(p0, callback) {
  dwr.engine._execute(SpecialtyTypeService._path, 'SpecialtyTypeService', 'findAssignedIds', p0, callback);
}
SpecialtyTypeService.findAvailable = function(p0, callback) {
  dwr.engine._execute(SpecialtyTypeService._path, 'SpecialtyTypeService', 'findAvailable', p0, callback);
}
SpecialtyTypeService.findSpecialtyTypesByName = function(p0, p1, p2, p3, p4, callback) {
  dwr.engine._execute(SpecialtyTypeService._path, 'SpecialtyTypeService', 'findSpecialtyTypesByName', p0, p1, p2, p3, p4, callback);
}
SpecialtyTypeService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(SpecialtyTypeService._path, 'SpecialtyTypeService', 'deleteByIdsNew', p0, callback);
}
SpecialtyTypeService.findById = function(p0, callback) {
  dwr.engine._execute(SpecialtyTypeService._path, 'SpecialtyTypeService', 'findById', p0, callback);
}
SpecialtyTypeService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(SpecialtyTypeService._path, 'SpecialtyTypeService', 'deleteByIds', p0, callback);
}
SpecialtyTypeService.assignSpecialtyTypes = function(p0, p1, p2, callback) {
  dwr.engine._execute(SpecialtyTypeService._path, 'SpecialtyTypeService', 'assignSpecialtyTypes', p0, p1, p2, callback);
}
if (TravelModeService == null) var TravelModeService = {};
TravelModeService._path = '/dwr';
TravelModeService.create = function(p0, callback) {
  dwr.engine._execute(TravelModeService._path, 'TravelModeService', 'create', p0, callback);
}
TravelModeService.update = function(p0, callback) {
  dwr.engine._execute(TravelModeService._path, 'TravelModeService', 'update', p0, callback);
}
TravelModeService.findAll = function(callback) {
  dwr.engine._execute(TravelModeService._path, 'TravelModeService', 'findAll', callback);
}
TravelModeService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(TravelModeService._path, 'TravelModeService', 'deleteByIdsNew', p0, callback);
}
TravelModeService.findById = function(p0, callback) {
  dwr.engine._execute(TravelModeService._path, 'TravelModeService', 'findById', p0, callback);
}
TravelModeService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(TravelModeService._path, 'TravelModeService', 'deleteByIds', p0, callback);
}
if (UserService == null) var UserService = {};
UserService._path = '/dwr';
UserService.create = function(p0, callback) {
  dwr.engine._execute(UserService._path, 'UserService', 'create', p0, callback);
}
UserService.update = function(p0, callback) {
  dwr.engine._execute(UserService._path, 'UserService', 'update', p0, callback);
}
UserService.findAll = function(callback) {
  dwr.engine._execute(UserService._path, 'UserService', 'findAll', callback);
}
UserService.findUsersByTextFields = function(p0, p1, p2, p3, callback) {
  dwr.engine._execute(UserService._path, 'UserService', 'findUsersByTextFields', p0, p1, p2, p3, callback);
}
UserService.findProxyLogonUsers = function(callback) {
  dwr.engine._execute(UserService._path, 'UserService', 'findProxyLogonUsers', callback);
}
UserService.findUserDtosByCriteria = function(p0, p1, p2, p3, callback) {
  dwr.engine._execute(UserService._path, 'UserService', 'findUserDtosByCriteria', p0, p1, p2, p3, callback);
}
UserService.findUsersForLinkingWithAdvertiser = function(p0, p1, p2, p3, callback) {
  dwr.engine._execute(UserService._path, 'UserService', 'findUsersForLinkingWithAdvertiser', p0, p1, p2, p3, callback);
}
UserService.deleteByIdsNew = function(p0, callback) {
  dwr.engine._execute(UserService._path, 'UserService', 'deleteByIdsNew', p0, callback);
}
UserService.findById = function(p0, callback) {
  dwr.engine._execute(UserService._path, 'UserService', 'findById', p0, callback);
}
UserService.deleteByIds = function(p0, callback) {
  dwr.engine._execute(UserService._path, 'UserService', 'deleteByIds', p0, callback);
}
UserService.getSourceLogon = function(callback) {
  dwr.engine._execute(UserService._path, 'UserService', 'getSourceLogon', callback);
}
UserService.changePassword = function(p0, p1, callback) {
  dwr.engine._execute(UserService._path, 'UserService', 'changePassword', p0, p1, callback);
}
UserService.refreshSession = function(callback) {
  dwr.engine._execute(UserService._path, 'UserService', 'refreshSession', callback);
}
UserService.validateUser = function(p0, callback) {
  dwr.engine._execute(UserService._path, 'UserService', 'validateUser', p0, callback);
}
UserService.findUsersToChangePassword = function(callback) {
  dwr.engine._execute(UserService._path, 'UserService', 'findUsersToChangePassword', callback);
}
UserService.getCurrentUserName = function(callback) {
  dwr.engine._execute(UserService._path, 'UserService', 'getCurrentUserName', callback);
}
UserService.findValidApUsers = function(p0, callback) {
  dwr.engine._execute(UserService._path, 'UserService', 'findValidApUsers', p0, callback);
}
UserService.findValidThUsers = function(p0, callback) {
  dwr.engine._execute(UserService._path, 'UserService', 'findValidThUsers', p0, callback);
}
UserService.createUserForAdvertiser = function(p0, p1, p2, callback) {
  dwr.engine._execute(UserService._path, 'UserService', 'createUserForAdvertiser', p0, p1, p2, callback);
}
UserService.assignMyListings = function(p0, callback) {
  dwr.engine._execute(UserService._path, 'UserService', 'assignMyListings', p0, callback);
}
UserService.addToMyListings = function(p0, callback) {
  dwr.engine._execute(UserService._path, 'UserService', 'addToMyListings', p0, callback);
}
UserService.removeFromMyListings = function(p0, callback) {
  dwr.engine._execute(UserService._path, 'UserService', 'removeFromMyListings', p0, callback);
}