interface WhmcsSetupOptions {
    identifier: string;
    secret: string;
    apiUrl: string;
}

declare abstract class BaseModule {
    request(methodName: string, options?: any): Promise<any>;
}

interface UpdateClientAddonRequest {
    id: number;
    status?: string;
    terminationDate?: Date;
    addonid?: number;
    name?: string;
    setupfee?: number;
    recurring?: number;
    billingcycle?: string;
    nextduedate?: Date;
    nextinvoicedate?: Date;
    notes?: string;
}
declare class UpdateClientAddonResponse {
    result: string;
    id: number;
}

declare class WhmcsAddonsService extends BaseModule {
    updateClientAddon(options: UpdateClientAddonRequest): Promise<UpdateClientAddonResponse>;
}

interface AffiliateActivateRequest {
    userid: number;
}
interface AffiliateActivateResponse {
    result: string;
}

interface GetAffiliatesRequest {
    limitstart?: number;
    limitnum?: number;
    userid?: number;
    visitors?: number;
    paytype?: string;
    payamount?: number;
    onetime?: number;
    balance?: number;
    withdrawn?: number;
}
interface GetAffiliatesResponse {
    result: string;
    totalresults: number;
    startnumber: number;
    numreturned: number;
    affiliates: Affiliate[];
}
interface Affiliate {
    id: number;
    date: Date;
    clientid: number;
    visitors: number;
    paytype: string;
    payamount: number;
    onetime: number;
    balance: number;
    withdrawn: number;
    created_at: Date;
    updated_at: Date;
}

declare class WhmcsAffiliatesService extends BaseModule {
    affiliateActivate(options: AffiliateActivateRequest): Promise<AffiliateActivateResponse>;
    getAffiliates(options: GetAffiliatesRequest): Promise<GetAffiliatesResponse>;
}

interface CreateOAuthCredentialRequest {
    grantType: string;
    scope: string;
    name?: string;
    serviceId?: number;
    description?: string;
    logoUri?: string;
    redirectUri?: string;
}
interface CreateOAuthCredentialResponse {
    result: string;
    credentialId: number;
    clientIdentifier: string;
    clientSecret: string;
}

interface CreateSsoTokenRequest {
    client_id?: number;
    user_id?: number;
    destination?: string;
    service_id: number;
    domain_id?: number;
    sso_redirect_path?: string;
}
interface CreateSsoTokenResponse {
    result: string;
    access_token: string;
    redirect_url: string;
}

interface DeleteOAuthCredentialRequest {
    credentialId: number;
}
interface DeleteOAuthCredentialResponse {
    credentialId: number;
}

interface ListOAuthCredentialsRequest {
    grantType?: string;
    sortField?: string;
    sortOrder?: string;
    limit?: number;
}
interface ListOAuthCredentialsResponse {
    result: string;
    clients: ClientOAuthCredentials[];
}
interface ClientOAuthCredentials {
    credentialId: number;
    name: string;
    description: string;
    grantType: string;
    scope: string;
    clientIdentifier: string;
    clientSecret: string;
    uuid: string;
    serviceId: number;
    logoUri: string;
    redirectUri: string[];
    rsaKeyPairId: number;
    createdAt: Date;
    updatedAt: Date;
}

interface UpdateOAuthCredentialRequest {
    credentialId: number;
    clientApiIdentifier?: string;
    name?: string;
    description?: string;
    grantType?: string;
    scope?: string;
    serviceId?: number;
    logoUri?: string[];
    redirectUrl?: string[];
    resetSecret?: boolean;
}
interface UpdateOAuthCredentialResponse {
    result: string;
    credentialId: number;
    newClientSecret?: string;
}

interface ValidateLoginRequest {
    email: string;
    password2: string;
}
interface ValidateLoginResponse {
    result: string;
    userid: number;
    passwordhash: string;
    twoFactorEnabled: boolean;
}

declare class WhmcsAuthenticationService extends BaseModule {
    createOAuthCredential(options: CreateOAuthCredentialRequest): Promise<CreateOAuthCredentialResponse>;
    createSsoToken(options: CreateSsoTokenRequest): Promise<CreateSsoTokenResponse>;
    deleteOAuthCredential(options: DeleteOAuthCredentialRequest): Promise<DeleteOAuthCredentialResponse>;
    listOAuthCredentials(options: ListOAuthCredentialsRequest): Promise<ListOAuthCredentialsResponse>;
    updateOAuthCredential(options: UpdateOAuthCredentialRequest): Promise<UpdateOAuthCredentialResponse>;
    validateLogin(options: ValidateLoginRequest): Promise<ValidateLoginResponse>;
}

interface AcceptQuoteRequest {
    quoteid: number;
}
interface AcceptQuoteResponse {
    result: string;
    invoiceid: number;
}

interface AddBillableItemRequest {
    clientid: number;
    description: string;
    amount: number;
    invoiceaction?: string;
    recur?: number;
    recurcycle?: string;
    recurfor?: number;
    duedate?: string;
    hours?: number;
}
interface AddBillableItemResponse {
    result: string;
    billableid: number;
}

interface AddCreditRequest {
    clientid: number;
    description: string;
    amount: number;
    date?: string;
    adminid?: number;
    type?: string;
}
interface AddCreditResponse {
    result: string;
    newbalance: number;
}

interface AddInvoicePaymentRequest {
    invoiceid: number;
    transid: string;
    gateway: string;
    date: string;
    amount?: number;
    fees?: number;
    noemail?: boolean;
}
interface AddInvoicePaymentResponse {
    result: string;
}

interface AddPayMethodRequest {
    clientid: number;
    type?: string;
    description?: string;
    gateway_module_name?: string;
    card_number?: string;
    card_expiry?: string;
    card_start?: string;
    card_issue_number?: number;
    bank_name?: string;
    bank_account_type?: string;
    bank_account?: string;
    set_as_default?: boolean;
}
interface AddPayMethodResponse {
    result: string;
    clientid: number;
    paymethodid: number;
}

interface AddTransactionRequest {
    paymentmethod: string;
    userid?: number;
    invoiceid?: number;
    transid?: string;
    date?: string;
    currencyid?: number;
    description?: string;
    amountin?: number;
    fees?: number;
    amountout?: number;
    rate?: number;
    credit?: boolean;
    allowduplicatetransid?: boolean;
}
interface AddTransactionResponse {
    result: string;
}

interface ApplyCreditRequest {
    invoiceid: number;
    amount: number;
    noemail?: boolean;
}
interface ApplyCreditResponse {
    result: string;
    invoiceid: number;
    amount: number;
    invoicepaid: string;
}

interface CapturePaymentRequest {
    invoiceid: number;
    cvv?: string;
}
interface CapturePaymentResponse {
    result: string;
}

interface CreateInvoiceRequest {
    userid: number;
    status?: string;
    draft?: boolean;
    sendinvoice?: boolean;
    paymentmethod?: string;
    taxrate?: number;
    taxrate2?: number;
    date?: string;
    duedate?: string;
    notes?: string;
    itemdescriptionx?: string;
    itemamountx?: number;
    itemtaxedx?: boolean;
    autoapplycredit?: boolean;
}
interface CreateInvoiceResponse {
    result: string;
    invoiceid: number;
    status: string;
}

interface CreateQuoteRequest {
    subject: string;
    stage: string;
    validuntil: string;
    datecreated?: string;
    lineitems?: LineItem$2[];
    userid?: number;
    firstname?: string;
    lastname?: string;
    companyname?: string;
    email?: string;
    address1?: string;
    address2?: string;
    city?: string;
    state?: string;
    postcode?: string;
    country?: string;
    phonenumber?: string;
    tax_id?: string;
    currency?: number;
    proposal?: string;
    customernotes?: string;
    adminnotes?: string;
}
interface CreateQuoteResponse {
    result: string;
    quoteid: number;
}
interface LineItem$2 {
    desc: string;
    qty: number;
    up: number;
    discount: number;
    taxable: boolean;
}

interface DeletePayMethodRequest {
    clientid: number;
    paymethodid: number;
    failonremotefailure?: boolean;
}
interface DeletePayMethodResponse {
    result: string;
    paymethodid: number;
}

interface DeleteQuoteRequest {
    quoteid: number;
}
interface DeleteQuoteResponse {
    result: string;
}

interface GenInvoicesRequest {
    noemails?: boolean;
    clientid?: number;
    serviceids?: number[];
    domainids?: number[];
    addonids?: number[];
}
interface GenInvoicesResponse {
    result: string;
    numcreated: number;
    latestinvoiceid: number;
}

interface GetCreditsRequest {
    clientid: number;
}
interface GetCreditsResponse {
    result: string;
    totalresults: number;
    clientid: number;
    credits: Credit[];
}
interface Credit {
    id: number;
    date: Date;
    description: string;
    amount: number;
    relid: number;
}

interface GetInvoiceRequest {
    invoiceid: number;
}
interface GetInvoiceResponse {
    result: string;
    invoiceid: number;
    invoicenum: string;
    userid: number;
    date: string;
    duedate: string;
    datepaid: string;
    subtotal: number;
    credit: number;
    tax: number;
    tax2: number;
    total: number;
    balance: number;
    taxrate: number;
    taxrate2: number;
    status: string;
    paymentmethod: string;
    notes: string;
    ccgateway: boolean;
    items: Item$1[];
    transactions: string[];
}
interface Item$1 {
    id: number;
    type: string;
    relid: number;
    description: number;
    amount: number;
    taxed: number;
}

