AzureData.configure (forAccountNamed: "cosmosDb name", withKey: "read-write key", ofType: .master)

AzureData.create (databaseWithId: id) { r in
    // database = r.resource
}

AzureData.databases () { r in
    // databases = r.resource?.items
}

AzureData.get (databaseWithId: id) { r in
    // database = r.resource
}

AzureData.delete (database) { s in
    // s == successfully deleted
}

AzureData.create (collectionWithId: id, inDatabase: databaseId) { r in
    // collection = r.resource
}

database.create (collectionWithId: id) { r in
    // collection = r.resource
}

AzureData.get (collectionsIn: databaseId) { r in
    // collections = r.resource?.items
}

database.getCollections () { r in
    // collections = r.resource?.items
}

AzureData.get (collectionWithId: id, inDatabase: databaseId) { r in
    // collection = r.resource
}

database.get (collectionWithId: id) { r in
    // collection = r.resource
}

AzureData.delete (collection, from: databaseId) { s in
    // s == successfully deleted
}

database.delete (collection) { s in
    // s == successfully deleted
}

// TODO...

let newDocument = ADDocument()
            
newDocument["aNumber"] = 1_500_000
newDocument["aString"] = "Hello!"
            
AzureData.create (document, inCollection: collectionId, inDatabase: databaseId) { r in
    // document = r.resource
}

AzureData.create (document, in: collection) { r in
    // document = r.resource
}

collection.create (document) { r in
    // document = r.resource
}

AzureData.get (documentsAs: ADDocument.self, inCollection: collectionId, inDatabase: databaseId) { r in
    // documents = r.resource?.items
}

AzureData.get (documentsAs: ADDocument.self, in: collection) { r in
    // documents = r.resource?.items
}

collection.get (documentsAs: ADDocument.self) { r in
    // documents in r.resource?.list
}

AzureData.get (documentWithId: id, as: ADDocument.self, inCollection: collectionId, inDatabase: databaseId) { r in
    // document = r.resource
}

AzureData.get (documentWithId: id, as: ADDocument.self, in: collection) { r in
    // document = r.resource
}

collection.get (documentWithResourceId: id: as: ADDocument.self) { r in
    // document = r.resource
}

AzureData.delete (document, fromCollection: collectionId, inDatabase: databaseId) { r in
    // document = r.resource
}

AzureData.delete (document, from: collection) { r in
    // document = r.resource
}

collection.delete (document) { s in
    // s == successfully deleted
}

AzureData.replace (document, inCollection: collectionId, inDatabase: databaseId) { r in
    // document = r.resource
}

AzureData.replace (document, in: collection) { r in
    // document = r.resource
}

collection.replace (document) { r in
    // document = r.resource
}

let query = ADQuery.select("firstName", "lastName", ...)
                   .from("People")
                   .where("firstName", is: "Colby")
                   .and("lastName", is: "Williams")
                   .and("age", isGreaterThanOrEqualTo: 20)
                   .orderBy("_etag", descending: true)

AzureData.query(documentsIn: collectionId, inDatabase: databaseId, with: query) { r in
    // documents = r.resource?.items
}

AzureData.query(documentsIn: collection, with: query) { r in
    // documents = r.resource?.items
}

collection.query (documentsWith: query) { r in
    // documents in r.resource?.list
}

// link to existing media asset:
AzureData.create (attachmentWithId: id, contentType: "image/png", andMediaUrl: url, onDocument: documentId, inCollection: collectionId, inDatabase: databaseId) { r in
    // attachment = r.resource
}

//or upload the media directly:
AzureData.create (attachmentWithId: id, contentType: "image/png", name: "file.png", with: media, onDocument: documentId, inCollection: collectionId, inDatabase: databaseId) { r in
    // attachment = r.resource
}

AzureData.get (attachmentsOn: documentId, inCollection: collectionId, inDatabase: databaseId) { r in
    // attachments = r.resource
}

AzureData.delete (attachment, onDocument: documentId, inCollection: collectionId, inDatabase: databaseId) { s in
    // s == successfully deleted
}

// link to existing media asset:
AzureData.replace(attachmentWithId: id, contentType: "image/png", andMediaUrl: url, onDocument: documentId, inCollection: collectionId, inDatabase: databaseId) { r in
    // attachment = r.resource
}


AzureData.replace(attachmentWithId: id, contentType: "image/png", name: "file.png", with: media, onDocument: documentId, inCollection: collectionId, inDatabase: databaseId) { r in
    // attachment = r.resource
}

AzureData.create (storedProcedureWithId: id, andBody: body, inCollection: collectionId, inDatabase: databaseId) { r in
    // storedProcedure = r.resource
}

AzureData.create (storedProcedureWithId: id, andBody: body, in: collection) { r in
    // storedProcedure = r.resource
}

collection.create (storedProcedureWithId: storedProcedureId, andBody: body) { r in
    // storedProcedure = r.resource
}

AzureData.get (storedProceduresIn: collectionId, inDatabase: databaseId) { r in
    // storedProcedures = r.resource?.items
}

AzureData.get (storedProceduresIn: collection) { r in
    // storedProcedures = r.resource?.items
}

collection.getStoredProcedures () { r in
    // storedProcedures in r.resource?.list
}

AzureData.delete (storedProcedure, fromCollection: collectionId, inDatabase: databaseId) { s in
    // s == successfully deleted
}

AzureData.delete (storedProcedure, from: collection) { s in
    // s == successfully deleted
}

collection.delete (storedProcedure) { s in
    // s == successfully deleted
}

