@penkov/swagger-code-gen 1.0.2 → 1.0.3

package/accounts.ts

@@ -0,0 +1,2117 @@
+/*********************************************************
+ *********************************************************
+ *********************************************************
+ *********************************************************
+ *********************************************************
+ *********************************************************
+ ************ GENERATED! DO NOT EDIT! ********************
+ *********************************************************
+ *********************************************************
+ *********************************************************
+ *********************************************************
+ *********************************************************/
+import fetch from 'node-fetch';
+
+
+export interface Access {
+    readonly filtering: FilteringAndLockingAccessLevel;
+    readonly locking: FilteringAndLockingAccessLevel;
+}
+
+
+export interface AccessRequestsSettingsModel {
+    readonly delegateToAccountId?: string;
+    readonly isApprovalFlowEnabled: boolean;
+    readonly approversEmails?: readonly string[];
+}
+
+
+export interface AccountCollectionItem {
+    readonly uniqueId: string;
+    readonly id?: string;
+    readonly number?: string;
+    readonly name?: string;
+    readonly contactName?: string;
+    readonly email?: string;
+    readonly phone: Phone;
+    readonly accountType: AccountType;
+    readonly createdOn: string;
+    readonly serviceProviderDisplayId?: string;
+}
+
+
+export interface AccountCollectionItemCollectionResult {
+    readonly collection?: readonly AccountCollectionItem[];
+    readonly total: number;
+}
+
+
+export interface AccountContactInfo {
+    readonly id: string;
+    readonly displayId?: string;
+    readonly number?: string;
+    readonly name?: string;
+    readonly contactPerson: Person;
+}
+
+
+export interface AccountContactInfoCollectionResult {
+    readonly collection?: readonly AccountContactInfo[];
+    readonly total: number;
+}
+
+
+export interface AccountDetailsResult {
+    readonly serviceProviderId: string;
+    readonly serviceProviderName?: string;
+    readonly number?: string;
+    readonly name?: string;
+    readonly accountType: AccountType;
+    readonly invitationStatus: AccountInvitationStatus;
+    readonly filteringAdminInvitationStatus: AccountInvitationStatus;
+}
+
+
+export interface AccountIdName {
+    readonly id: string;
+    readonly displayId?: string;
+    readonly name?: string;
+}
+
+
+export interface AccountIdNameCollectionResult {
+    readonly collection?: readonly AccountIdName[];
+    readonly total: number;
+}
+
+
+export interface AccountIdNameType {
+    readonly accountType: AccountType;
+    readonly id: string;
+    readonly displayId?: string;
+    readonly name?: string;
+}
+
+
+export interface AccountIdNameTypeCollectionResult {
+    readonly collection?: readonly AccountIdNameType[];
+    readonly total: number;
+}
+
+
+export interface AccountInfoResult {
+    readonly id: string;
+    readonly displayId?: string;
+    readonly updatedOn?: string;
+    readonly accountDetails: AccountDetailsResult;
+    readonly contactPerson: Person;
+    readonly accountSettings: AccountSettingsResult;
+    readonly blockPageContactPerson: Person;
+    readonly isCategoryAccessRequestAllowed: boolean;
+    readonly notes?: string;
+    readonly requestSettings: RequestSettingsResult;
+    readonly filteringAndLockingAccess: FilteringAndLockingAccess;
+    readonly notCompletedStates?: readonly number[];
+}
+
+
+export enum AccountInvitationStatus {
+    NotSent = 'NotSent',
+    Sent = 'Sent',
+    Used = 'Used',
+}
+
+
+export interface AccountSettingsResult {
+    readonly emailForNotifications?: string;
+    readonly currencyId: number;
+    readonly timeZoneId?: string;
+}
+
+
+export enum AccountType {
+    None = 'None',
+    Reseller = 'Reseller',
+    Company = 'Company',
+    Home = 'Home',
+    Division = 'Division',
+    RootDivision = 'RootDivision',
+}
+
+
+export interface AccountsCollectionResult {
+    readonly collection?: readonly AccountCollectionItem[];
+    readonly total: number;
+    readonly requiresStrictSearch: boolean;
+}
+
+
+export interface AddCustomerAccountModel {
+    readonly name?: string;
+    readonly accountType: AccountType;
+    readonly contactPerson: Person;
+    readonly serviceProviderDisplayId?: string;
+    readonly currencyId: number;
+    readonly timeZoneId?: string;
+    readonly isMarketingEmailsAllowed: boolean;
+    readonly isPersonalDataDiscloseAllowed: boolean;
+    readonly defaultEndUserAuthenticationCode?: string;
+    readonly id: string;
+    readonly operationDate: string;
+    readonly correlationId: string;
+}
+
+
+export interface CountryModel {
+    readonly countryName?: string;
+    readonly countryCode?: string;
+    readonly countryPhoneCode?: string;
+    readonly isDefault: boolean;
+}
+
+
+export interface CountryModelCollectionResult {
+    readonly collection?: readonly CountryModel[];
+    readonly total: number;
+}
+
+
+export interface CreateAccountModel {
+    readonly name?: string;
+    readonly contactPerson: Person;
+    readonly blockPageContactPerson: Person;
+    readonly accessRequestsSettings: AccessRequestsSettingsModel;
+    readonly defaultEndUserSettings: DefaultEndUserSettingsModel;
+    readonly serviceProviderDisplayId?: string;
+    readonly accountType: AccountType;
+    readonly currencyId: number;
+    readonly timeZoneId?: string;
+    readonly id: string;
+    readonly operationDate: string;
+    readonly correlationId: string;
+}
+
+
+export interface Currency {
+    readonly id: number;
+    readonly code?: string;
+    readonly symbol?: string;
+}
+
+
+export interface CurrencyCollectionResult {
+    readonly collection?: readonly Currency[];
+    readonly total: number;
+}
+
+
+export interface CustomerAccountVerificationModel {
+    readonly fullName?: string;
+    readonly email?: string;
+}
+
+
+export interface CustomerWfaAccountModel {
+    readonly displayId?: string;
+    readonly accountType: AccountType;
+    readonly name?: string;
+    readonly number?: string;
+    readonly serviceProviderDisplayId?: string;
+    readonly serviceProviderName?: string;
+    readonly contactPerson: Person;
+    readonly currencyId: number;
+}
+
+
+export interface DefaultEndUserSettingsModel {
+    readonly authenticationCode?: string;
+}
+
+
+export interface DownloadableItem {
+    readonly name?: string;
+    readonly description?: string;
+    readonly link?: string;
+    readonly uploadDate: string;
+}
+
+
+export interface DownloadableItemCollectionResult {
+    readonly collection?: readonly DownloadableItem[];
+    readonly total: number;
+}
+
+
+export enum EmailBelonging {
+    None = 'None',
+    SameUser = 'SameUser',
+    AnotherUser = 'AnotherUser',
+}
+
+
+export interface FilteringAndLockingAccess {
+    readonly allowRequestsWithUserLock: boolean;
+    readonly filteringAdminAccess: Access;
+    readonly accountOwnerAccess: Access;
+}
+
+
+export enum FilteringAndLockingAccessLevel {
+    None = 'None',
+    View = 'View',
+    Edit = 'Edit',
+}
+
+
+export interface Person {
+    readonly fullName?: string;
+    readonly email?: string;
+    readonly phone: Phone;
+}
+
+
+export interface Phone {
+    readonly countryCode?: string;
+    readonly countryPhoneCode?: string;
+    readonly phoneNumber?: string;
+}
+
+
+export interface PostPurchaseInstructionResult {
+    readonly notCompletedStates?: readonly number[];
+    readonly title?: string;
+    readonly message?: string;
+    readonly linkUrl?: string;
+    readonly linkTitle?: string;
+}
+
+
+export interface PrivacyPolicySettingsModel {
+    readonly isMarketingEmailsAllowed: boolean;
+    readonly isPersonalDataDiscloseAllowed: boolean;
+    readonly accountId?: string;
+}
+
+
+export interface RequestSettingsResult {
+    readonly delegateToAccountName?: string;
+    readonly delegateToAccountId?: string;
+    readonly isApprovalFlowEnabled: boolean;
+    readonly approversEmailsJson?: string;
+    readonly approversEmails?: readonly string[];
+    readonly isFilteringManagedByResellerOnly: boolean;
+}
+
+
+export interface ResellerAccountIdName {
+    readonly id: string;
+    readonly displayId?: string;
+    readonly name?: string;
+    readonly isFilteringManagedByResellerOnly: boolean;
+}
+
+
+export interface ResellerAccountIdNameCollectionResult {
+    readonly collection?: readonly ResellerAccountIdName[];
+    readonly total: number;
+}
+
+
+export interface SendCustomerInvitation {
+    readonly serviceProviderId: string;
+    readonly customerEmail?: string;
+    readonly invitationId: string;
+}
+
+
+export interface ServiceProviderDetails {
+    readonly id: string;
+    readonly name?: string;
+    readonly contactPerson: Person;
+}
+
+
+export interface ServiceProviderResult {
+    readonly currencyId: number;
+    readonly timeZoneId?: string;
+    readonly isSelected: boolean;
+    readonly id: string;
+    readonly displayId?: string;
+    readonly name?: string;
+}
+
+
+export interface ServiceProviderResultCollectionResult {
+    readonly collection?: readonly ServiceProviderResult[];
+    readonly total: number;
+}
+
+
+export interface StringSuccess {
+    readonly value?: string;
+}
+
+
+export interface Timezone {
+    readonly id?: string;
+    readonly name?: string;
+    readonly offset: string;
+}
+
+
+export interface TimezoneCollectionResult {
+    readonly collection?: readonly Timezone[];
+    readonly total: number;
+}
+
+
+export interface TrackInvitationOpened {
+    readonly invitationId: string;
+    readonly operationDate: string;
+    readonly correlationId: string;
+}
+
+
+export interface TrackInvitationRegistered {
+    readonly invitationId: string;
+    readonly operationDate: string;
+    readonly correlationId: string;
+    readonly email?: string;
+}
+
+
+export interface UpdateAccountBlockPageSettings {
+    readonly contactPerson: Person;
+    readonly isCategoryAccessRequestAllowed: boolean;
+    readonly id: string;
+    readonly operationDate: string;
+    readonly correlationId: string;
+}
+
+
+export interface UpdateAccountContactPerson {
+    readonly contactPerson: Person;
+    readonly id: string;
+    readonly operationDate: string;
+    readonly correlationId: string;
+}
+
+
+export interface UpdateAccountDetails {
+    readonly name?: string;
+    readonly serviceProviderId?: string;
+    readonly importNewResellerLockingSettings: boolean;
+    readonly displayId?: string;
+    readonly accountType: AccountType;
+    readonly id: string;
+    readonly operationDate: string;
+    readonly correlationId: string;
+}
+
+
+export interface UpdateAccountFilteringAndLockingAccess {
+    readonly name?: string;
+    readonly allowRequestsWithUserLock: boolean;
+    readonly filteringAdminAccess: Access;
+    readonly accountOwnerAccess: Access;
+    readonly id: string;
+    readonly operationDate: string;
+    readonly correlationId: string;
+}
+
+
+export interface UpdateAccountNotes {
+    readonly name?: string;
+    readonly notes?: string;
+    readonly id: string;
+    readonly operationDate: string;
+    readonly correlationId: string;
+}
+
+
+export interface UpdateAccountSettings {
+    readonly timeZoneId?: string;
+    readonly emailForNotifications?: string;
+    readonly id: string;
+    readonly operationDate: string;
+    readonly correlationId: string;
+}
+
+
+export interface UpdateCompanyName {
+    readonly name?: string;
+    readonly id: string;
+    readonly operationDate: string;
+    readonly correlationId: string;
+}
+
+
+export interface UpdatePostPurchaseInstructions {
+    readonly title?: string;
+    readonly message?: string;
+    readonly linkUrl?: string;
+    readonly linkTitle?: string;
+    readonly id: string;
+    readonly operationDate: string;
+    readonly correlationId: string;
+}
+
+
+export interface UpdatePrivacyPolicy {
+    readonly isMarketingEmailsAllowed: boolean;
+    readonly isPersonalDataDiscloseAllowed: boolean;
+    readonly id: string;
+    readonly operationDate: string;
+    readonly correlationId: string;
+}
+
+
+export interface UpdateRequestSettings {
+    readonly delegateToAccountId?: string;
+    readonly isApprovalFlowEnabled: boolean;
+    readonly approversEmails?: readonly string[];
+    readonly isFilteringManagedByResellerOnly: boolean;
+    readonly id: string;
+    readonly operationDate: string;
+    readonly correlationId: string;
+}
+
+
+
+export interface RequestOptions {
+    headers: Record<string, string>;
+}
+
+const defaultRequestOptions = {
+    headers: {
+        'Accept': 'application/json',
+        'Content-Type': 'application/json'
+    }
+}
+
+
+/**
+ * GET /accounts/{id}/direct/customers
+ * @param {Object} params
+ * @param {string} params.pathId This account id
+ * @param {string} params.requireVersion 
+ * @param {string} params.queryId 
+ * @param {boolean} params.isAscending 
+ * @param {string} params.orderBy 
+ * @param {number} params.page 
+ * @param {number} params.pageSize 
+ * @param {string} params.search 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary Gets direct accounts of this account of type Home or Company
+ * @return {AccountsCollectionResult} Success
+ */
+export async function getAccountsByIdDirectCustomers(
+    params: {
+        pathId: string,
+        requireVersion: string,
+        queryId?: string,
+        isAscending?: boolean,
+        orderBy?: string,
+        page?: number,
+        pageSize?: number,
+        search?: string,
+    },
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<AccountsCollectionResult> {
+    let query = '';
+    const queryParams = [];
+    if (!!params.queryId) {
+        queryParams.push(`id=${encodeURIComponent(params.queryId)}`);
+    }
+    if (!!params.isAscending) {
+        queryParams.push(`isAscending=${params.isAscending}`);
+    }
+    if (!!params.orderBy) {
+        queryParams.push(`orderBy=${encodeURIComponent(params.orderBy)}`);
+    }
+    if (!!params.page) {
+        queryParams.push(`page=${params.page}`);
+    }
+    if (!!params.pageSize) {
+        queryParams.push(`pageSize=${params.pageSize}`);
+    }
+    if (!!params.search) {
+        queryParams.push(`search=${encodeURIComponent(params.search)}`);
+    }
+    if (queryParams.length > 0) {
+        query = '?' + queryParams.join('&');
+    }
+    const resp = await fetch(`/accounts/${params.pathId}/direct/customers${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: params.requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as AccountsCollectionResult;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /accounts/{id}/direct/partners
+ * @param {Object} params
+ * @param {string} params.pathId This account id
+ * @param {string} params.requireVersion 
+ * @param {string} params.queryId 
+ * @param {boolean} params.isAscending 
+ * @param {string} params.orderBy 
+ * @param {number} params.page 
+ * @param {number} params.pageSize 
+ * @param {string} params.search 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary Gets direct accounts of this account of type Reseller or Division
+ * @return {AccountsCollectionResult} Success
+ */
+export async function getAccountsByIdDirectPartners(
+    params: {
+        pathId: string,
+        requireVersion: string,
+        queryId?: string,
+        isAscending?: boolean,
+        orderBy?: string,
+        page?: number,
+        pageSize?: number,
+        search?: string,
+    },
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<AccountsCollectionResult> {
+    let query = '';
+    const queryParams = [];
+    if (!!params.queryId) {
+        queryParams.push(`id=${encodeURIComponent(params.queryId)}`);
+    }
+    if (!!params.isAscending) {
+        queryParams.push(`isAscending=${params.isAscending}`);
+    }
+    if (!!params.orderBy) {
+        queryParams.push(`orderBy=${encodeURIComponent(params.orderBy)}`);
+    }
+    if (!!params.page) {
+        queryParams.push(`page=${params.page}`);
+    }
+    if (!!params.pageSize) {
+        queryParams.push(`pageSize=${params.pageSize}`);
+    }
+    if (!!params.search) {
+        queryParams.push(`search=${encodeURIComponent(params.search)}`);
+    }
+    if (queryParams.length > 0) {
+        query = '?' + queryParams.join('&');
+    }
+    const resp = await fetch(`/accounts/${params.pathId}/direct/partners${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: params.requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as AccountsCollectionResult;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /accounts/{id}/direct/children
+ * @param {Object} params
+ * @param {string} params.pathId This account id
+ * @param {string} params.requireVersion 
+ * @param {string} params.queryId 
+ * @param {boolean} params.isAscending 
+ * @param {string} params.orderBy 
+ * @param {number} params.page 
+ * @param {number} params.pageSize 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary Gets direct accounts of this account to show as a hierarchy tree
+ * @return {AccountCollectionItemCollectionResult} Success
+ */
+export async function getAccountsByIdDirectChildren(
+    params: {
+        pathId: string,
+        requireVersion: string,
+        queryId?: string,
+        isAscending?: boolean,
+        orderBy?: string,
+        page?: number,
+        pageSize?: number,
+    },
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<AccountCollectionItemCollectionResult> {
+    let query = '';
+    const queryParams = [];
+    if (!!params.queryId) {
+        queryParams.push(`id=${encodeURIComponent(params.queryId)}`);
+    }
+    if (!!params.isAscending) {
+        queryParams.push(`isAscending=${params.isAscending}`);
+    }
+    if (!!params.orderBy) {
+        queryParams.push(`orderBy=${encodeURIComponent(params.orderBy)}`);
+    }
+    if (!!params.page) {
+        queryParams.push(`page=${params.page}`);
+    }
+    if (!!params.pageSize) {
+        queryParams.push(`pageSize=${params.pageSize}`);
+    }
+    if (queryParams.length > 0) {
+        query = '?' + queryParams.join('&');
+    }
+    const resp = await fetch(`/accounts/${params.pathId}/direct/children${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: params.requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as AccountCollectionItemCollectionResult;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /accounts/{id}/timezone
+ * @param {string} id 
+ * @param {string} requireVersion 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary GetAccountTimeZone
+ * @return {StringSuccess} Success
+ */
+export async function getAccountsByIdTimezone(
+    id: string,
+    requireVersion: string,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<StringSuccess> {
+    let query = '';
+    const resp = await fetch(`/accounts/${id}/timezone${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as StringSuccess;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /accounts/by-display-id/{id}/with-service-provider
+ * @param {string} id account&#39;s Id
+ * @param {string} requireVersion 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary Gets an account by DisplayId
+ * @return {AccountInfoResult} Success
+ */
+export async function getAccountsByDisplayIdByIdWithServiceProvider(
+    id: string,
+    requireVersion: string,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<AccountInfoResult> {
+    let query = '';
+    const resp = await fetch(`/accounts/by-display-id/${id}/with-service-provider${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as AccountInfoResult;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /accounts/all/available
+ * @param {string} requireVersion 
+ * @param {readonly AccountType[]} types 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary GetAllAvailableAccounts
+ * @return {AccountIdNameCollectionResult} Success
+ */
+export async function getAccountsAllAvailable(
+    requireVersion: string,
+    types?: readonly AccountType[],
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<AccountIdNameCollectionResult> {
+    let query = '';
+    const queryParams = [];
+    if (!!types) {
+        queryParams.push(`types=${types}`);
+    }
+    if (queryParams.length > 0) {
+        query = '?' + queryParams.join('&');
+    }
+    const resp = await fetch(`/accounts/all/available${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as AccountIdNameCollectionResult;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * POST /accounts
+ * @param {string} requireVersion 
+ * @param {CreateAccountModel} body
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary CreateAccount
+ * @return {any} 
+ */
+export async function postAccounts(
+    requireVersion: string,
+    body: CreateAccountModel,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<any> {
+    let query = '';
+    const resp = await fetch(`/accounts${query}`, {
+        method: 'post',
+        body: JSON.stringify(body),
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as any;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * PUT /accounts/details
+ * @param {string} requireVersion 
+ * @param {UpdateAccountDetails} body
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary UpdateAccountDetails
+ * @return {any} 
+ */
+export async function putAccountsDetails(
+    requireVersion: string,
+    body: UpdateAccountDetails,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<any> {
+    let query = '';
+    const resp = await fetch(`/accounts/details${query}`, {
+        method: 'put',
+        body: JSON.stringify(body),
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as any;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * PUT /accounts/block-page-settings
+ * @param {string} requireVersion 
+ * @param {UpdateAccountBlockPageSettings} body
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary UpdateAccountBlockPageSettings
+ * @return {any} 
+ */
+export async function putAccountsBlockPageSettings(
+    requireVersion: string,
+    body: UpdateAccountBlockPageSettings,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<any> {
+    let query = '';
+    const resp = await fetch(`/accounts/block-page-settings${query}`, {
+        method: 'put',
+        body: JSON.stringify(body),
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as any;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * PUT /accounts/settings
+ * @param {string} requireVersion 
+ * @param {UpdateAccountSettings} body
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary UpdateAccountSettings
+ * @return {any} 
+ */
+export async function putAccountsSettings(
+    requireVersion: string,
+    body: UpdateAccountSettings,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<any> {
+    let query = '';
+    const resp = await fetch(`/accounts/settings${query}`, {
+        method: 'put',
+        body: JSON.stringify(body),
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as any;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * PUT /accounts/contact-person
+ * @param {string} requireVersion 
+ * @param {UpdateAccountContactPerson} body
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary UpdateAccountContactPerson
+ * @return {any} 
+ */
+export async function putAccountsContactPerson(
+    requireVersion: string,
+    body: UpdateAccountContactPerson,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<any> {
+    let query = '';
+    const resp = await fetch(`/accounts/contact-person${query}`, {
+        method: 'put',
+        body: JSON.stringify(body),
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as any;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /accounts/{id}/notes
+ * @param {string} id 
+ * @param {string} requireVersion 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary GetAccountNotes
+ * @return {StringSuccess} Success
+ */
+export async function getAccountsByIdNotes(
+    id: string,
+    requireVersion: string,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<StringSuccess> {
+    let query = '';
+    const resp = await fetch(`/accounts/${id}/notes${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as StringSuccess;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * PUT /accounts/notes
+ * @param {string} requireVersion 
+ * @param {UpdateAccountNotes} body
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary UpdateAccountNotes
+ * @return {any} 
+ */
+export async function putAccountsNotes(
+    requireVersion: string,
+    body: UpdateAccountNotes,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<any> {
+    let query = '';
+    const resp = await fetch(`/accounts/notes${query}`, {
+        method: 'put',
+        body: JSON.stringify(body),
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as any;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /accounts/email-belonging
+ * @param {Object} params
+ * @param {string} params.requireVersion 
+ * @param {string} params.id 
+ * @param {string} params.email 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary FindEmail
+ * @return {EmailBelonging} Success
+ */
+export async function getAccountsEmailBelonging(
+    params: {
+        requireVersion: string,
+        id?: string,
+        email?: string,
+    },
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<EmailBelonging> {
+    let query = '';
+    const queryParams = [];
+    if (!!params.id) {
+        queryParams.push(`id=${encodeURIComponent(params.id)}`);
+    }
+    if (!!params.email) {
+        queryParams.push(`email=${encodeURIComponent(params.email)}`);
+    }
+    if (queryParams.length > 0) {
+        query = '?' + queryParams.join('&');
+    }
+    const resp = await fetch(`/accounts/email-belonging${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: params.requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as EmailBelonging;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /accounts/service-providers/available-for-changing-current
+ * @param {Object} params
+ * @param {string} params.requireVersion 
+ * @param {number} params.page 
+ * @param {number} params.pageSize 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary GetServiceProvidersToChangeCurrent
+ * @return {ResellerAccountIdNameCollectionResult} Success
+ */
+export async function getAccountsServiceProvidersAvailableForChangingCurrent(
+    params: {
+        requireVersion: string,
+        page?: number,
+        pageSize?: number,
+    },
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<ResellerAccountIdNameCollectionResult> {
+    let query = '';
+    const queryParams = [];
+    if (!!params.page) {
+        queryParams.push(`page=${params.page}`);
+    }
+    if (!!params.pageSize) {
+        queryParams.push(`pageSize=${params.pageSize}`);
+    }
+    if (queryParams.length > 0) {
+        query = '?' + queryParams.join('&');
+    }
+    const resp = await fetch(`/accounts/service-providers/available-for-changing-current${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: params.requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as ResellerAccountIdNameCollectionResult;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /accounts/{id}/service-providers/available-for-delegation
+ * @param {Object} params
+ * @param {string} params.id 
+ * @param {string} params.requireVersion 
+ * @param {boolean} params.isForNewAccount 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary GetServiceProvidersForDelegation
+ * @return {AccountIdNameCollectionResult} Success
+ */
+export async function getAccountsByIdServiceProvidersAvailableForDelegation(
+    params: {
+        id: string,
+        requireVersion: string,
+        isForNewAccount?: boolean,
+    },
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<AccountIdNameCollectionResult> {
+    let query = '';
+    const queryParams = [];
+    if (!!params.isForNewAccount) {
+        queryParams.push(`isForNewAccount=${params.isForNewAccount}`);
+    }
+    if (queryParams.length > 0) {
+        query = '?' + queryParams.join('&');
+    }
+    const resp = await fetch(`/accounts/${params.id}/service-providers/available-for-delegation${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: params.requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as AccountIdNameCollectionResult;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * DELETE /accounts/{id}
+ * @param {Object} params
+ * @param {string} params.id 
+ * @param {string} params.requireVersion 
+ * @param {string} params.operationDate 
+ * @param {string} params.correlationId 
+ * @param {string} params.name 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary DeleteAccount
+ * @return {any} 
+ */
+export async function deleteAccountsById(
+    params: {
+        id: string,
+        requireVersion: string,
+        operationDate?: string,
+        correlationId?: string,
+        name?: string,
+    },
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<any> {
+    let query = '';
+    const queryParams = [];
+    if (!!params.operationDate) {
+        queryParams.push(`operationDate=${encodeURIComponent(params.operationDate)}`);
+    }
+    if (!!params.correlationId) {
+        queryParams.push(`correlationId=${encodeURIComponent(params.correlationId)}`);
+    }
+    if (!!params.name) {
+        queryParams.push(`name=${encodeURIComponent(params.name)}`);
+    }
+    if (queryParams.length > 0) {
+        query = '?' + queryParams.join('&');
+    }
+    const resp = await fetch(`/accounts/${params.id}${query}`, {
+        method: 'delete',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: params.requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as any;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /accounts/by-token
+ * @param {string} requireVersion 
+ * @param {string} token 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary GetInvitationToken
+ * @return {AccountCollectionItem} Success
+ */
+export async function getAccountsByToken(
+    requireVersion: string,
+    token?: string,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<AccountCollectionItem> {
+    let query = '';
+    const queryParams = [];
+    if (!!token) {
+        queryParams.push(`token=${encodeURIComponent(token)}`);
+    }
+    if (queryParams.length > 0) {
+        query = '?' + queryParams.join('&');
+    }
+    const resp = await fetch(`/accounts/by-token${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as AccountCollectionItem;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /accounts/{id}/service-providers/resellers
+ * @param {string} id 
+ * @param {string} requireVersion 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary GetChildServiceProviders
+ * @return {AccountIdNameCollectionResult} Success
+ */
+export async function getAccountsByIdServiceProvidersResellers(
+    id: string,
+    requireVersion: string,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<AccountIdNameCollectionResult> {
+    let query = '';
+    const resp = await fetch(`/accounts/${id}/service-providers/resellers${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as AccountIdNameCollectionResult;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /accounts/{id}/service-providers/available-to-create-children/any
+ * @param {string} id 
+ * @param {string} requireVersion 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary GetIsAnyServiceProvidersToCreateChild
+ * @return {boolean} Success
+ */
+export async function getAccountsByIdServiceProvidersAvailableToCreateChildrenAny(
+    id: string,
+    requireVersion: string,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<boolean> {
+    let query = '';
+    const resp = await fetch(`/accounts/${id}/service-providers/available-to-create-children/any${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as boolean;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /accounts/{id}/service-providers/available-to-create-children
+ * @param {string} id 
+ * @param {string} requireVersion 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary GetServiceProvidersToCreateChild
+ * @return {AccountIdNameTypeCollectionResult} Success
+ */
+export async function getAccountsByIdServiceProvidersAvailableToCreateChildren(
+    id: string,
+    requireVersion: string,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<AccountIdNameTypeCollectionResult> {
+    let query = '';
+    const resp = await fetch(`/accounts/${id}/service-providers/available-to-create-children${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as AccountIdNameTypeCollectionResult;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * POST /accounts/customer-invitation
+ * @param {string} requireVersion 
+ * @param {SendCustomerInvitation} body
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary SendCustomerInvitation
+ * @return {any} 
+ */
+export async function postAccountsCustomerInvitation(
+    requireVersion: string,
+    body: SendCustomerInvitation,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<any> {
+    let query = '';
+    const resp = await fetch(`/accounts/customer-invitation${query}`, {
+        method: 'post',
+        body: JSON.stringify(body),
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as any;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /accounts/{id}/post-purchase-instructions
+ * @param {string} id 
+ * @param {string} requireVersion 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary UpdatePostPurchaseInstructions
+ * @return {PostPurchaseInstructionResult} Success
+ */
+export async function getAccountsByIdPostPurchaseInstructions(
+    id: string,
+    requireVersion: string,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<PostPurchaseInstructionResult> {
+    let query = '';
+    const resp = await fetch(`/accounts/${id}/post-purchase-instructions${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as PostPurchaseInstructionResult;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * PUT /accounts/{id}/post-purchase-instructions
+ * @param {string} id 
+ * @param {string} requireVersion 
+ * @param {UpdatePostPurchaseInstructions} body
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary UpdatePostPurchaseInstructions
+ * @return {any} 
+ */
+export async function putAccountsByIdPostPurchaseInstructions(
+    id: string,
+    requireVersion: string,
+    body: UpdatePostPurchaseInstructions,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<any> {
+    let query = '';
+    const resp = await fetch(`/accounts/${id}/post-purchase-instructions${query}`, {
+        method: 'put',
+        body: JSON.stringify(body),
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as any;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * PUT /accounts/request-settings
+ * @param {string} requireVersion 
+ * @param {UpdateRequestSettings} body
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary UpdateAccountAccessRequestSettings
+ * @return {any} 
+ */
+export async function putAccountsRequestSettings(
+    requireVersion: string,
+    body: UpdateRequestSettings,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<any> {
+    let query = '';
+    const resp = await fetch(`/accounts/request-settings${query}`, {
+        method: 'put',
+        body: JSON.stringify(body),
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as any;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * PUT /accounts/filtering-and-locking-access
+ * @param {string} requireVersion 
+ * @param {UpdateAccountFilteringAndLockingAccess} body
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary UpdateAccountFilteringAndLockingAccess
+ * @return {any} 
+ */
+export async function putAccountsFilteringAndLockingAccess(
+    requireVersion: string,
+    body: UpdateAccountFilteringAndLockingAccess,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<any> {
+    let query = '';
+    const resp = await fetch(`/accounts/filtering-and-locking-access${query}`, {
+        method: 'put',
+        body: JSON.stringify(body),
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as any;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /accounts/list/for-user
+ * @param {string} requireVersion 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary GetAccountListForUser
+ * @return {AccountContactInfoCollectionResult} Success
+ */
+export async function getAccountsListForUser(
+    requireVersion: string,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<AccountContactInfoCollectionResult> {
+    let query = '';
+    const resp = await fetch(`/accounts/list/for-user${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as AccountContactInfoCollectionResult;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /currencies
+ * @param {string} requireVersion 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary GetCurrencies
+ * @return {CurrencyCollectionResult} Success
+ */
+export async function getCurrencies(
+    requireVersion: string,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<CurrencyCollectionResult> {
+    let query = '';
+    const resp = await fetch(`/currencies${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as CurrencyCollectionResult;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /accounts/of-customers
+ * @param {string} requireVersion 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary GetAccount
+ * @return {CustomerWfaAccountModel} Success
+ */
+export async function getAccountsOfCustomers(
+    requireVersion: string,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<CustomerWfaAccountModel> {
+    let query = '';
+    const resp = await fetch(`/accounts/of-customers${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as CustomerWfaAccountModel;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * POST /accounts/of-customers
+ * @param {string} requireVersion 
+ * @param {AddCustomerAccountModel} body
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary This endpoint is called from Customer Portal UI
+After the account creation we need to create a customer with credentials to login into the account
+ * @return {any} 
+ */
+export async function postAccountsOfCustomers(
+    requireVersion: string,
+    body: AddCustomerAccountModel,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<any> {
+    let query = '';
+    const resp = await fetch(`/accounts/of-customers${query}`, {
+        method: 'post',
+        body: JSON.stringify(body),
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as any;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /accounts/of-customers/service-provider/details
+ * @param {string} requireVersion 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary GetServiceProviderDetails
+ * @return {ServiceProviderDetails} Success
+ */
+export async function getAccountsOfCustomersServiceProviderDetails(
+    requireVersion: string,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<ServiceProviderDetails> {
+    let query = '';
+    const resp = await fetch(`/accounts/of-customers/service-provider/details${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as ServiceProviderDetails;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * PUT /accounts/of-customers/name
+ * @param {string} requireVersion 
+ * @param {UpdateCompanyName} body
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary UpdateCompanyName
+ * @return {any} 
+ */
+export async function putAccountsOfCustomersName(
+    requireVersion: string,
+    body: UpdateCompanyName,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<any> {
+    let query = '';
+    const resp = await fetch(`/accounts/of-customers/name${query}`, {
+        method: 'put',
+        body: JSON.stringify(body),
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as any;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * PUT /accounts/of-customers/contact-person
+ * @param {string} requireVersion 
+ * @param {UpdateAccountContactPerson} body
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary UpdateContactPerson
+ * @return {any} 
+ */
+export async function putAccountsOfCustomersContactPerson(
+    requireVersion: string,
+    body: UpdateAccountContactPerson,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<any> {
+    let query = '';
+    const resp = await fetch(`/accounts/of-customers/contact-person${query}`, {
+        method: 'put',
+        body: JSON.stringify(body),
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as any;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /accounts/of-customers/service-providers
+ * @param {string} requireVersion 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary GetServiceProviders
+ * @return {ServiceProviderResultCollectionResult} Success
+ */
+export async function getAccountsOfCustomersServiceProviders(
+    requireVersion: string,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<ServiceProviderResultCollectionResult> {
+    let query = '';
+    const resp = await fetch(`/accounts/of-customers/service-providers${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as ServiceProviderResultCollectionResult;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /accounts/of-customers/what-is-my-remote-address
+ * @param {string} requireVersion 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary WhatIsMyRemoteAddress
+ * @return {string} Success
+ */
+export async function getAccountsOfCustomersWhatIsMyRemoteAddress(
+    requireVersion: string,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<string> {
+    let query = '';
+    const resp = await fetch(`/accounts/of-customers/what-is-my-remote-address${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as string;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /accounts/of-customers/privacy
+ * @param {string} requireVersion 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary GetPrivacyPolicySettings
+ * @return {PrivacyPolicySettingsModel} Success
+ */
+export async function getAccountsOfCustomersPrivacy(
+    requireVersion: string,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<PrivacyPolicySettingsModel> {
+    let query = '';
+    const resp = await fetch(`/accounts/of-customers/privacy${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as PrivacyPolicySettingsModel;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * PUT /accounts/of-customers/privacy
+ * @param {string} requireVersion 
+ * @param {UpdatePrivacyPolicy} body
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary SetPrivacyPolicySettings
+ * @return {any} 
+ */
+export async function putAccountsOfCustomersPrivacy(
+    requireVersion: string,
+    body: UpdatePrivacyPolicy,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<any> {
+    let query = '';
+    const resp = await fetch(`/accounts/of-customers/privacy${query}`, {
+        method: 'put',
+        body: JSON.stringify(body),
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as any;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * POST /accounts/of-customers/verification
+ * @param {string} requireVersion 
+ * @param {CustomerAccountVerificationModel} body
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary StoreCustomerAccountVerification
+ * @return {any} 
+ */
+export async function postAccountsOfCustomersVerification(
+    requireVersion: string,
+    body: CustomerAccountVerificationModel,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<any> {
+    let query = '';
+    const resp = await fetch(`/accounts/of-customers/verification${query}`, {
+        method: 'post',
+        body: JSON.stringify(body),
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as any;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /accounts/of-customers/verification
+ * @param {string} requireVersion 
+ * @param {string} token 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary GetCustomerAccountVerification
+ * @return {CustomerAccountVerificationModel} Success
+ */
+export async function getAccountsOfCustomersVerification(
+    requireVersion: string,
+    token?: string,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<CustomerAccountVerificationModel> {
+    let query = '';
+    const queryParams = [];
+    if (!!token) {
+        queryParams.push(`token=${encodeURIComponent(token)}`);
+    }
+    if (queryParams.length > 0) {
+        query = '?' + queryParams.join('&');
+    }
+    const resp = await fetch(`/accounts/of-customers/verification${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as CustomerAccountVerificationModel;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /geo
+ * @param {string} requireVersion 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary GetCountries
+ * @return {CountryModelCollectionResult} Success
+ */
+export async function getGeo(
+    requireVersion: string,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<CountryModelCollectionResult> {
+    let query = '';
+    const resp = await fetch(`/geo${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as CountryModelCollectionResult;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * POST /invitations/{invitationId}/links/opened
+ * @param {string} invitationId 
+ * @param {string} requireVersion 
+ * @param {TrackInvitationOpened} body
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary TrackInvitationOpened
+ * @return {any} 
+ */
+export async function postInvitationsByInvitationIdLinksOpened(
+    invitationId: string,
+    requireVersion: string,
+    body: TrackInvitationOpened,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<any> {
+    let query = '';
+    const resp = await fetch(`/invitations/${invitationId}/links/opened${query}`, {
+        method: 'post',
+        body: JSON.stringify(body),
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as any;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * POST /invitations/{invitationId}/links/registered
+ * @param {string} invitationId 
+ * @param {string} requireVersion 
+ * @param {TrackInvitationRegistered} body
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary TrackInvitationRegistered
+ * @return {any} 
+ */
+export async function postInvitationsByInvitationIdLinksRegistered(
+    invitationId: string,
+    requireVersion: string,
+    body: TrackInvitationRegistered,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<any> {
+    let query = '';
+    const resp = await fetch(`/invitations/${invitationId}/links/registered${query}`, {
+        method: 'post',
+        body: JSON.stringify(body),
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as any;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /support
+ * @param {string} requireVersion 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary GetDownloads
+ * @return {DownloadableItemCollectionResult} Success
+ */
+export async function getSupport(
+    requireVersion: string,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<DownloadableItemCollectionResult> {
+    let query = '';
+    const resp = await fetch(`/support${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as DownloadableItemCollectionResult;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /timezones
+ * @param {string} requireVersion 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary GetTimezones
+ * @return {TimezoneCollectionResult} Success
+ */
+export async function getTimezones(
+    requireVersion: string,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<TimezoneCollectionResult> {
+    let query = '';
+    const resp = await fetch(`/timezones${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as TimezoneCollectionResult;
+   } else {
+       throw json;
+   }
+
+}
+
+
+/**
+ * GET /validation/emails
+ * @param {string} requireVersion 
+ * @param {string} email 
+ * @param {RequestOptions} requestOptions Additional request params
+ * @summary ValidateDisposableEmail
+ * @return {boolean} Success
+ */
+export async function getValidationEmails(
+    requireVersion: string,
+    email?: string,
+    requestOptions: RequestOptions = defaultRequestOptions
+): Promise<boolean> {
+    let query = '';
+    const queryParams = [];
+    if (!!email) {
+        queryParams.push(`email=${encodeURIComponent(email)}`);
+    }
+    if (queryParams.length > 0) {
+        query = '?' + queryParams.join('&');
+    }
+    const resp = await fetch(`/validation/emails${query}`, {
+        method: 'get',
+        body: undefined,
+        headers: {
+            ...requestOptions.headers,
+            requireVersion: requireVersion
+        }
+    });
+   const json = await resp.json();
+   if (resp.ok) {
+       return json as boolean;
+   } else {
+       throw json;
+   }
+
+}
+
+