interface GetInvoicesRequest {
    limitstart?: number;
    limitnum?: number;
    userid?: number;
    status?: string;
    orderby?: string;
    order?: string;
}
interface GetInvoicesResponse {
    result: string;
    totalresults: number;
    startnumber: number;
    numreturned: number;
    invoices: Invoices[];
}
interface Invoices {
    id: number;
    userid: number;
    firstname: string;
    lastname: string;
    companyname: string;
    invoicenum: number;
    date: Date;
    duedate: Date;
    datepaid: Date;
    subtotal: number;
    credit: number;
    tax: number;
    tax2: number;
    total: number;
    taxrate: number;
    taxrate2: number;
    status: string;
    paymentmethod: string;
    notes: string;
    currencycode: string;
    currencyprefix: string;
    currencysuffix: string;
}

interface GetPayMethodsRequest {
    clientid: number;
    paymethodid?: number;
    type?: string;
}
interface GetPayMethodsResponse {
    result: string;
    clientid: number;
    paymethods: PayMethod[];
}
interface PayMethod {
    id: number;
    type: string;
    description: string;
    gateway_name: string;
    contact_type: string;
    contact_id: number;
    card_last_four: number;
    expiry_date: string;
    start_date: string;
    issue_number: string;
    card_type: string;
    remote_token: string;
    last_updated: string;
}

interface GetQuotesRequest {
    limitstart?: number;
    limitnum?: number;
    quoteid?: string;
    userid?: number;
    subject?: string;
    stage?: string;
    datecreated?: string;
    lastmodified?: string;
    validuntil?: string;
}
interface GetQuotesResponse {
    result: string;
    totalresults: number;
    startnumber: number;
    numreturned: number;
    quotes: Quote[];
}
interface Quote {
    id: number;
    subject: string;
    stage: string;
    validuntil: string;
    userid: string;
    firstname: string;
    lastname: string;
    companyname: string;
    email: string;
    address1: string;
    address2: string;
    city: string;
    state: string;
    postcode: string;
    country: string;
    phonenumber: string;
    currency: string;
    subtotal: number;
    tax1: number;
    tax2: number;
    total: string;
    proposal: string;
    customernotes: string;
    adminnotes: string;
    datecreated: string;
    lastmodified: string;
    datesent: string;
    dateaccepted: string;
    item: Item[];
}
interface Item {
    id: number;
    description: string;
    quantity: number;
    unitprice: number;
    discount: number;
    taxable: number;
}

interface GetTransactionsRequest {
    invoiceid?: number;
    clientid?: number;
    transid?: string;
}
interface GetTransactionsResponse {
    result: string;
    totalresults: number;
    startnumber: number;
    numreturned: number;
    transactions: Transaction[];
}
interface Transaction {
    id: number;
    userid: number;
    currency: string;
    gateway: string;
    date: string;
    description: string;
    amountin: number;
    fees: number;
    amountout: number;
    rate: number;
    transid: string;
    invoiceid: number;
    refundid: number;
}

interface SendQuoteRequest {
    quoteid: number;
}
interface SendQuoteResponse {
    result: string;
}

interface UpdateInvoiceRequest {
    invoiceid: number;
    status?: string;
    paymentmethod?: string;
    taxrate?: number;
    taxrate2?: number;
    credit?: number;
    date?: string;
    duedate?: string;
    datepaid?: string;
    notes?: string;
    itemdescription?: string[];
    itemamount?: number[];
    itemtaxed?: boolean[];
    newitemdescription?: string[];
    newitemamount?: number[];
    newitemtaxed?: boolean[];
    deletelineids?: number[];
    publish?: boolean;
    publichandsendemail?: boolean;
}
interface UpdateInvoiceResponse {
    result: string;
    invoiceid: number;
}

interface UpdatePayMethodRequest {
    clientid: number;
    paymethodid: number;
    card_number?: string;
    card_expiry?: string;
    card_start?: string;
    card_issue_number?: number;
    bank_name?: string;
    bank_account_type?: string;
    bank_code?: string;
    bank_account?: string;
    set_as_default?: boolean;
}
interface UpdatePayMethodResponse {
    result: string;
    paymethodid: number;
    clientid: number;
}

interface UpdateQuoteRequest {
    quoteid: number;
    subject?: string;
    stage?: string;
    validuntil?: string;
    datecreated?: string;
    lineitems?: LineItem$1[];
    userid?: number;
    firstname?: string;
    lastname?: string;
    companyname?: string;
    email?: string;
    address1?: string;
    address2?: string;
    city?: string;
    state?: string;
    country?: string;
    phonenumber?: string;
    tax_id?: string;
    currency?: number;
    proposal?: string;
    customernotes?: string;
    adminnotes?: string;
}
interface UpdateQuoteResponse {
    result: string;
}
interface LineItem$1 {
    desc: string;
    qty: number;
    up: number;
    discount: number;
    taxable: boolean;
}

interface UpdateTransactionRequest {
    transactionid: number;
    refundid?: number;
    userid?: number;
    invoiceid?: number;
    transid?: string;
    date?: string;
    gateway?: string;
    currency?: number;
    description?: string;
    amountin?: number;
    fees?: number;
    amountout?: number;
    rate?: number;
    credit?: boolean;
}
interface UpdateTransactionResponse {
    result: string;
    transactionid: number;
}

declare class WhmcsBillingService extends BaseModule {
    acceptQuote(options: AcceptQuoteRequest): Promise<AcceptQuoteResponse>;
    addBillableItem(options: AddBillableItemRequest): Promise<AddBillableItemResponse>;
    addCredit(options: AddCreditRequest): Promise<AddCreditResponse>;
    addInvoicePayment(options: AddInvoicePaymentRequest): Promise<AddInvoicePaymentResponse>;
    addPayMethod(options: AddPayMethodRequest): Promise<AddPayMethodResponse>;
    addTransaction(options: AddTransactionRequest): Promise<AddTransactionResponse>;
    applyCredit(options: ApplyCreditRequest): Promise<ApplyCreditResponse>;
    capturePayment(options: CapturePaymentRequest): Promise<CapturePaymentResponse>;
    createInvoice(options: CreateInvoiceRequest): Promise<CreateInvoiceResponse>;
    createQuote(options: CreateQuoteRequest): Promise<CreateQuoteResponse>;
    deletePayMethod(options: DeletePayMethodRequest): Promise<DeletePayMethodResponse>;
    deleteQuote(options: DeleteQuoteRequest): Promise<DeleteQuoteResponse>;
    genInvoices(options: GenInvoicesRequest): Promise<GenInvoicesResponse>;
    getCredits(options: GetCreditsRequest): Promise<GetCreditsResponse>;
    getInvoice(options: GetInvoiceRequest): Promise<GetInvoiceResponse>;
    getInvoices(options: GetInvoicesRequest): Promise<GetInvoicesResponse>;
    getPayMethods(options: GetPayMethodsRequest): Promise<GetPayMethodsResponse>;
    getQuotes(options: GetQuotesRequest): Promise<GetQuotesResponse>;
    getTransactions(options: GetTransactionsRequest): Promise<GetTransactionsResponse>;
    sendQuote(options: SendQuoteRequest): Promise<SendQuoteResponse>;
    updateInvoice(options: UpdateInvoiceRequest): Promise<UpdateInvoiceResponse>;
    updatePayMethod(options: UpdatePayMethodRequest): Promise<UpdatePayMethodResponse>;
    updateQuote(options: UpdateQuoteRequest): Promise<UpdateQuoteResponse>;
    updateTransaction(options: UpdateTransactionRequest): Promise<UpdateTransactionResponse>;
}

interface AddClientRequest {
    owner_user_id: number;
    firstname: string;
    lastname: string;
    companyname?: string;
    email: string;
    address1: string;
    address2?: string;
    city: string;
    state: string;
    postcode: string;
    country: string;
    phonenumber: string;
    tax_id?: string;
    password2?: string;
    securityqid?: number;
    securityqans?: string;
    currency?: number;
    groupid?: number;
    customfields?: string;
    language?: string;
    clientip?: string;
    notes?: string;
    marketingoptin?: boolean;
    noemail?: boolean;
    skipvalidation?: boolean;
}
interface AddClientResponse {
    result: string;
    clientid: string;
}

interface AddContactRequest {
    clientid?: number;
    firstname?: string;
    lastname?: string;
    companyname?: string;
    email?: string;
    address1?: string;
    address2?: string;
    city?: string;
    state?: string;
    postcode?: string;
    country?: string;
    phonenumber?: string;
    tax_id?: string;
    email_preferences: EmailPreference$2[];
}
interface AddContactResponse {
    result: string;
    contactid: number;
}
interface EmailPreference$2 {
    general?: boolean;
    product?: boolean;
    domain?: boolean;
    invoice?: boolean;
    support?: boolean;
    affiliate?: boolean;
}

interface CloseClientRequest {
    clientid: number;
}
interface CloseClientResponse {
    result: string;
    clientid: number;
}

interface DeleteClientRequest {
    clientid: number;
}
interface DeleteClientResponse {
    result: string;
    clientid: number;
}

interface DeleteContactRequest {
    contactid: number;
}
interface DeleteContactResponse {
    result: string;
    contactid: number;
}