AzureData.replace (storedProcedureWithId: id, andBody: body, inCollection: collectionId, inDatabase: databaseId) { r in
    // storedProcedure = r.resource
}

AzureData.replace (storedProcedureWithId: id, andBody: body, in: collection) { r in
    // storedProcedure = r.resource
}

collection.replace (storedProcedureWithId: storedProcedureId, andBody: body) { r in
    // storedProcedure = r.resource
}

AzureData.execute (storedProcedureWithId: id, usingParameters: [], inCollection: collectionId, inDatabase: databaseId) { r in
    // r = raw response data
}

AzureData.execute (storedProcedureWithId: id, usingParameters: [], in: collection) { r in
    // r = raw response data
}

collection.execute (storedProcedureWithId: storedProcedureId, usingParameters: parameters) { data in
    // data = response from stored procedure
}

AzureData.create (userDefinedFunctionWithId: id, andBody: body, inCollection: collectionId, inDatabase: databaseId) { r in
    // userDefinedFunction = r.resource
}

AzureData.create (userDefinedFunctionWithId: id, andBody: body, in: collection) { r in
    // userDefinedFunction = r.resource
}

collection.create (userDefinedFunctionWithId: userDefinedFunctionId, andBody: body) { r in
    // userDefinedFunction = r.resource
}

AzureData.get (userDefinedFunctionsIn: collectionId, inDatabase: databaseId) { r in
    // userDefinedFunction = r.resource?.items
}

AzureData.get (userDefinedFunctionsIn: collection) { r in
    // userDefinedFunction = r.resource?.items
}

collection.getUserDefinedFunctions () { r in
    // userDefinedFunctions in r.resource?.list
}

AzureData.delete (userDefinedFunction, fromCollection: collectionId, inDatabase: databaseId) { s in
    // s == successfully deleted
}

AzureData.delete (userDefinedFunction, from: collection) { s in
    // s == successfully deleted
}

collection.delete (userDefinedFunction) { s in
    // s == successfully deleted
}

AzureData.replace (userDefinedFunctionWithId: id, andBody: body, inCollection: collectionId, inDatabase: databaseId) { r in
    // userDefinedFunction = r.resource
}

AzureData.replace (userDefinedFunctionWithId: id, andBody: body, from: collection) { r in
    // userDefinedFunction = r.resource
}

collection.replace (userDefinedFunctionWithId: userDefinedFunctionId, andBody: body) { r in
    // userDefinedFunction = r.resource
}

AzureData.create (triggerWithId: id, operation: .all, type: .pre, andBody: body, inCollection: collectionId, inDatabase: databaseId) { r in
    // trigger = r.resource
}

AzureData.create (triggerWithId: id, operation: .all, type: .pre, andBody: bosy, in: collection) { r in
    // trigger = r.resource
}

collection.create (triggerWithId: triggerId, andBody: body, operation: operation, type: type) { r in
    // trigger = r.resource
}

AzureData.get (triggersIn: collectionId, inDatabase: databaseId) { r in
    // triggers = r.resource?.items
}

AzureData.get (triggersIn: collection) { r in
    // triggers = r.resource?.items
}

collection.getTriggers () { r in
    // triggers in r.resource?.list
}

AzureData.delete (trigger, fromCollection: collectionId, inDatabase: databaseId) { s in
    // s == successfully deleted
}

AzureData.delete (trigger, from: collection) { s in
    // s == successfully deleted
}

collection.delete (trigger) { s in
    // s == successfully deleted
}

AzureData.replace (triggerWithId: id, operation: .all, type: .pre, andBody: body, inCollection: collectionId, inDatabase: databaseId) { r in
    // trigger = r.resource
}

AzureData.replace (triggerWithId: id, operation: .all, type: .pre, andBody: body, in: collection) { r in
    // trigger = r.resource
}

collection.replace (triggerWithId: triggerId, andBody: body, operation: operation, type: type) { r in
    // trigger = r.resource
}

AzureData.create (userWithId: id, inDatabase: databaseId) { r in
    // user = r.resource
}

database.create (userWithId: userId) { r in
    // user = r.resource
}

AzureData.get (usersIn: databaseId) { r in
    // users = r.resource?.items
}

database.getUsers () { r in
    // users = r.resource?.items
}

AzureData.get (userWithId: id, inDatabase: databaseId) { r in
    // user = r.resource
}

database.get (userWithId: userId) { r in
    // user = r.resource
}

AzureData.delete (user, fromDatabase: databaseId) { s in
    // s == successfully deleted
}

database.delete (user: user) { s in
    // s == successfully deleted
}

AzureData.replace (userWithId: id, with: newUserId, inDatabase: databaseId) { r in
    // user = r.resource
}

database.replace (userWithId: userId) { r in
    // user = r.resource
}

AzureData.create (permissionWithId: id, mode: .read, in: resource, forUser: userId, inDatabase: databaseId) { r in
    // permission = r.resource
}

AzureData.get (permissionsFor: userId, inDatabase: databaseId) { r in
    // permissions = r.resource
}

AzureData.get (permissionWithId: id, forUser: userId, inDatabase: databaseId) { r in
    // permission = r.resource
}

AzureData.delete (permission, forUser: userId, inDatabase: databaseId) { s in
    // s == successfully deleted
}

AzureData.replace (permissionWithId: id, mode: .read, in: resource, forUser: userId, inDatabase: databaseId) { r in
    // permission = r.resource
}

AzureData.offers() { r in
// offers = r.resource?.items
}

AzureData.get (offerWithId: id) { r in
    // offer = r.resource
}

// TODO...

// TODO...