         return try StripeRequest(client: self.client, method: .post, route: .account, query: [:], body: Body.data(body.formURLEncoded()), headers: nil)
     }
     
+    /**
+     Retrieve account details
+     Retrieves the details of the account.
+     
+     - parameter accountId: The identifier of the account to be retrieved. If none is provided, 
+                            will default to the account of the API key.
+     
+     - returns: A StripeRequest<> item which you can then use to convert to the corresponding node
+     */
     public func retrieve(account accountId: String) throws -> StripeRequest<ConnectAccount> {
         return try StripeRequest(client: self.client, method: .get, route: .accounts(accountId), query: [:], body: nil, headers: nil)
     }
     
+    /**
+     Update an account
+     Updates an account by setting the values of the parameters passed. Any parameters not provided will 
+     be left unchanged.
+     You may only update Custom and Express accounts that you manage. To update your own account, 
+     you can currently only do so via the dashboard.
+     
+     - parameter accountId:                 The account ID to update on to
+     - parameter bussinessName:             The publicly sharable name for this account.
+     - parameter bussinessPrimaryColor:     A CSS hex color value representing the primary branding color for this account.
+     - parameter businessUrl:               The URL that best shows the service or product provided for this account.
+     - parameter debitNegativeBalances:     A boolean for whether or not Stripe should try to reclaim negative balances
+                                            from the account holder’s bank account.
+     - parameter declineChargeOn:           Account-level settings to automatically decline certain types of charges
+                                            regardless of the bank’s decision.
+     - parameter defaultCurrency:           Three-letter ISO currency code representing the default currency for the account
+     - parameter email:                     Email address of the account holder. For Standard accounts, this is used to email
+                                            them asking them to claim their Stripe account. For Custom accounts, this is only
+                                            to make the account easier to identify to you: Stripe will not email the account holder.
+     - parameter externalAccount:           A card or bank account to attach to the account. You can provide either a token,
+                                            like the ones returned by Stripe.js, or a dictionary as documented in the external_account
+                                            parameter for bank account creation. This will create a new external account object, make it
+                                            the new default external account for its currency, and delete the old default if one exists.
+                                            If you want to add additional external accounts instead of replacing the existing default for 
+                                            this currency, use the bank account or card creation API.
+     - parameter legalEntity:               Information about the account holder; varies by account country and account status.
+     - parameter payoutSchedule:            Details on when this account will make funds from charges available, and when they will be 
+                                            paid out to the account holder’s bank account.
+     - parameter payoutStatementDescriptor: The text that will appear on the account’s bank account statement for payouts. If not set, this 
+                                            will default to your platform’s bank descriptor set on the Dashboard. This will be unset if you 
+                                            POST an empty value.
+     - parameter productDescription:        Internal-only description of the product being sold or service being provided by this account. 
+                                            It’s used by Stripe for risk and underwriting purposes.
+     - parameter statementDescriptor:       The text that will appear on credit card statements by default if a charge is being made 
+                                            directly on the account.
+     - parameter supportEmail:              A publicly shareable email address that can be reached for support for this account.
+     - parameter supportPhone:              A publicly shareable phone number that can be reached for support for this account.
+     - parameter supportUrl:                A publicly shareable URL that can be reached for support for this account.
+     - parameter tosAcceptance:             Details on who accepted the Stripe terms of service, and when they accepted it.
+     - paramater metadata:                  A set of key/value pairs that you can attach to an account object. It can be useful for storing 
+                                            additional information about the account in a structured format. You can unset individual keys 
+                                            if you POST an empty value for that key. You can clear all keys if you POST an empty value for metadata.
+     
+     - returns: A StripeRequest<> item which you can then use to convert to the corresponding node
+     */
     public func update(account accountId: String, businessName: String? = nil, businessPrimaryColor: String? = nil, businessUrl: String? = nil, debitNegativeBalances: Bool? = nil, declineChargeOn: Node? = nil, defaultCurrency: StripeCurrency? = nil, email: String? = nil, externalAccount: Node? = nil, legalEntity: Node? = nil, payoutSchedule: Node? = nil, payoutStatementDescriptor: String? = nil, productDescription: String? = nil, statementDescriptor: String? = nil, supportEmail: String? = nil, supportPhone: String? = nil, supportUrl: String? = nil, tosAcceptance: Node? = nil, metadata: Node? = nil) throws -> StripeRequest<ConnectAccount> {
         var body = Node([:])
         

        return try StripeRequest(client: self.client, method: .get, route: .account, query: query, body: nil, headers: nil)
    }
    
    public func createLoginLink(forAccount accountId: String) throws -> StripeRequest<ConnectLoginLink> {
        return try StripeRequest(client: self.client, method: .post, route: .accountsLoginLink(accountId), query: [:], body: nil, headers: nil)
    }

        return try StripeRequest(client: self.client, method: .post, route: .accounts(accountId), query: [:], body: Body.data(body.formURLEncoded()), headers: nil)
    }
    
    /**
     Delete an account
     With Connect, you may delete Custom accounts you manage.
     Custom accounts created using test-mode keys can be deleted at any time. Custom accounts created 
     using live-mode keys may only be deleted once all balances are zero.
     If you are looking to close your own account, use the data tab in your account settings instead.
     
     - parameter accountId: The identifier of the account to be deleted. If none is provided, will default 
                            to the account of the API key.
     
     - returns: A StripeRequest<> item which you can then use to convert to the corresponding node
     */
    public func delete(account accountId: String) throws -> StripeRequest<DeletedObject> {
        return try StripeRequest(client: self.client, method: .delete, route: .accounts(accountId), query: [:], body: nil, headers: nil)
    }
    
    /**
     Reject an account
     With Connect, you may flag accounts as suspicious.
     Test-mode Custom and Express accounts can be rejected at any time. Accounts created using live-mode keys may only 
     be rejected once all balances are zero.
     
     - parameter accountId: The identifier of the account to create a login link for.
     - parameter reason: The reason for rejecting the account.
     
     - returns: A StripeRequest<> item which you can then use to convert to the corresponding node
     */
    public func reject(account accountId: String, for reason: AccountRejectReason) throws -> StripeRequest<ConnectAccount> {
        var body = Node([:])
        