interface GetCancelledPackagesRequest {
    limitstart?: number;
    limitnum?: number;
}
interface GetCancelledPackagesResponse {
    result: string;
    totalresults: number;
    startnumber: number;
    numreturned: number;
    packages: Package[];
}
interface Package {
    id: number;
    date: string;
    relid: number;
    reason: string;
    type: string;
    created_at: string;
    updated_at: string;
}

interface GetClientGroupsRequest {
}
interface GetClientGroupsResponse {
    result: string;
    totalresults: number;
    groups: Group[];
}
interface Group {
    id: number;
    groupname: string;
    groupcolour: string;
    discountpercent: number;
    susptermexempt: string;
    separateinvoices: string;
}

interface GetClientPasswordRequest {
    userid?: number;
    email?: string;
}
interface GetClientPasswordResponse {
    result: string;
    password: string;
}

interface GetClientsRequest {
    limitstart?: number;
    limitnum?: number;
    sorting?: string;
    search?: string;
}
interface GetClientsResponse {
    result: string;
    totalresults: number;
    startnumber: number;
    numreturned: number;
    clients: Client$1[];
}
interface Client$1 {
    id: number;
    firstname: string;
    lastname: string;
    companyname: string;
    email: string;
    datecreated: string;
    groupid: number;
    status: string;
}

interface GetClientsAddonsRequest {
    serviceid?: number;
    clientid?: number;
    addonid?: number;
}
interface GetClientsAddonsResponse {
    result: string;
    totalresults: number;
    serviceid: number;
    clientid: number;
    addons: Addon[];
}
interface Addon {
    id: number;
    userid: number;
    orderid: number;
    serviceid: number;
    addonid: number;
    name: string;
    setupfee: number;
    recurring: number;
    billingcycle: string;
    tax: number;
    status: string;
    regdate: string;
    nextduedate: string;
    nextinvoicedate: string;
    paymentmethod: string;
    paymentmethodname: string;
    notes: string;
}

interface GetClientsDetailsRequest {
    clientid?: number;
    email?: string;
    stats?: boolean;
}
interface GetClientsDetailsResponse {
    result: string;
    client: Client;
    stats: Stats;
}
interface Client {
    client_id: number;
    owner_user_id: number;
    userid: number;
    id: number;
    uuid: string;
    firstname: string;
    lastname: string;
    fullname: string;
    companyname: string;
    email: string;
    address1: string;
    address2: string;
    city: string;
    fullstate: string;
    state: string;
    postcode: string;
    countrycode: string;
    country: string;
    phonenumber: number;
    tax_id: string;
    email_preferences: {
        general: number;
        invoice: number;
        support: number;
        product: number;
        domain: number;
        affiliate: number;
    };
    statecode: string;
    countryname: string;
    phonecc: number;
    phonenumberformatted: string;
    telephoneNumber: string;
    billingcid: number;
    notes: string;
    currency: number;
    defaultgateway: string;
    groupid: number;
    status: string;
    credit: number;
    taxexempt: boolean;
    latefeeoveride: boolean;
    overideduenotices: boolean;
    separateinvoices: boolean;
    disableautocc: boolean;
    emailoptout: boolean;
    marketing_emails_opt_in: boolean;
    overrideautoclose: boolean;
    allowSingleSignOn: number;
    email_verified: boolean;
    language: string;
    isOptedInToMarketingEmails: boolean;
    lastlogin: string;
    currency_code: string;
    users: User[];
}
interface User {
    id: number;
    name: string;
    email: string;
    is_owner: boolean;
}
interface Stats {
    numdueinvoices: number;
    dueinvoicesbalance: string;
    incredit: boolean;
    creditbalance: string;
    grossRevenue: string;
    expenses: string;
    income: string;
    numoverdueinvoices: number;
    overdueinvoicesbalance: string;
    numDraftInvoices: number;
    draftInvoicesBalance: string;
    numunpaidinvoices: number;
    unpaidinvoicesamount: string;
    numpaidinvoices: number;
    paidinvoicesamount: string;
    numcancelledinvoices: number;
    cancelledinvoicesamount: string;
    numrefundedinvoices: number;
    refundedinvoicesamount: string;
    numcollectionsinvoices: number;
    collectionsinvoicesamount: string;
    numpaymentpendinginvoices: number;
    paymentpendinginvoicesamount: string;
    productsnumactivehosting: number;
    productsnumhosting: number;
    productsnumactivereseller: number;
    productsnumreseller: number;
    productsnumactiveservers: number;
    productsnumservers: number;
    productsnumactiveother: number;
    productsnumother: number;
    productsnumactive: number;
    productsnumtotal: number;
    numactivedomains: number;
    numdomains: number;
    numacceptedquotes: number;
    numquotes: number;
    numtickets: number;
    numactivetickets: number;
    numaffiliatesignups: number;
    isAffiliate: boolean;
}

interface GetClientsDomainsRequest {
    limitstart?: number;
    limitnum?: number;
    clientid?: number;
    domainid?: number;
    domain?: string;
}
interface GetClientsDomainsResponse {
    result: string;
    clientid: number;
    domainid: number;
    totalresults: number;
    startnumber: number;
    numreturned: number;
    domains: Domain[];
}
interface Domain {
    id: number;
    userid: number;
    orderid: number;
    regtype: string;
    domainname: string;
    registrar: string;
    regperiod: number;
    firstpaymentamount: number;
    recurringamount: number;
    paymentmethod: string;
    paymentmethodname: string;
    regdate: string;
    expirydate: string;
    nextduedate: string;
    status: string;
    subscriptionid: string;
    promoid: number;
    dnsmanagement: number;
    emailforwarding: number;
    idprotection: number;
    donotrenew: number;
    notes: string;
}

interface GetClientsProductsRequest {
    limitstart?: number;
    limitnum?: number;
    clientid?: number;
    serviceid?: number;
    pid?: number;
    domain?: string;
    username2?: string;
}
interface GetClientsProductsResponse {
    result: string;
    clientid: number;
    serviceid: number;
    pid: number;
    domain: string;
    totalresults: number;
    startnumber: number;
    numreturned: number;
    products: Product$1[];
}
interface Product$1 {
    id: number;
    clientid: number;
    orderid: number;
    pid: number;
    regdate: string;
    name: string;
    translated_name: string;
    groupname: string;
    translated_groupname: string;
    domain: string;
    dedicatedip: string;
    serverid: number;
    servername: string;
    serverip: string;
    serverhostname: string;
    suspensionreason: string;
    firstpaymentamount: number;
    recurringamount: number;
    paymentmethod: string;
    paymentmethodname: string;
    billingcycle: string;
    nextduedate: string;
    status: string;
    username: string;
    password: string;
    subscriptionid: string;
    promoid: number;
    overideautosuspend: string;
    overidesuspenduntil: string;
    ns1: string;
    ns2: string;
    assignedips: string;
    notes: string;
    diskusage: number;
    disklimit: number;
    bwusage: number;
    bwlimit: number;
    lastupdate: string;
    customfields: {
        customfield: [];
    };
    configoptions: {
        configoption: ConfigOption[];
    };
}
interface ConfigOption {
    id: number;
    option: string;
    type: string;
    value: string;
}

interface GetContactsRequest {
    limitstart?: number;
    limitnum?: number;
    userid?: number;
    firstname?: string;
    lastname?: string;
    companyname?: string;
    email?: string;
    address1?: string;
    address2?: string;
    city?: string;
    state?: string;
    postcode?: string;
    country?: string;
    phonenumber?: string;
}
interface GetContactsResponse {
    result: string;
    totalresults: number;
    startnumber: number;
    numreturned: number;
    contacts: Contact[];
}
interface Contact {
    id: number;
    userid: number;
    firstname: string;
    lastname: string;
    email: string;
    address1: string;
    address2: string;
    city: string;
    state: string;
    postcode: string;
    country: string;
    phonenumber: string;
    domainemails: boolean;
    generalemails: boolean;
    invoicemeails: boolean;
    productemails: boolean;
    supportemails: boolean;
    affiliateemails: boolean;
    created_at: string;
    updated_at: string;
}

interface GetEmailsRequest {
    clientid: number;
    limitstart?: number;
    limitnum?: number;
    date?: string;
    subject?: string;
}
interface GetEmailsResponse {
    result: string;
    totalresults: number;
    startnumber: number;
    numreturned: number;
    emails: Email[];
}
interface Email {
    id: number;
    userid: number;
    subject: string;
    message: string;
    date: string;
    to: string;
    cc: string;
    bcc: string;
    attachments: any;
    pending: number;
    message_data: any;
    failed: number;
    failure_reason: string;
    retry_count: number;
    created_at: string;
    updated_at: string;
    campaign_id: number;
}

interface UpdateClientRequest {
    clientid?: number;
    clientemail?: string;
    firstname?: string;
    lastname?: string;
    companyname?: string;
    email?: string;
    address1?: string;
    address2?: string;
    city?: string;
    state?: string;
    postcode?: string;
    country?: string;
    phonenumber?: string;
    tax_id?: string;
    currency?: number;
    groupid?: number;
    customfields?: string;
    language?: string;
    clientip?: string;
    notes?: string;
    status?: string;
    paymentmethod?: string;
    email_preferences?: EmailPreference$1[];
    marketingoptin?: boolean;
    clearcreditcard?: boolean;
    skipvalidation?: boolean;
    latefeeoveride?: boolean;
    overideduenotices?: boolean;
    taxexempt?: boolean;
    separateinvoices?: boolean;
    disableautocc?: boolean;
    overrideautoclose?: boolean;
}
interface UpdateClientResponse {
    result: string;
    clientid: number;
}
interface EmailPreference$1 {
    general?: boolean;
    product?: boolean;
    domain?: boolean;
    invoice?: boolean;
    support?: boolean;
    affiliate?: boolean;
}

