How to use the datafire.Integration function in datafire

'use strict';

let datafire = require('datafire');
let openapi = require('./openapi.json');

let aws = require('aws-sdk');
const INTEGRATION_ID = 'amazonaws_streams_dynamodb';
const SDK_ID = 'DynamoDBStreams';

let integ = module.exports = new datafire.Integration({
  id: INTEGRATION_ID,
  title: openapi.info.title,
  description: openapi.info.description,
  logo: openapi.info['x-logo'],
});
integ.security[INTEGRATION_ID]= {
  integration: INTEGRATION_ID,
  fields: {
    accessKeyId: "",
    secretAccessKey: "",
    region: "AWS region (if applicable)",
  }
}

function maybeCamelCase(str) {
  return str.replace(/_(\w)/g, (match, char) => char.toUpperCase())

'use strict';

let datafire = require('datafire');
let openapi = require('./openapi.json');

let aws = require('aws-sdk');
const INTEGRATION_ID = 'amazonaws_gamelift';
const SDK_ID = 'GameLift';

let integ = module.exports = new datafire.Integration({
  id: INTEGRATION_ID,
  title: openapi.info.title,
  description: openapi.info.description,
  logo: openapi.info['x-logo'],
});
integ.security[INTEGRATION_ID]= {
  integration: INTEGRATION_ID,
  fields: {
    accessKeyId: "",
    secretAccessKey: "",
    region: "AWS region (if applicable)",
  }
}

function maybeCamelCase(str) {
  return str.replace(/_(\w)/g, (match, char) => char.toUpperCase())

'use strict';

let datafire = require('datafire');
let openapi = require('./openapi.json');

let aws = require('aws-sdk');
const INTEGRATION_ID = 'amazonaws_marketplacecommerceanalytics';
const SDK_ID = 'MarketplaceCommerceAnalytics';

let integ = module.exports = new datafire.Integration({
  id: INTEGRATION_ID,
  title: openapi.info.title,
  description: openapi.info.description,
  logo: openapi.info['x-logo'],
});
integ.security[INTEGRATION_ID]= {
  integration: INTEGRATION_ID,
  fields: {
    accessKeyId: "",
    secretAccessKey: "",
    region: "AWS region (if applicable)",
  }
}

function maybeCamelCase(str) {
  return str.replace(/_(\w)/g, (match, char) => char.toUpperCase())

'use strict';

let datafire = require('datafire');
let openapi = require('./openapi.json');

let aws = require('aws-sdk');
const INTEGRATION_ID = 'amazonaws_cloudfront';
const SDK_ID = 'CloudFront';

let integ = module.exports = new datafire.Integration({
  id: INTEGRATION_ID,
  title: openapi.info.title,
  description: openapi.info.description,
  logo: openapi.info['x-logo'],
});
integ.security[INTEGRATION_ID]= {
  integration: INTEGRATION_ID,
  fields: {
    accessKeyId: "",
    secretAccessKey: "",
    region: "AWS region (if applicable)",
  }
}

function maybeCamelCase(str) {
  return str.replace(/_(\w)/g, (match, char) => char.toUpperCase())

'use strict';

let datafire = require('datafire');
let openapi = require('./openapi.json');

let aws = require('aws-sdk');
const INTEGRATION_ID = 'amazonaws_elasticmapreduce';
const SDK_ID = 'EMR';

let integ = module.exports = new datafire.Integration({
  id: INTEGRATION_ID,
  title: openapi.info.title,
  description: openapi.info.description,
  logo: openapi.info['x-logo'],
});
integ.security[INTEGRATION_ID]= {
  integration: INTEGRATION_ID,
  fields: {
    accessKeyId: "",
    secretAccessKey: "",
    region: "AWS region (if applicable)",
  }
}

function maybeCamelCase(str) {
  return str.replace(/_(\w)/g, (match, char) => char.toUpperCase())

"use strict";
const datafire = require('datafire');
const nodemailer = require('nodemailer');

const smtp = module.exports = new datafire.Integration({
  id: 'smtp',
  title: 'SMTP',
  description: "Send e-mail using the SMTP protocol",
  security: {
    smtp: {
      fields: {
        host: "Hostname of the SMTP server (default is localhost)",
        port: "Port number of the SMTP server",
        username: "Username for the SMTP server",
        password: "Password for the SMTP server",
      }
    }
  }
});

smtp.addAction('send', {

"use strict";

const datafire = require('datafire');
const ldapJS = require('ldapjs');

const ldap = module.exports = new datafire.Integration({
  id: 'ldap',
  title: 'LDAP - Lightweight Directory Access Protocol',
  description: "The Lightweight Directory Access Protocol is an open, vendor-neutral, industry standard application protocol for accessing and maintaining distributed directory information services over an Internet Protocol (IP) network.",
  security: {
    ldap: {
      fields: {
        "host": "A URL begining with ldap://",
        "dn": "e.g. cn=root",
        "password": "",
      }
    }
  }
})

function getClient(context) {
  var client = ldapJS.createClient({

"use strict";

const datafire = require('datafire');
const IMAP = require('imap');
const schemas = require('./schemas');

const AUTH_TIMEOUT = 3000;

const imap = module.exports = new datafire.Integration({
  id: 'imap',
  description: "Interact with e-mail servers via the Internet Message Access Protocol",
  definitions: schemas,
  security: {
    imap: {
      fields: {
        user: 'Your e-mail address',
        password: 'Your password',
        host: 'IMAP host, e.g. imap.gmail.com',
        port: 'The port to connect to, e.g. 993',
        tls: 'Whether to use TLS',
      }
    }
  }
});

'.gif': 'image/gif',
  '.eot': 'application/vnd.ms-fontobject',
  '.otf': 'application/font-sfnt',
  '.svg': 'image/svg+xml',
  '.ttf': 'application/font-sfnt',
  '.woff': 'application/font-woff',
  '.woff2': 'application/font-woff2',
}

let ENCODINGS = {
  default: 'utf8',
  '.woff': 'binary',
  '.woff2': 'binary',
}

let fileserver = module.exports = new datafire.Integration({
  id: 'fileserver',
  title: "File Server",
  description: "Serve static files, such as HTML, CSS, JavaScript, and images",
});

fileserver.addAction('serve', {
  inputs: [{
    title: 'filename',
    type: 'string',
  }, {
    title: 'contentType',
    type: 'string',
    default: '',
  }],

  security: {

BodyRequest: {
    allOf: [{$ref: '#/definitions/Request'}],
    properties: {
      body: {type: 'string'},
    }
  },
  MethodRequest: {
    allOf: [{$ref: '#/definitions/BodyRequest'}],
    required: ['method'],
    properties: {
      method: {type: 'string'},
    }
  }
}

let http = module.exports = new datafire.Integration({
  id: 'http',
  title: "HTTP",
  description: "Make HTTP calls",
});

http.addAction('request', new datafire.Action({
  title: 'request',
  description: 'Make an HTTP request',

  inputSchema: {
    definitions,
    $ref: '#/definitions/MethodRequest',
  },
  outputSchema: {
    definitions,
    $ref: '#/definitions/Response'