interface UpdateContactRequest {
    contactid: number;
    firstname?: string;
    lastname?: string;
    companyname?: string;
    email?: string;
    address1?: string;
    address2?: string;
    city?: string;
    state?: string;
    postcode?: string;
    country?: string;
    phonenumber?: string;
    email_preferences?: EmailPreference[];
}
interface UpdateContactResponse {
    result: string;
    contactid: number;
}
interface EmailPreference {
    general?: boolean;
    product?: boolean;
    domain?: boolean;
    invoice?: boolean;
    support?: boolean;
    affiliate?: boolean;
}

declare class WhmcsClientService extends BaseModule {
    addClient(options: AddClientRequest): Promise<AddClientResponse>;
    addContact(options: AddContactRequest): Promise<AddContactResponse>;
    closeClient(options: CloseClientRequest): Promise<CloseClientResponse>;
    deleteClient(options: DeleteClientRequest): Promise<DeleteClientResponse>;
    deleteContact(options: DeleteContactRequest): Promise<DeleteContactResponse>;
    getCancelledPackages(options: GetCancelledPackagesRequest): Promise<GetCancelledPackagesResponse>;
    getClientGroups(options: GetClientGroupsRequest): Promise<GetClientGroupsResponse>;
    getClientPassword(options: GetClientPasswordRequest): Promise<GetClientPasswordResponse>;
    getClients(options: GetClientsRequest): Promise<GetClientsResponse>;
    getClientsAddons(options: GetClientsAddonsRequest): Promise<GetClientsAddonsResponse>;
    getClientsDetails(options: GetClientsDetailsRequest): Promise<GetClientsDetailsResponse>;
    getClientsDomains(options: GetClientsDomainsRequest): Promise<GetClientsDomainsResponse>;
    getClientsProducts(options: GetClientsProductsRequest): Promise<GetClientsProductsResponse>;
    getContacts(options: GetContactsRequest): Promise<GetContactsResponse>;
    getEmails(options: GetEmailsRequest): Promise<GetEmailsResponse>;
    updateClient(options: UpdateClientRequest): Promise<UpdateClientResponse>;
    updateContact(options: UpdateContactRequest): Promise<UpdateContactResponse>;
}

interface CreateOrUpdateTLDRequest {
    extension: string;
    id_protection?: boolean;
    dns_management?: boolean;
    email_forwarding?: boolean;
    epp_required?: boolean;
    auto_registrar?: string;
    group?: string;
    currency_code?: string;
    grace_period_days?: number;
    grace_period_fee?: any;
    redemption_period_days?: number;
    redemption_period_fee?: any;
    register?: [];
    renew?: [];
    transfer?: [];
    display_after?: string;
}
interface CreateOrUpdateTLDResponse {
    result: string;
    extension: string;
    id: number;
}

interface DomainGetLockingStatusRequest {
    domainid: number;
}
interface DomainGetLockingStatusResponse {
    result: string;
    lockstatus: string;
}

interface DomainGetNameserversRequest {
    domainid: number;
}
interface DomainGetNameserversResponse {
    result: string;
    ns1: string;
    ns2: string;
    ns3: string;
    ns4: string;
    ns5: string;
}

interface DomainGetWhoisInfoRequest {
    domainid: number;
}
interface DomainGetWhoisInfoResponse {
    result: string;
    Registrant: [];
    Admin: [];
    Tech: [];
}

interface DomainRegisterRequest {
    domainid?: number;
    domain?: string;
    idnlanguage?: string;
}
interface DomainRegisterResponse {
    result: string;
}

interface DomainReleaseRequest {
    domainid?: number;
    domain?: string;
    newtag: string;
}
interface DomainReleaseResponse {
    result: string;
}

interface DomainRenewRequest {
    domainid?: number;
    domain?: string;
    regperiod?: number;
}
interface DomainRenewResponse {
    result: string;
}

interface DomainRequestEPPRequest {
    domainid: number;
}
interface DomainRequestEPPResponse {
    result: string;
    eppcode: string;
}

interface DomainToggleIdProtectRequest {
    domainid: number;
    idprotect?: boolean;
}
interface DomainToggleIdProtectResponse {
    result: string;
}

interface DomainTransferRequest {
    domainid?: string;
    domain?: string;
    eppcode?: number;
}
interface DomainTransferResponse {
    result: string;
}

interface DomainUpdateLockingStatusRequest {
    domainid: number;
    lockstatus?: boolean;
}
interface DomainUpdateLockingStatusResponse {
    result: string;
}

interface DomainUpdateNameserversRequest {
    domainid?: number;
    domain?: string;
    ns1: string;
    ns2: string;
    ns3?: string;
    ns4?: string;
    ns5?: string;
}
interface DomainUpdateNameserversResponse {
    result: string;
}

interface DomainUpdateWhoisInfoRequest {
    domainid: number;
    xml: string;
}
interface DomainUpdateWhoisInfoResponse {
    result: string;
}

interface DomainWhoisRequest {
    domain: string;
}
interface DomainWhoisResponse {
    result: string;
    status: string;
    whois: string;
}

interface GetTLDPricingRequest {
    currencyid?: number;
    clientid?: number;
}
interface GetTLDPricingResponse {
    result: string;
    currency: [];
    pricing: [];
}

interface UpdateClientDomainRequest {
    action: string;
    domainid: number;
    dnsmanagement?: boolean;
    emailforwarding?: boolean;
    idprotection?: boolean;
    donotrenew?: boolean;
    type?: string;
    regdate?: string;
    nextduedate?: string;
    expirydate?: string;
    domain?: string;
    firstpaymentamount?: any;
    recurringamount?: any;
    registrar?: string;
    regperiod?: number;
    paymentmethod?: string;
    subscriptionid?: string;
    status?: string;
    notes?: string;
    promoid?: number;
    autorecalc?: boolean;
    updatens?: boolean;
    ns1?: string;
    ns2?: string;
    ns3?: string;
    ns4?: string;
    ns5?: string;
}
interface UpdateClientDomainResponse {
    result: string;
    domainid: number;
}

declare class WhmcsDomainsService extends BaseModule {
    createOrUpdateTLD(options: CreateOrUpdateTLDRequest): Promise<CreateOrUpdateTLDResponse>;
    domainGetLockingStatus(options: DomainGetLockingStatusRequest): Promise<DomainGetLockingStatusResponse>;
    domainGetNameservers(options: DomainGetNameserversRequest): Promise<DomainGetNameserversResponse>;
    domainGetWhoisInfo(options: DomainGetWhoisInfoRequest): Promise<DomainGetWhoisInfoResponse>;
    domainRegister(options: DomainRegisterRequest): Promise<DomainRegisterResponse>;
    domainRelease(options: DomainReleaseRequest): Promise<DomainReleaseResponse>;
    domainRenew(options: DomainRenewRequest): Promise<DomainRenewResponse>;
    domainRequestEPP(options: DomainRequestEPPRequest): Promise<DomainRequestEPPResponse>;
    domainToggleIdProtect(options: DomainToggleIdProtectRequest): Promise<DomainToggleIdProtectResponse>;
    domainTransfer(options: DomainTransferRequest): Promise<DomainTransferResponse>;
    domainUpdateLockingStatus(options: DomainUpdateLockingStatusRequest): Promise<DomainUpdateLockingStatusResponse>;
    domainUpdateNameservers(options: DomainUpdateNameserversRequest): Promise<DomainUpdateNameserversResponse>;
    domainUpdateWhoisInfo(options: DomainUpdateWhoisInfoRequest): Promise<DomainUpdateWhoisInfoResponse>;
    domainWhois(options: DomainWhoisRequest): Promise<DomainWhoisResponse>;
    getTLDPricing(options: GetTLDPricingRequest): Promise<GetTLDPricingResponse>;
    updateClientDomain(options: UpdateClientDomainRequest): Promise<UpdateClientDomainResponse>;
}

interface ActivateModuleRequest {
    moduleType: string;
    moduleName: string;
    parameters?: [];
}
interface ActivateModuleResponse {
    result: string;
}

interface DeactivateModuleRequest {
    moduleType: string;
    moduleName: string;
    newGateway?: string;
}
interface DeactivateModuleResponse {
    result: string;
}

interface GetModuleConfigurationParametersRequest {
    moduleType: string;
    moduleName: string;
}
interface GetModuleConfigurationParametersResponse {
    result: string;
    parameters: [];
}

interface GetModuleQueueRequest {
    relatedId?: number;
    serviceType?: string;
    moduleName?: string;
    moduleAction?: string;
    since?: string;
}
interface GetModuleQueueResponse {
    result: string;
    count: number;
    queue: [];
}

interface UpdateModuleConfigurationRequest {
    moduleType: string;
    moduleName: string;
    parameters?: [];
}
interface UpdateModuleConfigurationResponse {
    result: string;
}

declare class WhmcsModuleService extends BaseModule {
    activateModule(options: ActivateModuleRequest): Promise<ActivateModuleResponse>;
    deactivateModule(options: DeactivateModuleRequest): Promise<DeactivateModuleResponse>;
    getModuleConfigurationParameters(options: GetModuleConfigurationParametersRequest): Promise<GetModuleConfigurationParametersResponse>;
    getModuleQueue(options: GetModuleQueueRequest): Promise<GetModuleQueueResponse>;
    updateModuleConfiguration(options: UpdateModuleConfigurationRequest): Promise<UpdateModuleConfigurationResponse>;
}

interface AcceptOrderRequest {
    orderid: number;
    serverid?: number;
    serviceusername?: string;
    servicepassword?: string;
    registrar?: string;
    sendregistrar?: boolean;
    autosetup?: boolean;
    sendemail?: boolean;
}
interface AcceptOrderResponse {
    result: string;
}

interface AddOrderRequest {
    clientid: number;
    paymentmethod: string;
    pid?: number[];
    domain?: string[];
    billingcycle?: string[];
    domaintype?: string[];
    regperiod?: number[];
    idnlanguage?: string[];
    eppcode?: string[];
    nameserver1?: string;
    nameserver2?: string;
    nameserver3?: string;
    nameserver4?: string;
    nameserver5?: string;
    customfields?: string[];
    configoptions?: string[];
    priceoverride?: number[];
    promocode?: string;
    promooverride?: boolean;
    affid?: number;
    noinvoice?: boolean;
    noinvoiceemail?: boolean;
    noemail?: boolean;
    addons?: string[];
    hostname?: string[];
    ns1prefix?: string[];
    ns2prefix?: string[];
    rootpw?: string[];
    contactid?: number;
    dnsmanagement?: boolean[];
    domainfields?: string[];
    emailforwarding?: boolean[];
    idprotection?: boolean[];
    domainpriceoverride?: number[];
    domainrenewoverride?: number[];
    domainrenewals?: any[];
    clientip?: string;
    addonid?: number;
    serviceid?: number;
    addonids?: number[];
    serviceids?: number[];
}
interface AddOrderResponse {
    result: string;
    orderid: number;
    serviceids: string;
    addonids: string;
    domainids: string;
    invoiceid: number;
}

interface CancelOrderRequest {
    orderid: number;
    cancelsub?: string;
    noemail?: boolean;
}
interface CancelOrderResponse {
    result: string;
}

interface DeleteOrderRequest {
    orderid: number;
}
interface DeleteOrderResponse {
    result: string;
}

interface FraudOrderRequest {
    orderid: number;
    cancelsub: boolean;
}
interface FraudOrderResponse {
    result: string;
}

interface GetOrderStatusesRequest {
}
interface GetOrderStatusesResponse {
    result: string;
    totalresults: number;
    statuses: [];
}

interface GetOrdersRequest {
    limitstart?: number;
    limitnum?: number;
    id?: number;
    userid?: number;
    status?: string;
}
interface GetOrdersResponse {
    result: string;
    totalresults: number;
    startnumber: number;
    numreturned: number;
    orders: Order[];
}
interface Order {
    id: number;
    ordernum: number;
    userid: number;
    contactid: number;
    date: string;
    nameservers: string;
    transfersecret: string;
    renewals: string;
    promocode: string;
    promotype: string;
    promovalue: string;
    orderdata: string;
    amount: number;
    paymentmethod: string;
    invoiceid: number;
    status: string;
    ipaddress: string;
    fraudmodule: string;
    fraudoutput: string;
    notes: string;
    paymentmethodname: string;
    paymentstatus: string;
    name: string;
    currencyprefix: string;
    currencysuffix: string;
    frauddata: string;
    lineitems: LineItem[];
}
interface LineItem {
    type: string;
    relid: number;
    producttype: string;
    product: string;
    domain: string;
    billingcycle: string;
    amount: string;
    status: string;
}

interface GetProductsRequest {
    pid?: string;
    gid: number;
    module: string;
}
interface GetProductsResponse {
    result: string;
    totalresults: number;
    startnumber: any;
    number: any;
    numreturned: number;
    products: Product[];
}
interface Product {
    pid: number;
    gid: number;
    type: string;
    name: string;
    description: string;
    module: string;
    paytype: string;
    pricing: object;
    customfields: object;
    configoptions: object;
}

interface GetPromotionsRequest {
    code?: string;
}
interface GetPromotionsResponse {
    result: string;
    totalresults: number;
    promotions: Promotion[];
}
interface Promotion {
    id: number;
    code: string;
    type: string;
    recurring: number;
    value: number;
    cycles: string;
    appliesto: string;
    requires: string;
    requiresexisting: number;
    startdate: string;
    expirationdate: string;
    maxuses: number;
    uses: number;
    lifetimepromo: number;
    applyonce: number;
    newsignups: number;
    existingclient: number;
    onceperclient: number;
    recurfor: number;
    upgrades: number;
    upgradeconfig: string;
    notes: string;
}

interface OrderFraudCheckRequest {
    orderid: number;
    ipaddress?: string;
}
interface OrderFraudCheckResponse {
    result: string;
    status: string;
    module: string;
    results: string;
}

interface PendingOrderRequest {
    orderid: number;
}
interface PendingOrderResponse {
    result: string;
}

declare class WhmcsOrdersService extends BaseModule {
    acceptOrder(options: AcceptOrderRequest): Promise<AcceptOrderResponse>;
    addOrder(options: AddOrderRequest): Promise<AddOrderResponse>;
    cancelOrder(options: CancelOrderRequest): Promise<CancelOrderResponse>;
    deleteOrder(options: DeleteOrderRequest): Promise<DeleteOrderResponse>;
    fraudOrder(options: FraudOrderRequest): Promise<FraudOrderResponse>;
    getOrders(options: GetOrdersRequest): Promise<GetOrdersResponse>;
    getOrderStatuses(options: GetOrderStatusesRequest): Promise<GetOrderStatusesResponse>;
    getProducts(options: GetProductsRequest): Promise<GetProductsResponse>;
    getPromotions(options: GetPromotionsRequest): Promise<GetPromotionsResponse>;
    orderFraudCheck(options: OrderFraudCheckRequest): Promise<OrderFraudCheckResponse>;
    pendingOrder(options: PendingOrderRequest): Promise<PendingOrderResponse>;
}

interface AddProductRequest {
    name: string;
    gid: number;
    type?: string;
    stockcontrol?: boolean;
    qty?: number;
    paytype?: string;
    hidden?: boolean;
    showdomainoptions?: boolean;
    tax?: boolean;
    isFeatured?: boolean;
    proratabilling?: boolean;
    description?: string;
    welcomeemail?: number;
    proratadate?: number;
    proratachargenextmonth?: number;
    subdomain?: string;
    autosetup?: string;
    module?: string;
    servergroupid?: number;
    configoption1?: any;
    configoption2?: any;
    configoption3?: any;
    configoption4?: any;
    configoption5?: any;
    configoption6?: any;
    order?: number;
    pricing?: any[];
}
interface AddProductResponse {
    result: string;
    pid: number;
}

declare class WhmcsProductsService extends BaseModule {
    addProduct(options: AddProductRequest): Promise<AddProductResponse>;
}

interface AddProjectMessageRequest {
    prodictid: number;
    message: string;
    adminid?: number;
}
interface AddProjectMessageResponse {
    result: string;
    message: string;
}

interface AddProjectTaskRequest {
    projectid: number;
    duedate: string;
    adminid?: number;
    task?: string;
    notes?: string;
    completed?: boolean;
    billed?: boolean;
}
interface AddProjectTaskResponse {
    result: string;
    message: string;
}

interface CreateProjectRequest {
    title: string;
    adminid: number;
    userid?: number;
    status?: string;
    created?: string;
    duedate?: string;
    completed?: boolean;
    ticketids?: string;
    invoiceids?: string;
}
interface CreateProjectResponse {
    result: string;
    message: string;
}

interface DeleteProjectTaskRequest {
    projectid: number;
    taskid: number;
}
interface DeleteProjectTaskResponse {
    result: string;
    message: number;
}

interface EndTaskTimerRequest {
    timerid: number;
    projectid?: number;
    adminid?: number;
    end_time?: number;
}
interface EndTaskTimerResponse {
    result: string;
    mesage: string;
}

interface GetProjectRequest {
    projectid: number;
}
interface GetProjectResponse {
    result: string;
    projectinfo: ProjectInfo[];
    tasks: Task[];
    messages: Message[];
}
interface ProjectInfo {
    id: number;
    userid: number;
    title: string;
    attachments: string;
    ticketids: string;
    invoiceids: string;
    notes: string;
    adminid: number;
    status: string;
    created: string;
    duedate: string;
    completed: number;
    lastmodified: string;
}
interface Task {
    id: number;
    projectid: number;
    task: string;
    notes: string;
    adminid: number;
    created: string;
    duedate: string;
    completed: number;
    billed: number;
    order: number;
    timelogs: TimeLog[];
}
interface TimeLog {
    id: number;
    projectid: number;
    taskid: number;
    adminid: number;
    start: number;
    end: number;
    donotbill: number;
    starttime: string;
    endtime: string;
}
interface Message {
    id: number;
    projectid: number;
    date: string;
    message: string;
    attachments: string;
    adminid: number;
}

interface GetProjectsRequest {
    limitstart?: number;
    limitnum?: number;
    userid?: number;
    title?: string;
    ticketids?: string;
    invoiceids?: string;
    notes?: string;
    adminid?: number;
    status?: string;
    created?: string;
    duedate?: string;
    completed?: boolean;
    lastmodified?: string;
}
interface GetProjectsResponse {
    result: string;
    totalresults: number;
    startnumber: number;
    numreturned: number;
    projects: Project[];
}
interface Project {
    id: number;
    userid: number;
    title: string;
    ticketids: string;
    invoiceids: string;
    notes: string;
    adminid: number;
    status: string;
    created: string;
    duedate: string;
    completed: number;
    lastmodified: string;
    watchers: string;
}

interface StartTaskTimerRequest {
    timerid: number;
    projectid: number;
    adminid?: number;
    start_time?: number;
    end_time?: number;
}
interface StartTaskTimerResponse {
    result: string;
    message: string;
}

interface UpdateProjectRequest {
    projectid: number;
    adminid?: number;
    userid?: number;
    status?: string;
    created?: string;
    duedate?: string;
    completed?: boolean;
    title?: string;
    ticketids?: string;
    invoiceids?: string;
    notes?: string;
}
interface UpdateProjectResponse {
    result: string;
    message: string;
}

interface UpdateProjectTaskRequest {
    taskid: number;
    projectid?: number;
    duedate?: string;
    adminid?: number;
    task?: string;
    notes?: string;
    completed?: boolean;
}
interface UpdateProjectTaskResponse {
    result: string;
    message: string;
}

declare class WhmcsProjectManagementService extends BaseModule {
    addProjectMessage(options: AddProjectMessageRequest): Promise<AddProjectMessageResponse>;
    addProjectTask(options: AddProjectTaskRequest): Promise<AddProjectTaskResponse>;
    createProject(options: CreateProjectRequest): Promise<CreateProjectResponse>;
    deleteProjectTask(options: DeleteProjectTaskRequest): Promise<DeleteProjectTaskResponse>;
    endTaskTimer(options: EndTaskTimerRequest): Promise<EndTaskTimerResponse>;
    getProject(options: GetProjectRequest): Promise<GetProjectResponse>;
    getProjects(options: GetProjectsRequest): Promise<GetProjectsResponse>;
    startTaskTimer(options: StartTaskTimerRequest): Promise<StartTaskTimerResponse>;
    updateProject(options: UpdateProjectRequest): Promise<UpdateProjectResponse>;
    updateProjectTask(options: UpdateProjectTaskRequest): Promise<UpdateProjectTaskResponse>;
}

interface GetHealthStatusRequest {
    fetchStatus?: boolean;
}
interface GetHealthStatusResponse {
    result: string;
}

interface GetServersRequest {
    fetchStatus?: boolean;
}
interface GetServersResponse {
    result: string;
}

declare class WhmcsServersService extends BaseModule {
    getHealthStatus(options: GetHealthStatusRequest): Promise<GetHealthStatusResponse>;
    getServers(options: GetServersRequest): Promise<GetServersResponse>;
}

interface ModuleChangePackageRequest {
    serviceid: number;
}
interface ModuleChangePackageResponse {
    result: string;
}

interface ModuleChangePwRequest {
    serviceid: number;
    servicepassword?: string;
}
interface ModuleChangePwResponse {
    result: string;
}

interface ModuleCreateRequest {
    serviceid: number;
}
interface ModuleCreateResponse {
    result: string;
}

interface ModuleCustomRequest {
    serviceid: number;
    func_name: string;
}
interface ModuleCustomResponse {
    result: string;
}

interface ModuleSuspendRequest {
    serviceid: number;
    suspendreason?: string;
}
interface ModuleSuspendResponse {
    result: string;
}

interface ModuleTerminateRequest {
    serviceid: number;
}
interface ModuleTerminateResponse {
    result: string;
}

interface ModuleUnsuspendRequest {
    serviceid: number;
}
interface ModuleUnsuspendResponse {
    result: string;
}

interface UpdateClientProductRequest {
    serviceid: number;
    pid?: number;
    serverid?: number;
    regdate?: string;
    nextduedate?: string;
    terminationDate?: string;
    completedDate?: string;
    domain?: string;
    firstpaymentamount?: number;
    recurringamount?: number;
    paymentmethod?: string;
    billingcycle?: string;
    subscriptionid?: string;
    status?: string;
    notes?: string;
    serviceusername?: string;
    servicepassword?: string;
    overideautosuspend?: string;
    overidesuspenduntil?: string;
    ns1?: string;
    ns2?: string;
    dedicatedip?: string;
    assignedips?: string;
    diskusage?: number;
    disklimit?: number;
    bwusage?: number;
    bwlimit?: number;
    suspendreason?: string;
    promoid?: number;
    unset?: any[];
    autorecalc?: boolean;
    customfields?: string;
    configoptions?: string;
}
interface UpdateClientProductResponse {
    result: string;
    serviceid: number;
}

interface UpgradeProductRequest {
    serviceid: number;
    calconly?: boolean;
    paymentmethod: string;
    type: string;
    newproductid?: number;
    newproductbillingcycle?: string;
    promocode?: string;
    configoptions?: any[];
}
interface UpgradeProductResponse {
    result: string;
    upgradeinprogress: boolean;
}

declare class WhmcsServiceService extends BaseModule {
    moduleChangePackage(options: ModuleChangePackageRequest): Promise<ModuleChangePackageResponse>;
    moduleChangePw(options: ModuleChangePwRequest): Promise<ModuleChangePwResponse>;
    moduleCreate(options: ModuleCreateRequest): Promise<ModuleCreateResponse>;
    moduleCustom(options: ModuleCustomRequest): Promise<ModuleCustomResponse>;
    moduleSuspend(options: ModuleSuspendRequest): Promise<ModuleSuspendResponse>;
    moduleTerminate(options: ModuleTerminateRequest): Promise<ModuleTerminateResponse>;
    moduleUnsuspend(options: ModuleUnsuspendRequest): Promise<ModuleUnsuspendResponse>;
    updateClientProduct(options: UpdateClientProductRequest): Promise<UpdateClientProductResponse>;
    upgradeProduct(options: UpgradeProductRequest): Promise<UpgradeProductResponse>;
}

interface AddAnnouncementRequest {
    date: string;
    title: string;
    announcement: string;
    published?: boolean;
}
interface AddAnnouncementResponse {
    result: string;
    announcementid: number;
}

interface AddCancelRequestRequest {
    serviceid: number;
    type?: string;
    reason?: string;
}
interface AddCancelRequestResponse {
    result: string;
    serviceid: number;
    userid: number;
}

interface AddClientNoteRequest {
    userid: number;
    notes: string;
    sticky?: boolean;
}
interface AddClientNoteResponse {
    result: string;
    noteid: number;
}

interface AddTicketNoteRequest {
    message: string;
    ticketnum?: string;
    ticketid?: number;
    markdown?: boolean;
    attachments?: any[];
    created?: string;
}
interface AddTicketNoteResponse {
    result: string;
}

interface AddTicketReplyRequest {
    ticketid: number;
    message: string;
    markdown?: boolean;
    clientid?: number;
    contactid?: number;
    adminusername?: string;
    name?: string;
    email?: string;
    status?: string;
    noemail?: boolean;
    attachments?: any[];
    created?: string;
}
interface AddTicketReplyResponse {
    result: string;
}

interface BlockTicketSenderRequest {
    ticketid: number;
    delete?: boolean;
}
interface BlockTicketSenderResponse {
    result: string;
}

interface DeleteAnnouncementRequest {
    announcementid: number;
}
interface DeleteAnnouncementResponse {
    result: string;
}

interface DeleteTicketRequest {
    ticketid: number;
}
interface DeleteTicketResponse {
    result: string;
}

interface DeleteTicketNoteRequest {
    noteid: number;
}
interface DeleteTicketNoteResponse {
    result: string;
}

interface DeleteTicketReplyRequest {
    ticketid: number;
    replyid: number;
}
interface DeleteTicketReplyResponse {
    result: string;
}

interface GetAnnouncementsRequest {
    limitstart?: number;
    limitnum?: number;
}
interface GetAnnouncementsResponse {
    result: string;
    totalresults: number;
    startnumber: number;
    numreturned: number;
    announcements: Announcement[];
}
interface Announcement {
    id: number;
    date: string;
    title: string;
    announcement: string;
    published: number;
    parentid: number;
    language: string;
    created_at: string;
    updated_at: string;
}

interface MergeTicketRequest {
    ticketid: number;
    mergeticketids: string;
    newsubject?: string;
}
interface MergeTicketResponse {
    result: string;
    ticketid: number;
}

interface OpenTicketRequest {
    deptid: number;
    subject: string;
    message: string;
    clientid?: number;
    contactid?: number;
    name?: string;
    email?: string;
    priority?: string;
    created?: string;
    serviceid?: number;
    domainid?: number;
    admin?: boolean;
    markdown?: boolean;
    customfields?: string;
    attachments: any[];
}
interface OpenTicketResponse {
    result: string;
    id: number;
    tid: string;
    c: string;
}

interface UpdateTicketRequest {
    ticketid: number;
    deptid?: number;
    status?: string;
    subject?: string;
    userid?: number;
    name?: string;
    email?: string;
    cc?: string;
    priority?: string;
    created?: string;
    flag?: number;
    removeFlag?: boolean;
    message?: string;
    markdown?: boolean;
    customfields?: string;
}
interface UpdateTicketResponse {
    result: string;
    ticketid: number;
}

interface UpdateTicketReplyRequest {
    replyid: number;
    message: string;
    markdown?: boolean;
    created?: string;
}
interface UpdateTicketReplyResponse {
    result: string;
    replyid: number;
}

declare class WhmcsSupportService extends BaseModule {
    addAnnouncement(options: AddAnnouncementRequest): Promise<AddAnnouncementResponse>;
    addCancelRequest(options: AddCancelRequestRequest): Promise<AddCancelRequestResponse>;
    addClientNote(options: AddClientNoteRequest): Promise<AddClientNoteResponse>;
    addTicketNote(options: AddTicketNoteRequest): Promise<AddTicketNoteResponse>;
    addTicketReply(options: AddTicketReplyRequest): Promise<AddTicketReplyResponse>;
    blockTicketSender(options: BlockTicketSenderRequest): Promise<BlockTicketSenderResponse>;
    deleteAnnouncement(options: DeleteAnnouncementRequest): Promise<DeleteAnnouncementResponse>;
    deleteTicket(options: DeleteTicketRequest): Promise<DeleteTicketResponse>;
    deleteTicketNote(options: DeleteTicketNoteRequest): Promise<DeleteTicketNoteResponse>;
    deleteTicketReply(options: DeleteTicketReplyRequest): Promise<DeleteTicketReplyResponse>;
    getAnnouncements(options: GetAnnouncementsRequest): Promise<GetAnnouncementsResponse>;
    mergeTicket(options: MergeTicketRequest): Promise<MergeTicketResponse>;
    openTicket(options: OpenTicketRequest): Promise<OpenTicketResponse>;
    updateTicket(options: UpdateTicketRequest): Promise<UpdateTicketResponse>;
    updateTicketReply(options: UpdateTicketReplyRequest): Promise<UpdateTicketReplyResponse>;
}

interface AddBannedIpRequest {
    ip: string;
    reason: string;
    days: number;
    expires?: string;
}
interface AddBannedIpResponse {
    result: string;
    banid: number;
}

interface DecryptPasswordRequest {
    password2: string;
}
interface DecryptPasswordResponse {
    result: string;
}

interface EncryptPasswordRequest {
    password2: string;
}
interface EncryptPasswordResponse {
    result: string;
}

interface GetActivityLogRequest {
    limitstart?: number;
    limitnum?: number;
    userid?: number;
    date?: string;
    user?: string;
    description?: string;
    ipaddress?: string;
}
interface GetActivityLogResponse {
    result: string;
    totalresults: number;
    startnumber: number;
    activity: Entry[];
}
interface Entry {
    id: number;
    userid: number;
    date: string;
    description: string;
    username: string;
    ipadress: string;
}

interface GetAdminDetailsRequest {
}
interface GetAdminDetailsResponse {
    result: string;
    adminid: number;
    name: string;
    notes: string;
    signature: string;
    allowedpermissions: string;
    departments: string;
    requesttime: string;
    whmcs: {
        version: string;
        canonicalversion: string;
    };
}

interface GetAdminUsersRequest {
    roleid?: number;
    email?: string;
    include_disabled?: boolean;
}
interface GetAdminUsersResponse {
    result: string;
    count: number;
    admin_users: AdminUser$1[];
}
interface AdminUser$1 {
    id: number;
    uuid: string;
    roleId: number;
    username: string;
    twoFactorAuthModule: string;
    firstname: string;
    lastname: string;
    email: string;
    signature: string;
    notes: string;
    template: string;
    language: string;
    isDisabled: number;
    loginAttempts: number;
    supportDepartmentIds: string[];
    receivesTicketNotifications: string[];
    homepageWidgetsConfig: string;
    hiddenHomepageWidgets: string;
    created_at: string;
    updated_at: string;
    fullName: string;
    gravatarHash: string;
}

interface GetAutomationLogRequest {
    startdate?: string;
    enddate?: string;
    namespace?: string;
}
interface GetAutomationLogResponse {
    result: string;
    currentDatetime: string;
    lastDailyCronInvocationTime: string;
    startdate: string;
    enddate: string;
    statistics: any[];
}

interface GetConfigurationValueRequest {
    setting: string;
}
interface GetConfigurationValueResponse {
    result: string;
    setting: string;
    value: string;
}

interface GetCurrenciesRequest {
}
interface GetCurrenciesResponse {
    result: string;
    totalresults: number;
    currencies: Currency[];
}
interface Currency {
    id: string;
    code: string;
    prefix: string;
    suffix: string;
    format: string;
    rate: string;
}

interface GetEmailTemplatesRequest {
    type?: string;
    language?: string;
}
interface GetEmailTemplatesResponse {
    result: string;
    totalresults: number;
    emailtemplates: EmailTemplate[];
}
interface EmailTemplate {
    id: number;
    name: string;
    subject: string;
    custom: number;
}

interface GetPaymentMethodsRequest {
}
interface GetPaymentMethodsResponse {
    result: string;
    totalresults: number;
    paymentmethods: PaymentMethod[];
}
interface PaymentMethod {
    module: string;
    displayname: string;
}

interface GetStaffOnlineRequest {
}
interface GetStaffOnlineResponse {
    result: string;
    totalresults: number;
    staffonline: AdminUser[];
}
interface AdminUser {
    adminusername: string;
    logintime: string;
    ipaddress: string;
    lastvisit: string;
}

interface GetStatsRequest {
    timeline_days: number;
}
interface GetStatsResponse {
    result: string;
    income_today: number;
    income_thismonth: number;
    income_thisyear: number;
    income_alltime: number;
    orders_pending: number;
    orders_today_cancelled: number;
    orders_today_pending: number;
    orders_today_fraud: number;
    orders_today_active: number;
    orders_today_total: number;
    orders_yesterday_cancelled: number;
    orders_yesterday_pending: number;
    orders_yesterday_fraud: number;
    orders_yesterday_active: number;
    orders_yesterday_total: number;
    orders_thismonth_total: number;
    orders_thisyear_total: number;
    tickets_allactive: number;
    tickets_awaitingreply: number;
    tickets_flaggedtickets: number;
    tickets_open: number;
    tickets_answered: number;
    tickets_customerreply: number;
    tickets_closed: number;
    tickets_onhold: number;
    tickets_inprogress: number;
    cancellations_pending: number;
    todoitems_due: number;
    networkissues_open: number;
    quotes_valid: number;
    staff_online: number;
    timeline_data: number;
}

interface GetToDoItemStatusesRequest {
}
interface GetToDoItemStatusesResponse {
    result: string;
    totalresults: number;
    todoitemstatuses: Status$1[];
}
interface Status$1 {
    type: string;
    count: number;
    overdue: number;
}

interface GetToDoItemsRequest {
    limitstart: number;
    limitnum: number;
    status: string;
}
interface GetToDoItemsResponse {
    result: string;
    totalresults: number;
    startnumber: number;
    items: any[];
}

interface LogActivityRequest {
    clientid?: number;
    description: string;
}
interface LogActivityResponse {
    result: string;
}

interface SendAdminEmailRequest {
    messagename: string;
    custommessage: string;
    customsubject: string;
    type: string;
    deptid: number;
    mergefields: any[];
}
interface SendAdminEmailResponse {
    result: string;
}

interface SendEmailRequest {
    messagename?: string;
    id?: number;
    customtype?: string;
    custommessage?: string;
    cstuomsubject?: string;
    customvars?: any[];
}
interface SendEmailResponse {
    result: string;
}

interface SetConfigurationValueRequest {
    setting: string;
    value: string;
}
interface SetConfigurationValueResponse {
    result: string;
    value_changed: boolean;
}

interface TriggerNotificationEventRequest {
    notifications_identifier?: string;
    title?: string;
    message?: string;
    url?: string;
    status?: string;
    statusStyle?: string;
    attributes?: any[];
}
interface TriggerNotificationEventResponse {
    result: string;
}

interface UpdateAdminNotesRequest {
    notes: string;
}
interface UpdateAdminNotesResponse {
    result: string;
}

interface UpdateAnnouncementRequest {
    announcementid: string;
    title?: string;
    announcement?: string;
    date?: string;
    published?: boolean;
}
interface UpdateAnnouncementResponse {
    result: string;
    announcementid: number;
}

interface UpdateToDoItemRequest {
    itemid: number;
    adminid: number;
    status?: string;
    date?: number;
    title?: string;
    description?: string;
    duedate?: number;
}
interface UpdateToDoItemResponse {
    result: string;
    itemid: number;
}

interface WhmcsDetailsRequest {
}
interface WhmcsDetailsResponse {
    result: string;
    whmcs: {
        version: string;
        canonicalversion: string;
    };
}

declare class WhmcsSystemService extends BaseModule {
    addBannedIp(options: AddBannedIpRequest): Promise<AddBannedIpResponse>;
    decryptPassword(options: DecryptPasswordRequest): Promise<DecryptPasswordResponse>;
    encryptPassword(options: EncryptPasswordRequest): Promise<EncryptPasswordResponse>;
    getActivityLog(options: GetActivityLogRequest): Promise<GetActivityLogResponse>;
    getAdminDetails(options: GetAdminDetailsRequest): Promise<GetAdminDetailsResponse>;
    getAdminUsers(options: GetAdminUsersRequest): Promise<GetAdminUsersResponse>;
    getAutomationLog(options: GetAutomationLogRequest): Promise<GetAutomationLogResponse>;
    getConfigurationValue(options: GetConfigurationValueRequest): Promise<GetConfigurationValueResponse>;
    getCurrencies(options: GetCurrenciesRequest): Promise<GetCurrenciesResponse>;
    getEmailTemplates(options: GetEmailTemplatesRequest): Promise<GetEmailTemplatesResponse>;
    getPaymentMethods(options: GetPaymentMethodsRequest): Promise<GetPaymentMethodsResponse>;
    getStaffOnline(options: GetStaffOnlineRequest): Promise<GetStaffOnlineResponse>;
    getStats(options: GetStatsRequest): Promise<GetStatsResponse>;
    getToDoItems(options: GetToDoItemsRequest): Promise<GetToDoItemsResponse>;
    getToDoItemStatuses(options: GetToDoItemStatusesRequest): Promise<GetToDoItemStatusesResponse>;
    logActivity(options: LogActivityRequest): Promise<LogActivityResponse>;
    sendAdminEmail(options: SendAdminEmailRequest): Promise<SendAdminEmailResponse>;
    sendEmail(options: SendEmailRequest): Promise<SendEmailResponse>;
    setConfigurationValue(options: SetConfigurationValueRequest): Promise<SetConfigurationValueResponse>;
    triggerNotificationEvent(options: TriggerNotificationEventRequest): Promise<TriggerNotificationEventResponse>;
    updateAdminNotes(options: UpdateAdminNotesRequest): Promise<UpdateAdminNotesResponse>;
    updateAnnouncement(options: UpdateAnnouncementRequest): Promise<UpdateAnnouncementResponse>;
    updateToDoItem(options: UpdateToDoItemRequest): Promise<UpdateToDoItemResponse>;
    whmcsDetails(options: WhmcsDetailsRequest): Promise<WhmcsDetailsResponse>;
}

interface GetSupportDepartmentsRequest {
    ignore_dept_assignments?: boolean;
}
interface GetSupportDepartmentsResponse {
    result: string;
    totalresults: number;
    departments: Department[];
}
interface Department {
    id: number;
    name: string;
    awaitingreply: number;
    opentickets: number;
}

interface GetSupportStatusesRequest {
    deptid?: number;
}
interface GetSupportStatusesResponse {
    result: string;
    totalresults: number;
    statuses: Status[];
}
interface Status {
    title: string;
    count: number;
    color: string;
}

interface GetTicketRequest {
    ticketnum?: string;
    ticketid?: number;
    repliessort?: string;
}
interface GetTicketResponse {
    result: string;
    ticketid: number;
    tid: string;
    c: string;
    deptid: number;
    deptname: string;
    userid: number;
    contactid: number;
    name: string;
    email: string;
    requestor_name: string;
    requestor_type: string;
    requestor_email: string;
    cc: string;
    date: string;
    subject: string;
    status: string;
    priority: string;
    admin: string;
    lastreply: string;
    flag: number;
    service: string;
    replies: Reply[];
    notes: Note$1[];
}
interface Reply {
    replyid: number;
    userid: number;
    contactid: number;
    name: string;
    email: string;
    requestor_name: string;
    requestor_email: string;
    requestor_type: string;
    date: string;
    message: string;
    attachment: string;
    attachments: Attachment[];
    attachments_removed: boolean;
    admin: string;
}
interface Attachment {
    filename: string;
    index: number;
}
interface Note$1 {
    noteid: number;
    date: string;
    message: string;
    attachment: string;
    attachments: Attachment[];
    attachments_removed: boolean;
    admin: string;
}

interface GetTicketAttachmentRequest {
    relatedid: number;
    type: string;
    index: number;
}
interface GetTicketAttachmentResponse {
    result: string;
    filename: string;
    data: string;
}

interface GetTicketCountsRequest {
    ignoreDepartmentAssignments?: boolean;
    includeCountsByStatus?: boolean;
}
interface GetTicketCountsResponse {
    result: string;
    filteredDepartments: number[];
    allActive: number;
    awaitingReply: number;
    flaggedTickets: number;
    status: any;
}

interface GetTicketNotesRequest {
    ticketid: number;
}
interface GetTicketNotesResponse {
    result: string;
    totalresults: number;
    notes: Note[];
}
interface Note {
    id: number;
    admin: string;
    date: string;
    message: string;
    attachment: string;
    attachments_removed: boolean;
}

interface GetTicketPredefinedCatsRequest {
}
interface GetTicketPredefinedCatsResponse {
    result: string;
    totalresults: number;
    categories: Category[];
}
interface Category {
    id: number;
    parentid: number;
    name: string;
    replycount: number;
}

interface GetTicketPredefinedRepliesRequest {
    catid?: number;
}
interface GetTicketPredefinedRepliesResponse {
    result: string;
    totalresults: number;
    predefinedreplies: PredefinedReply[];
}
interface PredefinedReply {
    name: string;
    reply: string;
}

interface GetTicketsRequest {
    limitstart?: number;
    limitnum?: number;
    deptid?: number;
    clientid?: number;
    email?: string;
    status?: string;
    subject?: string;
    ignore_dept_assignments?: boolean;
}
interface GetTicketsResponse {
    result: string;
    totalresults: number;
    startnumber: number;
    numreturned: number;
    tickets: any[];
    requestor_name: string;
    requestor_type: string;
    requestor_email: string;
    owner_name: string;
}

declare class WhmcsTicketsService extends BaseModule {
    getSupportDepartments(options: GetSupportDepartmentsRequest): Promise<GetSupportDepartmentsResponse>;
    getSupportStatuses(options: GetSupportStatusesRequest): Promise<GetSupportStatusesResponse>;
    getTicket(options: GetTicketRequest): Promise<GetTicketResponse>;
    getTicketAttachment(options: GetTicketAttachmentRequest): Promise<GetTicketAttachmentResponse>;
    getTicketCounts(options?: GetTicketCountsRequest): Promise<GetTicketCountsResponse>;
    getTicketNotes(options: GetTicketNotesRequest): Promise<GetTicketNotesResponse>;
    getTicketPredefinedCats(options: GetTicketPredefinedCatsRequest): Promise<GetTicketPredefinedCatsResponse>;
    getTicketPredefinedReplies(options: GetTicketPredefinedRepliesRequest): Promise<GetTicketPredefinedRepliesResponse>;
    getTickets(options: GetTicketsRequest): Promise<GetTicketsResponse>;
}

interface AddUserRequest {
    firstname: string;
    lastname: string;
    email: string;
    password2: string;
    language?: string;
}
interface AddUserResponse {
    result: string;
    user_id: number;
}

interface CreateClientInviteRequest {
    client_id: string;
    email: number;
    permissions: string;
}
interface CreateClientInviteResponse {
    result: string;
}

interface DeleteUserClientRequest {
    user_id: number;
    client_id: number;
}
interface DeleteUserClientResponse {
    result: string;
}

interface GetPermissionsListRequest {
}
interface GetPermissionsListResponse {
    result: string;
    permissions: any;
}

interface GetUserPermissionsRequest {
    user_id: number;
    client_id: number;
}
interface GetUserPermissionsResponse {
    result: string;
}

interface ResetPasswordRequest {
    id?: number;
    email?: string;
}
interface ResetPasswordResponse {
    result: string;
}

interface UpdateUserRequest {
    user_id: number;
    firstname?: string;
    lastname?: string;
    email?: string;
    language?: string;
}
interface UpdateUserResponse {
    result: string;
    user_id: number;
}

interface UpdateUserPermissionsRequest {
    user_id: number;
    client_id: number;
    permission: string;
}
interface UpdateUserPermissionsResponse {
    result: string;
}

declare class WhmcsUsersService extends BaseModule {
    addUser(options: AddUserRequest): Promise<AddUserResponse>;
    createClientInvite(options: CreateClientInviteRequest): Promise<CreateClientInviteResponse>;
    deleteUserClient(options: DeleteUserClientRequest): Promise<DeleteUserClientResponse>;
    getPermissionsList(options: GetPermissionsListRequest): Promise<GetPermissionsListResponse>;
    getUserPermissions(options: GetUserPermissionsRequest): Promise<GetUserPermissionsResponse>;
    resetPassword(options: ResetPasswordRequest): Promise<ResetPasswordResponse>;
    updateUser(options: UpdateUserRequest): Promise<UpdateUserResponse>;
    updateUserPermissions(options: UpdateUserPermissionsRequest): Promise<UpdateUserPermissionsResponse>;
}

declare class WhmcsClientCustom extends BaseModule {
    call<T>(method: string, options: Record<string, unknown>): Promise<T>;
}

declare class WhmcsApi {
    static options: WhmcsSetupOptions;
    constructor(options: WhmcsSetupOptions);
    addons: WhmcsAddonsService;
    affiliates: WhmcsAffiliatesService;
    authentication: WhmcsAuthenticationService;
    billing: WhmcsBillingService;
    client: WhmcsClientService;
    domains: WhmcsDomainsService;
    module: WhmcsModuleService;
    orders: WhmcsOrdersService;
    products: WhmcsProductsService;
    projectmanagement: WhmcsProjectManagementService;
    servers: WhmcsServersService;
    service: WhmcsServiceService;
    support: WhmcsSupportService;
    system: WhmcsSystemService;
    tickets: WhmcsTicketsService;
    users: WhmcsUsersService;
    custom: WhmcsClientCustom;
}

export { type Client, type ConfigOption, type GetClientsDetailsRequest, type GetClientsDetailsResponse, type GetClientsProductsRequest, type GetClientsProductsResponse, type Product$1 as Product, type Stats, type User, WhmcsApi };