text:
/* jshint maxlen: false */

'use strict';

var createAPIRequest = require('../../lib/apirequest');
var utils = require('../../lib/utils');

/**
 * Google Cloud DNS API
 *
 * Configures and serves authoritative DNS records.
 *
 * @example
 * var google = require('googleapis');
 * var dns = google.dns('v2beta1');
 *
 * @namespace dns
 * @type {Function}
 * @version v2beta1
 * @variation v2beta1
 * @param {object=} options Options for Dns
 */
function Dns(options) { // eslint-disable-line
  var self = this;
  self._options = options || {};

  self.changes = {

    /**
     * dns.changes.create
     *
     * @desc Atomically update the ResourceRecordSet collection.
     *
     * @example
     * // BEFORE RUNNING:
     * // ---------------
     * // 1. If not already done, enable the Google Cloud DNS API
     * //    and check the quota for your project at
     * //    https://console.developers.google.com/apis/api/dns
     * // 2. This sample uses Application Default Credentials for authentication.
     * //    If not already done, install the gcloud CLI from
     * //    https://cloud.google.com/sdk and run
     * //    `gcloud beta auth application-default login`.
     * //    For more information, see
     * //    https://developers.google.com/identity/protocols/application-default-credentials
     * // 3. Install the Node.js client library by running
     * //    `npm install googleapis --save`
     *
     * var google = require('googleapis');
     * var dns = google.dns('v2beta1');
     *
     * authorize(function(authClient) {
     *   var request = {
     *     // Identifies the project addressed by this request.
     *     project: '',  // TODO: Update placeholder value.
     *
     *     // Identifies the managed zone addressed by this request. Can be the managed zone name or id.
     *     managedZone: '',  // TODO: Update placeholder value.
     *
     *     resource: {
     *       // TODO: Add desired properties to the request body.
     *     },
     *
     *     auth: authClient
     *   };
     *
     *   dns.changes.create(request, function(err, response) {
     *     if (err) {
     *       console.log(err);
     *       return;
     *     }
     *
     *     // TODO: Change code below to process the `response` object:
     *     console.log(JSON.stringify(response, null, 2));
     *   });
     * });
     *
     * function authorize(callback) {
     *   google.auth.getApplicationDefault(function(err, authClient)) {
     *     if (err) {
     *       console.log('authentication failed: ', err);
     *       return;
     *     }
     *     if (authClient.createScopedRequired && authClient.createScopedRequired()) {
     *       var scopes = ['https://www.googleapis.com/auth/cloud-platform'];
     *       authClient = authClient.createScoped(scopes);
     *     }
     *     callback(authClient);
     *   });
     * }
     *
     * @alias dns.changes.create
     * @memberOf! dns(v2beta1)
     *
     * @param {object} params Parameters for request
     * @param {string=} params.clientOperationId For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
     * @param {string} params.managedZone Identifies the managed zone addressed by this request. Can be the managed zone name or id.
     * @param {string} params.project Identifies the project addressed by this request.
     * @param {dns(v2beta1).Change} params.resource Request body data
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    create: function (params, options, callback) {
      if (typeof options === 'function') {
        callback = options;
        options = {};
      }
      options || (options = {});

      var parameters = {
        options: utils.extend({
          url: 'https://www.googleapis.com/dns/v2beta1/projects/{project}/managedZones/{managedZone}/changes',
          method: 'POST'
        }, options),
        params: params,
        requiredParams: ['project', 'managedZone'],
        pathParams: ['managedZone', 'project'],
        context: self
      };

      return createAPIRequest(parameters, callback);
    },

    /**
     * dns.changes.get
     *
     * @desc Fetch the representation of an existing Change.
     *
     * @example
     * // BEFORE RUNNING:
     * // ---------------
     * // 1. If not already done, enable the Google Cloud DNS API
     * //    and check the quota for your project at
     * //    https://console.developers.google.com/apis/api/dns
     * // 2. This sample uses Application Default Credentials for authentication.
     * //    If not already done, install the gcloud CLI from
     * //    https://cloud.google.com/sdk and run
     * //    `gcloud beta auth application-default login`.
     * //    For more information, see
     * //    https://developers.google.com/identity/protocols/application-default-credentials
     * // 3. Install the Node.js client library by running
     * //    `npm install googleapis --save`
     *
     * var google = require('googleapis');
     * var dns = google.dns('v2beta1');
     *
     * authorize(function(authClient) {
     *   var request = {
     *     // Identifies the project addressed by this request.
     *     project: '',  // TODO: Update placeholder value.
     *
     *     // Identifies the managed zone addressed by this request. Can be the managed zone name or id.
     *     managedZone: '',  // TODO: Update placeholder value.
     *
     *     // The identifier of the requested change, from a previous ResourceRecordSetsChangeResponse.
     *     changeId: '',  // TODO: Update placeholder value.
     *
     *     auth: authClient
     *   };
     *
     *   dns.changes.get(request, function(err, response) {
     *     if (err) {
     *       console.log(err);
     *       return;
     *     }
     *
     *     // TODO: Change code below to process the `response` object:
     *     console.log(JSON.stringify(response, null, 2));
     *   });
     * });
     *
     * function authorize(callback) {
     *   google.auth.getApplicationDefault(function(err, authClient)) {
     *     if (err) {
     *       console.log('authentication failed: ', err);
     *       return;
     *     }
     *     if (authClient.createScopedRequired && authClient.createScopedRequired()) {
     *       var scopes = ['https://www.googleapis.com/auth/cloud-platform'];
     *       authClient = authClient.createScoped(scopes);
     *     }
     *     callback(authClient);
     *   });
     * }
     *
     * @alias dns.changes.get
     * @memberOf! dns(v2beta1)
     *
     * @param {object} params Parameters for request
     * @param {string} params.changeId The identifier of the requested change, from a previous ResourceRecordSetsChangeResponse.
     * @param {string=} params.clientOperationId For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
     * @param {string} params.managedZone Identifies the managed zone addressed by this request. Can be the managed zone name or id.
     * @param {string} params.project Identifies the project addressed by this request.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    get: function (params, options, callback) {
      if (typeof options === 'function') {
        callback = options;
        options = {};
      }
      options || (options = {});

      var parameters = {
        options: utils.extend({
          url: 'https://www.googleapis.com/dns/v2beta1/projects/{project}/managedZones/{managedZone}/changes/{changeId}',
          method: 'GET'
        }, options),
        params: params,
        requiredParams: ['project', 'managedZone', 'changeId'],
        pathParams: ['changeId', 'managedZone', 'project'],
        context: self
      };

      return createAPIRequest(parameters, callback);
    },

    /**
     * dns.changes.list
     *
     * @desc Enumerate Changes to a ResourceRecordSet collection.
     *
     * @example
     * // BEFORE RUNNING:
     * // ---------------
     * // 1. If not already done, enable the Google Cloud DNS API
     * //    and check the quota for your project at
     * //    https://console.developers.google.com/apis/api/dns
     * // 2. This sample uses Application Default Credentials for authentication.
     * //    If not already done, install the gcloud CLI from
     * //    https://cloud.google.com/sdk and run
     * //    `gcloud beta auth application-default login`.
     * //    For more information, see
     * //    https://developers.google.com/identity/protocols/application-default-credentials
     * // 3. Install the Node.js client library by running
     * //    `npm install googleapis --save`
     *
     * var google = require('googleapis');
     * var dns = google.dns('v2beta1');
     *
     * authorize(function(authClient) {
     *   var request = {
     *     // Identifies the project addressed by this request.
     *     project: '',  // TODO: Update placeholder value.
     *
     *     // Identifies the managed zone addressed by this request. Can be the managed zone name or id.
     *     managedZone: '',  // TODO: Update placeholder value.
     *
     *     auth: authClient
     *   };
     *
     *   var handlePage = function(err, response) {
     *     if (err) {
     *       console.log(err);
     *       return;
     *     }
     *
     *     var changesPage = response['changes'];
     *     if (!changesPage) {
     *       return;
     *     }
     *     for (var i = 0; i < changesPage.length; i++) {
     *       // TODO: Change code below to process each resource in `changesPage`:
     *       console.log(JSON.stringify(changesPage[i], null, 2));
     *     }
     *
     *     if (response.nextPageToken) {
     *       request.pageToken = response.nextPageToken;
     *       dns.changes.list(request, handlePage);
     *     }
     *   };
     *
     *   dns.changes.list(request, handlePage);
     * });
     *
     * function authorize(callback) {
     *   google.auth.getApplicationDefault(function(err, authClient)) {
     *     if (err) {
     *       console.log('authentication failed: ', err);
     *       return;
     *     }
     *     if (authClient.createScopedRequired && authClient.createScopedRequired()) {
     *       var scopes = ['https://www.googleapis.com/auth/cloud-platform'];
     *       authClient = authClient.createScoped(scopes);
     *     }
     *     callback(authClient);
     *   });
     * }
     *
     * @alias dns.changes.list
     * @memberOf! dns(v2beta1)
     *
     * @param {object} params Parameters for request
     * @param {string} params.managedZone Identifies the managed zone addressed by this request. Can be the managed zone name or id.
     * @param {integer=} params.maxResults Optional. Maximum number of results to be returned. If unspecified, the server will decide how many results to return.
     * @param {string=} params.pageToken Optional. A tag returned by a previous list request that was truncated. Use this parameter to continue a previous list request.
     * @param {string} params.project Identifies the project addressed by this request.
     * @param {string=} params.sortBy Sorting criterion. The only supported value is change sequence.
     * @param {string=} params.sortOrder Sorting order direction: 'ascending' or 'descending'.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    list: function (params, options, callback) {
      if (typeof options === 'function') {
        callback = options;
        options = {};
      }
      options || (options = {});

      var parameters = {
        options: utils.extend({
          url: 'https://www.googleapis.com/dns/v2beta1/projects/{project}/managedZones/{managedZone}/changes',
          method: 'GET'
        }, options),
        params: params,
        requiredParams: ['project', 'managedZone'],
        pathParams: ['managedZone', 'project'],
        context: self
      };

      return createAPIRequest(parameters, callback);
    }

  };

  self.dnsKeys = {

    /**
     * dns.dnsKeys.get
     *
     * @desc Fetch the representation of an existing DnsKey.
     *
     * @example
     * // BEFORE RUNNING:
     * // ---------------
     * // 1. If not already done, enable the Google Cloud DNS API
     * //    and check the quota for your project at
     * //    https://console.developers.google.com/apis/api/dns
     * // 2. This sample uses Application Default Credentials for authentication.
     * //    If not already done, install the gcloud CLI from
     * //    https://cloud.google.com/sdk and run
     * //    `gcloud beta auth application-default login`.
     * //    For more information, see
     * //    https://developers.google.com/identity/protocols/application-default-credentials
     * // 3. Install the Node.js client library by running
     * //    `npm install googleapis --save`
     *
     * var google = require('googleapis');
     * var dns = google.dns('v2beta1');
     *
     * authorize(function(authClient) {
     *   var request = {
     *     // Identifies the project addressed by this request.
     *     project: '',  // TODO: Update placeholder value.
     *
     *     // Identifies the managed zone addressed by this request. Can be the managed zone name or id.
     *     managedZone: '',  // TODO: Update placeholder value.
     *
     *     // The identifier of the requested DnsKey.
     *     dnsKeyId: '',  // TODO: Update placeholder value.
     *
     *     auth: authClient
     *   };
     *
     *   dns.dnsKeys.get(request, function(err, response) {
     *     if (err) {
     *       console.log(err);
     *       return;
     *     }
     *
     *     // TODO: Change code below to process the `response` object:
     *     console.log(JSON.stringify(response, null, 2));
     *   });
     * });
     *
     * function authorize(callback) {
     *   google.auth.getApplicationDefault(function(err, authClient)) {
     *     if (err) {
     *       console.log('authentication failed: ', err);
     *       return;
     *     }
     *     if (authClient.createScopedRequired && authClient.createScopedRequired()) {
     *       var scopes = ['https://www.googleapis.com/auth/cloud-platform'];
     *       authClient = authClient.createScoped(scopes);
     *     }
     *     callback(authClient);
     *   });
     * }
     *
     * @alias dns.dnsKeys.get
     * @memberOf! dns(v2beta1)
     *
     * @param {object} params Parameters for request
     * @param {string=} params.clientOperationId For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
     * @param {string=} params.digestType An optional comma-separated list of digest types to compute and display for key signing keys. If omitted, the recommended digest type will be computed and displayed.
     * @param {string} params.dnsKeyId The identifier of the requested DnsKey.
     * @param {string} params.managedZone Identifies the managed zone addressed by this request. Can be the managed zone name or id.
     * @param {string} params.project Identifies the project addressed by this request.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    get: function (params, options, callback) {
      if (typeof options === 'function') {
        callback = options;
        options = {};
      }
      options || (options = {});

      var parameters = {
        options: utils.extend({
          url: 'https://www.googleapis.com/dns/v2beta1/projects/{project}/managedZones/{managedZone}/dnsKeys/{dnsKeyId}',
          method: 'GET'
        }, options),
        params: params,
        requiredParams: ['project', 'managedZone', 'dnsKeyId'],
        pathParams: ['dnsKeyId', 'managedZone', 'project'],
        context: self
      };

      return createAPIRequest(parameters, callback);
    },

    /**
     * dns.dnsKeys.list
     *
     * @desc Enumerate DnsKeys to a ResourceRecordSet collection.
     *
     * @example
     * // BEFORE RUNNING:
     * // ---------------
     * // 1. If not already done, enable the Google Cloud DNS API
     * //    and check the quota for your project at
     * //    https://console.developers.google.com/apis/api/dns
     * // 2. This sample uses Application Default Credentials for authentication.
     * //    If not already done, install the gcloud CLI from
     * //    https://cloud.google.com/sdk and run
     * //    `gcloud beta auth application-default login`.
     * //    For more information, see
     * //    https://developers.google.com/identity/protocols/application-default-credentials
     * // 3. Install the Node.js client library by running
     * //    `npm install googleapis --save`
     *
     * var google = require('googleapis');
     * var dns = google.dns('v2beta1');
     *
     * authorize(function(authClient) {
     *   var request = {
     *     // Identifies the project addressed by this request.
     *     project: '',  // TODO: Update placeholder value.
     *
     *     // Identifies the managed zone addressed by this request. Can be the managed zone name or id.
     *     managedZone: '',  // TODO: Update placeholder value.
     *
     *     auth: authClient
     *   };
     *
     *   var handlePage = function(err, response) {
     *     if (err) {
     *       console.log(err);
     *       return;
     *     }
     *
     *     var dnsKeysPage = response['dnsKeys'];
     *     if (!dnsKeysPage) {
     *       return;
     *     }
     *     for (var i = 0; i < dnsKeysPage.length; i++) {
     *       // TODO: Change code below to process each resource in `dnsKeysPage`:
     *       console.log(JSON.stringify(dnsKeysPage[i], null, 2));
     *     }
     *
     *     if (response.nextPageToken) {
     *       request.pageToken = response.nextPageToken;
     *       dns.dnsKeys.list(request, handlePage);
     *     }
     *   };
     *
     *   dns.dnsKeys.list(request, handlePage);
     * });
     *
     * function authorize(callback) {
     *   google.auth.getApplicationDefault(function(err, authClient)) {
     *     if (err) {
     *       console.log('authentication failed: ', err);
     *       return;
     *     }
     *     if (authClient.createScopedRequired && authClient.createScopedRequired()) {
     *       var scopes = ['https://www.googleapis.com/auth/cloud-platform'];
     *       authClient = authClient.createScoped(scopes);
     *     }
     *     callback(authClient);
     *   });
     * }
     *
     * @alias dns.dnsKeys.list
     * @memberOf! dns(v2beta1)
     *
     * @param {object} params Parameters for request
     * @param {string=} params.digestType An optional comma-separated list of digest types to compute and display for key signing keys. If omitted, the recommended digest type will be computed and displayed.
     * @param {string} params.managedZone Identifies the managed zone addressed by this request. Can be the managed zone name or id.
     * @param {integer=} params.maxResults Optional. Maximum number of results to be returned. If unspecified, the server will decide how many results to return.
     * @param {string=} params.pageToken Optional. A tag returned by a previous list request that was truncated. Use this parameter to continue a previous list request.
     * @param {string} params.project Identifies the project addressed by this request.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    list: function (params, options, callback) {
      if (typeof options === 'function') {
        callback = options;
        options = {};
      }
      options || (options = {});

      var parameters = {
        options: utils.extend({
          url: 'https://www.googleapis.com/dns/v2beta1/projects/{project}/managedZones/{managedZone}/dnsKeys',
          method: 'GET'
        }, options),
        params: params,
        requiredParams: ['project', 'managedZone'],
        pathParams: ['managedZone', 'project'],
        context: self
      };

      return createAPIRequest(parameters, callback);
    }

  };

  self.managedZoneOperations = {

    /**
     * dns.managedZoneOperations.get
     *
     * @desc Fetch the representation of an existing Operation.
     *
     * @example
     * // BEFORE RUNNING:
     * // ---------------
     * // 1. If not already done, enable the Google Cloud DNS API
     * //    and check the quota for your project at
     * //    https://console.developers.google.com/apis/api/dns
     * // 2. This sample uses Application Default Credentials for authentication.
     * //    If not already done, install the gcloud CLI from
     * //    https://cloud.google.com/sdk and run
     * //    `gcloud beta auth application-default login`.
     * //    For more information, see
     * //    https://developers.google.com/identity/protocols/application-default-credentials
     * // 3. Install the Node.js client library by running
     * //    `npm install googleapis --save`
     *
     * var google = require('googleapis');
     * var dns = google.dns('v2beta1');
     *
     * authorize(function(authClient) {
     *   var request = {
     *     // Identifies the project addressed by this request.
     *     project: '',  // TODO: Update placeholder value.
     *
     *     // Identifies the managed zone addressed by this request.
     *     managedZone: '',  // TODO: Update placeholder value.
     *
     *     // Identifies the operation addressed by this request.
     *     operation: '',  // TODO: Update placeholder value.
     *
     *     auth: authClient
     *   };
     *
     *   dns.managedZoneOperations.get(request, function(err, response) {
     *     if (err) {
     *       console.log(err);
     *       return;
     *     }
     *
     *     // TODO: Change code below to process the `response` object:
     *     console.log(JSON.stringify(response, null, 2));
     *   });
     * });
     *
     * function authorize(callback) {
     *   google.auth.getApplicationDefault(function(err, authClient)) {
     *     if (err) {
     *       console.log('authentication failed: ', err);
     *       return;
     *     }
     *     if (authClient.createScopedRequired && authClient.createScopedRequired()) {
     *       var scopes = ['https://www.googleapis.com/auth/cloud-platform'];
     *       authClient = authClient.createScoped(scopes);
     *     }
     *     callback(authClient);
     *   });
     * }
     *
     * @alias dns.managedZoneOperations.get
     * @memberOf! dns(v2beta1)
     *
     * @param {object} params Parameters for request
     * @param {string=} params.clientOperationId For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
     * @param {string} params.managedZone Identifies the managed zone addressed by this request.
     * @param {string} params.operation Identifies the operation addressed by this request.
     * @param {string} params.project Identifies the project addressed by this request.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    get: function (params, options, callback) {
      if (typeof options === 'function') {
        callback = options;
        options = {};
      }
      options || (options = {});

      var parameters = {
        options: utils.extend({
          url: 'https://www.googleapis.com/dns/v2beta1/projects/{project}/managedZones/{managedZone}/operations/{operation}',
          method: 'GET'
        }, options),
        params: params,
        requiredParams: ['project', 'managedZone', 'operation'],
        pathParams: ['managedZone', 'operation', 'project'],
        context: self
      };

      return createAPIRequest(parameters, callback);
    },

    /**
     * dns.managedZoneOperations.list
     *
     * @desc Enumerate Operations for the given ManagedZone.
     *
     * @example
     * // BEFORE RUNNING:
     * // ---------------
     * // 1. If not already done, enable the Google Cloud DNS API
     * //    and check the quota for your project at
     * //    https://console.developers.google.com/apis/api/dns
     * // 2. This sample uses Application Default Credentials for authentication.
     * //    If not already done, install the gcloud CLI from
     * //    https://cloud.google.com/sdk and run
     * //    `gcloud beta auth application-default login`.
     * //    For more information, see
     * //    https://developers.google.com/identity/protocols/application-default-credentials
     * // 3. Install the Node.js client library by running
     * //    `npm install googleapis --save`
     *
     * var google = require('googleapis');
     * var dns = google.dns('v2beta1');
     *
     * authorize(function(authClient) {
     *   var request = {
     *     // Identifies the project addressed by this request.
     *     project: '',  // TODO: Update placeholder value.
     *
     *     // Identifies the managed zone addressed by this request.
     *     managedZone: '',  // TODO: Update placeholder value.
     *
     *     auth: authClient
     *   };
     *
     *   var handlePage = function(err, response) {
     *     if (err) {
     *       console.log(err);
     *       return;
     *     }
     *
     *     var operationsPage = response['operations'];
     *     if (!operationsPage) {
     *       return;
     *     }
     *     for (var i = 0; i < operationsPage.length; i++) {
     *       // TODO: Change code below to process each resource in `operationsPage`:
     *       console.log(JSON.stringify(operationsPage[i], null, 2));
     *     }
     *
     *     if (response.nextPageToken) {
     *       request.pageToken = response.nextPageToken;
     *       dns.managedZoneOperations.list(request, handlePage);
     *     }
     *   };
     *
     *   dns.managedZoneOperations.list(request, handlePage);
     * });
     *
     * function authorize(callback) {
     *   google.auth.getApplicationDefault(function(err, authClient)) {
     *     if (err) {
     *       console.log('authentication failed: ', err);
     *       return;
     *     }
     *     if (authClient.createScopedRequired && authClient.createScopedRequired()) {
     *       var scopes = ['https://www.googleapis.com/auth/cloud-platform'];
     *       authClient = authClient.createScoped(scopes);
     *     }
     *     callback(authClient);
     *   });
     * }
     *
     * @alias dns.managedZoneOperations.list
     * @memberOf! dns(v2beta1)
     *
     * @param {object} params Parameters for request
     * @param {string} params.managedZone Identifies the managed zone addressed by this request.
     * @param {integer=} params.maxResults Optional. Maximum number of results to be returned. If unspecified, the server will decide how many results to return.
     * @param {string=} params.pageToken Optional. A tag returned by a previous list request that was truncated. Use this parameter to continue a previous list request.
     * @param {string} params.project Identifies the project addressed by this request.
     * @param {string=} params.sortBy Sorting criterion. The only supported values are START_TIME and ID.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    list: function (params, options, callback) {
      if (typeof options === 'function') {
        callback = options;
        options = {};
      }
      options || (options = {});

      var parameters = {
        options: utils.extend({
          url: 'https://www.googleapis.com/dns/v2beta1/projects/{project}/managedZones/{managedZone}/operations',
          method: 'GET'
        }, options),
        params: params,
        requiredParams: ['project', 'managedZone'],
        pathParams: ['managedZone', 'project'],
        context: self
      };

      return createAPIRequest(parameters, callback);
    }

  };

  self.managedZones = {

    /**
     * dns.managedZones.create
     *
     * @desc Create a new ManagedZone.
     *
     * @example
     * // BEFORE RUNNING:
     * // ---------------
     * // 1. If not already done, enable the Google Cloud DNS API
     * //    and check the quota for your project at
     * //    https://console.developers.google.com/apis/api/dns
     * // 2. This sample uses Application Default Credentials for authentication.
     * //    If not already done, install the gcloud CLI from
     * //    https://cloud.google.com/sdk and run
     * //    `gcloud beta auth application-default login`.
     * //    For more information, see
     * //    https://developers.google.com/identity/protocols/application-default-credentials
     * // 3. Install the Node.js client library by running
     * //    `npm install googleapis --save`
     *
     * var google = require('googleapis');
     * var dns = google.dns('v2beta1');
     *
     * authorize(function(authClient) {
     *   var request = {
     *     // Identifies the project addressed by this request.
     *     project: '',  // TODO: Update placeholder value.
     *
     *     resource: {
     *       // TODO: Add desired properties to the request body.
     *     },
     *
     *     auth: authClient
     *   };
     *
     *   dns.managedZones.create(request, function(err, response) {
     *     if (err) {
     *       console.log(err);
     *       return;
     *     }
     *
     *     // TODO: Change code below to process the `response` object:
     *     console.log(JSON.stringify(response, null, 2));
     *   });
     * });
     *
     * function authorize(callback) {
     *   google.auth.getApplicationDefault(function(err, authClient)) {
     *     if (err) {
     *       console.log('authentication failed: ', err);
     *       return;
     *     }
     *     if (authClient.createScopedRequired && authClient.createScopedRequired()) {
     *       var scopes = ['https://www.googleapis.com/auth/cloud-platform'];
     *       authClient = authClient.createScoped(scopes);
     *     }
     *     callback(authClient);
     *   });
     * }
     *
     * @alias dns.managedZones.create
     * @memberOf! dns(v2beta1)
     *
     * @param {object} params Parameters for request
     * @param {string=} params.clientOperationId For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
     * @param {string} params.project Identifies the project addressed by this request.
     * @param {dns(v2beta1).ManagedZone} params.resource Request body data
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    create: function (params, options, callback) {
      if (typeof options === 'function') {
        callback = options;
        options = {};
      }
      options || (options = {});

      var parameters = {
        options: utils.extend({
          url: 'https://www.googleapis.com/dns/v2beta1/projects/{project}/managedZones',
          method: 'POST'
        }, options),
        params: params,
        requiredParams: ['project'],
        pathParams: ['project'],
        context: self
      };

      return createAPIRequest(parameters, callback);
    },

    /**
     * dns.managedZones.delete
     *
     * @desc Delete a previously created ManagedZone.
     *
     * @example
     * // BEFORE RUNNING:
     * // ---------------
     * // 1. If not already done, enable the Google Cloud DNS API
     * //    and check the quota for your project at
     * //    https://console.developers.google.com/apis/api/dns
     * // 2. This sample uses Application Default Credentials for authentication.
     * //    If not already done, install the gcloud CLI from
     * //    https://cloud.google.com/sdk and run
     * //    `gcloud beta auth application-default login`.
     * //    For more information, see
     * //    https://developers.google.com/identity/protocols/application-default-credentials
     * // 3. Install the Node.js client library by running
     * //    `npm install googleapis --save`
     *
     * var google = require('googleapis');
     * var dns = google.dns('v2beta1');
     *
     * authorize(function(authClient) {
     *   var request = {
     *     // Identifies the project addressed by this request.
     *     project: '',  // TODO: Update placeholder value.
     *
     *     // Identifies the managed zone addressed by this request. Can be the managed zone name or id.
     *     managedZone: '',  // TODO: Update placeholder value.
     *
     *     auth: authClient
     *   };
     *
     *   dns.managedZones.delete(request, function(err, response) {
     *     if (err) {
     *       console.log(err);
     *       return;
     *     }
     *
     *     // TODO: Change code below to process the `response` object:
     *     console.log(JSON.stringify(response, null, 2));
     *   });
     * });
     *
     * function authorize(callback) {
     *   google.auth.getApplicationDefault(function(err, authClient)) {
     *     if (err) {
     *       console.log('authentication failed: ', err);
     *       return;
     *     }
     *     if (authClient.createScopedRequired && authClient.createScopedRequired()) {
     *       var scopes = ['https://www.googleapis.com/auth/cloud-platform'];
     *       authClient = authClient.createScoped(scopes);
     *     }
     *     callback(authClient);
     *   });
     * }
     *
     * @alias dns.managedZones.delete
     * @memberOf! dns(v2beta1)
     *
     * @param {object} params Parameters for request
     * @param {string=} params.clientOperationId For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
     * @param {string} params.managedZone Identifies the managed zone addressed by this request. Can be the managed zone name or id.
     * @param {string} params.project Identifies the project addressed by this request.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    delete: function (params, options, callback) {
      if (typeof options === 'function') {
        callback = options;
        options = {};
      }
      options || (options = {});

      var parameters = {
        options: utils.extend({
          url: 'https://www.googleapis.com/dns/v2beta1/projects/{project}/managedZones/{managedZone}',
          method: 'DELETE'
        }, options),
        params: params,
        requiredParams: ['project', 'managedZone'],
        pathParams: ['managedZone', 'project'],
        context: self
      };

      return createAPIRequest(parameters, callback);
    },

    /**
     * dns.managedZones.get
     *
     * @desc Fetch the representation of an existing ManagedZone.
     *
     * @example
     * // BEFORE RUNNING:
     * // ---------------
     * // 1. If not already done, enable the Google Cloud DNS API
     * //    and check the quota for your project at
     * //    https://console.developers.google.com/apis/api/dns
     * // 2. This sample uses Application Default Credentials for authentication.
     * //    If not already done, install the gcloud CLI from
     * //    https://cloud.google.com/sdk and run
     * //    `gcloud beta auth application-default login`.
     * //    For more information, see
     * //    https://developers.google.com/identity/protocols/application-default-credentials
     * // 3. Install the Node.js client library by running
     * //    `npm install googleapis --save`
     *
     * var google = require('googleapis');
     * var dns = google.dns('v2beta1');
     *
     * authorize(function(authClient) {
     *   var request = {
     *     // Identifies the project addressed by this request.
     *     project: '',  // TODO: Update placeholder value.
     *
     *     // Identifies the managed zone addressed by this request. Can be the managed zone name or id.
     *     managedZone: '',  // TODO: Update placeholder value.
     *
     *     auth: authClient
     *   };
     *
     *   dns.managedZones.get(request, function(err, response) {
     *     if (err) {
     *       console.log(err);
     *       return;
     *     }
     *
     *     // TODO: Change code below to process the `response` object:
     *     console.log(JSON.stringify(response, null, 2));
     *   });
     * });
     *
     * function authorize(callback) {
     *   google.auth.getApplicationDefault(function(err, authClient)) {
     *     if (err) {
     *       console.log('authentication failed: ', err);
     *       return;
     *     }
     *     if (authClient.createScopedRequired && authClient.createScopedRequired()) {
     *       var scopes = ['https://www.googleapis.com/auth/cloud-platform'];
     *       authClient = authClient.createScoped(scopes);
     *     }
     *     callback(authClient);
     *   });
     * }
     *
     * @alias dns.managedZones.get
     * @memberOf! dns(v2beta1)
     *
     * @param {object} params Parameters for request
     * @param {string=} params.clientOperationId For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
     * @param {string} params.managedZone Identifies the managed zone addressed by this request. Can be the managed zone name or id.
     * @param {string} params.project Identifies the project addressed by this request.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    get: function (params, options, callback) {
      if (typeof options === 'function') {
        callback = options;
        options = {};
      }
      options || (options = {});

      var parameters = {
        options: utils.extend({
          url: 'https://www.googleapis.com/dns/v2beta1/projects/{project}/managedZones/{managedZone}',
          method: 'GET'
        }, options),
        params: params,
        requiredParams: ['project', 'managedZone'],
        pathParams: ['managedZone', 'project'],
        context: self
      };

      return createAPIRequest(parameters, callback);
    },

    /**
     * dns.managedZones.list
     *
     * @desc Enumerate ManagedZones that have been created but not yet deleted.
     *
     * @example
     * // BEFORE RUNNING:
     * // ---------------
     * // 1. If not already done, enable the Google Cloud DNS API
     * //    and check the quota for your project at
     * //    https://console.developers.google.com/apis/api/dns
     * // 2. This sample uses Application Default Credentials for authentication.
     * //    If not already done, install the gcloud CLI from
     * //    https://cloud.google.com/sdk and run
     * //    `gcloud beta auth application-default login`.
     * //    For more information, see
     * //    https://developers.google.com/identity/protocols/application-default-credentials
     * // 3. Install the Node.js client library by running
     * //    `npm install googleapis --save`
     *
     * var google = require('googleapis');
     * var dns = google.dns('v2beta1');
     *
     * authorize(function(authClient) {
     *   var request = {
     *     // Identifies the project addressed by this request.
     *     project: '',  // TODO: Update placeholder value.
     *
     *     auth: authClient
     *   };
     *
     *   var handlePage = function(err, response) {
     *     if (err) {
     *       console.log(err);
     *       return;
     *     }
     *
     *     var managedZonesPage = response['managedZones'];
     *     if (!managedZonesPage) {
     *       return;
     *     }
     *     for (var i = 0; i < managedZonesPage.length; i++) {
     *       // TODO: Change code below to process each resource in `managedZonesPage`:
     *       console.log(JSON.stringify(managedZonesPage[i], null, 2));
     *     }
     *
     *     if (response.nextPageToken) {
     *       request.pageToken = response.nextPageToken;
     *       dns.managedZones.list(request, handlePage);
     *     }
     *   };
     *
     *   dns.managedZones.list(request, handlePage);
     * });
     *
     * function authorize(callback) {
     *   google.auth.getApplicationDefault(function(err, authClient)) {
     *     if (err) {
     *       console.log('authentication failed: ', err);
     *       return;
     *     }
     *     if (authClient.createScopedRequired && authClient.createScopedRequired()) {
     *       var scopes = ['https://www.googleapis.com/auth/cloud-platform'];
     *       authClient = authClient.createScoped(scopes);
     *     }
     *     callback(authClient);
     *   });
     * }
     *
     * @alias dns.managedZones.list
     * @memberOf! dns(v2beta1)
     *
     * @param {object} params Parameters for request
     * @param {string=} params.dnsName Restricts the list to return only zones with this domain name.
     * @param {integer=} params.maxResults Optional. Maximum number of results to be returned. If unspecified, the server will decide how many results to return.
     * @param {string=} params.pageToken Optional. A tag returned by a previous list request that was truncated. Use this parameter to continue a previous list request.
     * @param {string} params.project Identifies the project addressed by this request.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    list: function (params, options, callback) {
      if (typeof options === 'function') {
        callback = options;
        options = {};
      }
      options || (options = {});

      var parameters = {
        options: utils.extend({
          url: 'https://www.googleapis.com/dns/v2beta1/projects/{project}/managedZones',
          method: 'GET'
        }, options),
        params: params,
        requiredParams: ['project'],
        pathParams: ['project'],
        context: self
      };

      return createAPIRequest(parameters, callback);
    },

    /**
     * dns.managedZones.patch
     *
     * @desc Update an existing ManagedZone. This method supports patch semantics.
     *
     * @example
     * // BEFORE RUNNING:
     * // ---------------
     * // 1. If not already done, enable the Google Cloud DNS API
     * //    and check the quota for your project at
     * //    https://console.developers.google.com/apis/api/dns
     * // 2. This sample uses Application Default Credentials for authentication.
     * //    If not already done, install the gcloud CLI from
     * //    https://cloud.google.com/sdk and run
     * //    `gcloud beta auth application-default login`.
     * //    For more information, see
     * //    https://developers.google.com/identity/protocols/application-default-credentials
     * // 3. Install the Node.js client library by running
     * //    `npm install googleapis --save`
     *
     * var google = require('googleapis');
     * var dns = google.dns('v2beta1');
     *
     * authorize(function(authClient) {
     *   var request = {
     *     // Identifies the project addressed by this request.
     *     project: '',  // TODO: Update placeholder value.
     *
     *     // Identifies the managed zone addressed by this request. Can be the managed zone name or id.
     *     managedZone: '',  // TODO: Update placeholder value.
     *
     *     resource: {
     *       // TODO: Add desired properties to the request body. Only these properties
     *       // will be changed.
     *     },
     *
     *     auth: authClient
     *   };
     *
     *   dns.managedZones.patch(request, function(err, response) {
     *     if (err) {
     *       console.log(err);
     *       return;
     *     }
     *
     *     // TODO: Change code below to process the `response` object:
     *     console.log(JSON.stringify(response, null, 2));
     *   });
     * });
     *
     * function authorize(callback) {
     *   google.auth.getApplicationDefault(function(err, authClient)) {
     *     if (err) {
     *       console.log('authentication failed: ', err);
     *       return;
     *     }
     *     if (authClient.createScopedRequired && authClient.createScopedRequired()) {
     *       var scopes = ['https://www.googleapis.com/auth/cloud-platform'];
     *       authClient = authClient.createScoped(scopes);
     *     }
     *     callback(authClient);
     *   });
     * }
     *
     * @alias dns.managedZones.patch
     * @memberOf! dns(v2beta1)
     *
     * @param {object} params Parameters for request
     * @param {string=} params.clientOperationId For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
     * @param {string} params.managedZone Identifies the managed zone addressed by this request. Can be the managed zone name or id.
     * @param {string} params.project Identifies the project addressed by this request.
     * @param {dns(v2beta1).ManagedZone} params.resource Request body data
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    patch: function (params, options, callback) {
      if (typeof options === 'function') {
        callback = options;
        options = {};
      }
      options || (options = {});

      var parameters = {
        options: utils.extend({
          url: 'https://www.googleapis.com/dns/v2beta1/projects/{project}/managedZones/{managedZone}',
          method: 'PATCH'
        }, options),
        params: params,
        requiredParams: ['project', 'managedZone'],
        pathParams: ['managedZone', 'project'],
        context: self
      };

      return createAPIRequest(parameters, callback);
    },

    /**
     * dns.managedZones.update
     *
     * @desc Update an existing ManagedZone.
     *
     * @example
     * // BEFORE RUNNING:
     * // ---------------
     * // 1. If not already done, enable the Google Cloud DNS API
     * //    and check the quota for your project at
     * //    https://console.developers.google.com/apis/api/dns
     * // 2. This sample uses Application Default Credentials for authentication.
     * //    If not already done, install the gcloud CLI from
     * //    https://cloud.google.com/sdk and run
     * //    `gcloud beta auth application-default login`.
     * //    For more information, see
     * //    https://developers.google.com/identity/protocols/application-default-credentials
     * // 3. Install the Node.js client library by running
     * //    `npm install googleapis --save`
     *
     * var google = require('googleapis');
     * var dns = google.dns('v2beta1');
     *
     * authorize(function(authClient) {
     *   var request = {
     *     // Identifies the project addressed by this request.
     *     project: '',  // TODO: Update placeholder value.
     *
     *     // Identifies the managed zone addressed by this request. Can be the managed zone name or id.
     *     managedZone: '',  // TODO: Update placeholder value.
     *
     *     resource: {
     *       // TODO: Add desired properties to the request body. All existing properties
     *       // will be replaced.
     *     },
     *
     *     auth: authClient
     *   };
     *
     *   dns.managedZones.update(request, function(err, response) {
     *     if (err) {
     *       console.log(err);
     *       return;
     *     }
     *
     *     // TODO: Change code below to process the `response` object:
     *     console.log(JSON.stringify(response, null, 2));
     *   });
     * });
     *
     * function authorize(callback) {
     *   google.auth.getApplicationDefault(function(err, authClient)) {
     *     if (err) {
     *       console.log('authentication failed: ', err);
     *       return;
     *     }
     *     if (authClient.createScopedRequired && authClient.createScopedRequired()) {
     *       var scopes = ['https://www.googleapis.com/auth/cloud-platform'];
     *       authClient = authClient.createScoped(scopes);
     *     }
     *     callback(authClient);
     *   });
     * }
     *
     * @alias dns.managedZones.update
     * @memberOf! dns(v2beta1)
     *
     * @param {object} params Parameters for request
     * @param {string=} params.clientOperationId For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
     * @param {string} params.managedZone Identifies the managed zone addressed by this request. Can be the managed zone name or id.
     * @param {string} params.project Identifies the project addressed by this request.
     * @param {dns(v2beta1).ManagedZone} params.resource Request body data
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    update: function (params, options, callback) {
      if (typeof options === 'function') {
        callback = options;
        options = {};
      }
      options || (options = {});

      var parameters = {
        options: utils.extend({
          url: 'https://www.googleapis.com/dns/v2beta1/projects/{project}/managedZones/{managedZone}',
          method: 'PUT'
        }, options),
        params: params,
        requiredParams: ['project', 'managedZone'],
        pathParams: ['managedZone', 'project'],
        context: self
      };

      return createAPIRequest(parameters, callback);
    }

  };

  self.projects = {

    /**
     * dns.projects.get
     *
     * @desc Fetch the representation of an existing Project.
     *
     * @example
     * // BEFORE RUNNING:
     * // ---------------
     * // 1. If not already done, enable the Google Cloud DNS API
     * //    and check the quota for your project at
     * //    https://console.developers.google.com/apis/api/dns
     * // 2. This sample uses Application Default Credentials for authentication.
     * //    If not already done, install the gcloud CLI from
     * //    https://cloud.google.com/sdk and run
     * //    `gcloud beta auth application-default login`.
     * //    For more information, see
     * //    https://developers.google.com/identity/protocols/application-default-credentials
     * // 3. Install the Node.js client library by running
     * //    `npm install googleapis --save`
     *
     * var google = require('googleapis');
     * var dns = google.dns('v2beta1');
     *
     * authorize(function(authClient) {
     *   var request = {
     *     // Identifies the project addressed by this request.
     *     project: '',  // TODO: Update placeholder value.
     *
     *     auth: authClient
     *   };
     *
     *   dns.projects.get(request, function(err, response) {
     *     if (err) {
     *       console.log(err);
     *       return;
     *     }
     *
     *     // TODO: Change code below to process the `response` object:
     *     console.log(JSON.stringify(response, null, 2));
     *   });
     * });
     *
     * function authorize(callback) {
     *   google.auth.getApplicationDefault(function(err, authClient)) {
     *     if (err) {
     *       console.log('authentication failed: ', err);
     *       return;
     *     }
     *     if (authClient.createScopedRequired && authClient.createScopedRequired()) {
     *       var scopes = ['https://www.googleapis.com/auth/cloud-platform'];
     *       authClient = authClient.createScoped(scopes);
     *     }
     *     callback(authClient);
     *   });
     * }
     *
     * @alias dns.projects.get
     * @memberOf! dns(v2beta1)
     *
     * @param {object} params Parameters for request
     * @param {string=} params.clientOperationId For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
     * @param {string} params.project Identifies the project addressed by this request.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    get: function (params, options, callback) {
      if (typeof options === 'function') {
        callback = options;
        options = {};
      }
      options || (options = {});

      var parameters = {
        options: utils.extend({
          url: 'https://www.googleapis.com/dns/v2beta1/projects/{project}',
          method: 'GET'
        }, options),
        params: params,
        requiredParams: ['project'],
        pathParams: ['project'],
        context: self
      };

      return createAPIRequest(parameters, callback);
    }

  };

  self.resourceRecordSets = {

    /**
     * dns.resourceRecordSets.list
     *
     * @desc Enumerate ResourceRecordSets that have been created but not yet deleted.
     *
     * @example
     * // BEFORE RUNNING:
     * // ---------------
     * // 1. If not already done, enable the Google Cloud DNS API
     * //    and check the quota for your project at
     * //    https://console.developers.google.com/apis/api/dns
     * // 2. This sample uses Application Default Credentials for authentication.
     * //    If not already done, install the gcloud CLI from
     * //    https://cloud.google.com/sdk and run
     * //    `gcloud beta auth application-default login`.
     * //    For more information, see
     * //    https://developers.google.com/identity/protocols/application-default-credentials
     * // 3. Install the Node.js client library by running
     * //    `npm install googleapis --save`
     *
     * var google = require('googleapis');
     * var dns = google.dns('v2beta1');
     *
     * authorize(function(authClient) {
     *   var request = {
     *     // Identifies the project addressed by this request.
     *     project: '',  // TODO: Update placeholder value.
     *
     *     // Identifies the managed zone addressed by this request. Can be the managed zone name or id.
     *     managedZone: '',  // TODO: Update placeholder value.
     *
     *     auth: authClient
     *   };
     *
     *   var handlePage = function(err, response) {
     *     if (err) {
     *       console.log(err);
     *       return;
     *     }
     *
     *     var rrsetsPage = response['rrsets'];
     *     if (!rrsetsPage) {
     *       return;
     *     }
     *     for (var i = 0; i < rrsetsPage.length; i++) {
     *       // TODO: Change code below to process each resource in `rrsetsPage`:
     *       console.log(JSON.stringify(rrsetsPage[i], null, 2));
     *     }
     *
     *     if (response.nextPageToken) {
     *       request.pageToken = response.nextPageToken;
     *       dns.resourceRecordSets.list(request, handlePage);
     *     }
     *   };
     *
     *   dns.resourceRecordSets.list(request, handlePage);
     * });
     *
     * function authorize(callback) {
     *   google.auth.getApplicationDefault(function(err, authClient)) {
     *     if (err) {
     *       console.log('authentication failed: ', err);
     *       return;
     *     }
     *     if (authClient.createScopedRequired && authClient.createScopedRequired()) {
     *       var scopes = ['https://www.googleapis.com/auth/cloud-platform'];
     *       authClient = authClient.createScoped(scopes);
     *     }
     *     callback(authClient);
     *   });
     * }
     *
     * @alias dns.resourceRecordSets.list
     * @memberOf! dns(v2beta1)
     *
     * @param {object} params Parameters for request
     * @param {string} params.managedZone Identifies the managed zone addressed by this request. Can be the managed zone name or id.
     * @param {integer=} params.maxResults Optional. Maximum number of results to be returned. If unspecified, the server will decide how many results to return.
     * @param {string=} params.name Restricts the list to return only records with this fully qualified domain name.
     * @param {string=} params.pageToken Optional. A tag returned by a previous list request that was truncated. Use this parameter to continue a previous list request.
     * @param {string} params.project Identifies the project addressed by this request.
     * @param {string=} params.type Restricts the list to return only records of this type. If present, the "name" parameter must also be present.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    list: function (params, options, callback) {
      if (typeof options === 'function') {
        callback = options;
        options = {};
      }
      options || (options = {});

      var parameters = {
        options: utils.extend({
          url: 'https://www.googleapis.com/dns/v2beta1/projects/{project}/managedZones/{managedZone}/rrsets',
          method: 'GET'
        }, options),
        params: params,
        requiredParams: ['project', 'managedZone'],
        pathParams: ['managedZone', 'project'],
        context: self
      };

      return createAPIRequest(parameters, callback);
    }

  };
}

/**
 * @typedef Change
 * @memberOf! dns(v2beta1)
 * @type object
 * @property {dns(v2beta1).ResourceRecordSet[]} additions Which ResourceRecordSets to add?
 * @property {dns(v2beta1).ResourceRecordSet[]} deletions Which ResourceRecordSets to remove? Must match existing data exactly.
 * @property {string} id Unique identifier for the resource; defined by the server (output only).
 * @property {boolean} isServing If the DNS queries for the zone will be served.
 * @property {string} kind Identifies what kind of resource this is. Value: the fixed string "dns#change".
 * @property {string} startTime The time that this operation was started by the server (output only). This is in RFC3339 text format.
 * @property {string} status Status of the operation (output only).
 */
/**
 * @typedef ChangesListResponse
 * @memberOf! dns(v2beta1)
 * @type object
* @property {dns(v2beta1).Change[]} changes The requested changes.
* @property {dns(v2beta1).ResponseHeader} header
* @property {string} kind Type of resource.
* @property {string} nextPageToken The presence of this field indicates that there exist more results following your last page of results in pagination order. To fetch them, make another list request using this value as your pagination token.

In this way you can retrieve the complete contents of even very large collections one page at a time. However, if the contents of the collection change between the first and last paginated list request, the set of all elements returned will be an inconsistent view of the collection. There is no way to retrieve a "snapshot" of collections larger than the maximum page size.
*/
/**
 * @typedef DnsKey
 * @memberOf! dns(v2beta1)
 * @type object
 * @property {string} algorithm String mnemonic specifying the DNSSEC algorithm of this key. Immutable after creation time.
 * @property {string} creationTime The time that this resource was created in the control plane. This is in RFC3339 text format. Output only.
 * @property {string} description A mutable string of at most 1024 characters associated with this resource for the user's convenience. Has no effect on the resource's function.
 * @property {dns(v2beta1).DnsKeyDigest[]} digests Cryptographic hashes of the DNSKEY resource record associated with this DnsKey. These digests are needed to construct a DS record that points at this DNS key. Output only.
 * @property {string} id Unique identifier for the resource; defined by the server (output only).
 * @property {boolean} isActive Active keys will be used to sign subsequent changes to the ManagedZone. Inactive keys will still be present as DNSKEY Resource Records for the use of resolvers validating existing signatures.
 * @property {integer} keyLength Length of the key in bits. Specified at creation time then immutable.
 * @property {integer} keyTag The key tag is a non-cryptographic hash of the a DNSKEY resource record associated with this DnsKey. The key tag can be used to identify a DNSKEY more quickly (but it is not a unique identifier). In particular, the key tag is used in a parent zone's DS record to point at the DNSKEY in this child ManagedZone. The key tag is a number in the range [0, 65535] and the algorithm to calculate it is specified in RFC4034 Appendix B. Output only.
 * @property {string} kind Identifies what kind of resource this is. Value: the fixed string "dns#dnsKey".
 * @property {string} publicKey Base64 encoded public half of this key. Output only.
 * @property {string} type One of "KEY_SIGNING" or "ZONE_SIGNING". Keys of type KEY_SIGNING have the Secure Entry Point flag set and, when active, will be used to sign only resource record sets of type DNSKEY. Otherwise, the Secure Entry Point flag will be cleared and this key will be used to sign only resource record sets of other types. Immutable after creation time.
 */
/**
 * @typedef DnsKeyDigest
 * @memberOf! dns(v2beta1)
 * @type object
 * @property {string} digest The base-16 encoded bytes of this digest. Suitable for use in a DS resource record.
 * @property {string} type Specifies the algorithm used to calculate this digest.
 */
/**
 * @typedef DnsKeySpec
 * @memberOf! dns(v2beta1)
 * @type object
 * @property {string} algorithm String mnemonic specifying the DNSSEC algorithm of this key.
 * @property {integer} keyLength Length of the keys in bits.
 * @property {string} keyType One of "KEY_SIGNING" or "ZONE_SIGNING". Keys of type KEY_SIGNING have the Secure Entry Point flag set and, when active, will be used to sign only resource record sets of type DNSKEY. Otherwise, the Secure Entry Point flag will be cleared and this key will be used to sign only resource record sets of other types.
 * @property {string} kind Identifies what kind of resource this is. Value: the fixed string "dns#dnsKeySpec".
 */
/**
 * @typedef DnsKeysListResponse
 * @memberOf! dns(v2beta1)
 * @type object
* @property {dns(v2beta1).DnsKey[]} dnsKeys The requested resources.
* @property {dns(v2beta1).ResponseHeader} header
* @property {string} kind Type of resource.
* @property {string} nextPageToken The presence of this field indicates that there exist more results following your last page of results in pagination order. To fetch them, make another list request using this value as your pagination token.

In this way you can retrieve the complete contents of even very large collections one page at a time. However, if the contents of the collection change between the first and last paginated list request, the set of all elements returned will be an inconsistent view of the collection. There is no way to retrieve a "snapshot" of collections larger than the maximum page size.
*/
/**
 * @typedef ManagedZone
 * @memberOf! dns(v2beta1)
 * @type object
 * @property {string} creationTime The time that this resource was created on the server. This is in RFC3339 text format. Output only.
 * @property {string} description A mutable string of at most 1024 characters associated with this resource for the user's convenience. Has no effect on the managed zone's function.
 * @property {string} dnsName The DNS name of this managed zone, for instance "example.com.".
 * @property {dns(v2beta1).ManagedZoneDnsSecConfig} dnssecConfig DNSSEC configuration.
 * @property {string} id Unique identifier for the resource; defined by the server (output only)
 * @property {string} kind Identifies what kind of resource this is. Value: the fixed string "dns#managedZone".
 * @property {string} name User assigned name for this resource. Must be unique within the project. The name must be 1-63 characters long, must begin with a letter, end with a letter or digit, and only contain lowercase letters, digits or dashes.
 * @property {string} nameServerSet Optionally specifies the NameServerSet for this ManagedZone. A NameServerSet is a set of DNS name servers that all host the same ManagedZones. Most users will leave this field unset.
 * @property {string[]} nameServers Delegate your managed_zone to these virtual name servers; defined by the server (output only)
 */
/**
 * @typedef ManagedZoneDnsSecConfig
 * @memberOf! dns(v2beta1)
 * @type object
 * @property {dns(v2beta1).DnsKeySpec[]} defaultKeySpecs Specifies parameters that will be used for generating initial DnsKeys for this ManagedZone. Output only while state is not OFF.
 * @property {string} kind Identifies what kind of resource this is. Value: the fixed string "dns#managedZoneDnsSecConfig".
 * @property {string} nonExistence Specifies the mechanism used to provide authenticated denial-of-existence responses. Output only while state is not OFF.
 * @property {string} state Specifies whether DNSSEC is enabled, and what mode it is in.
 */
/**
 * @typedef ManagedZoneOperationsListResponse
 * @memberOf! dns(v2beta1)
 * @type object
* @property {dns(v2beta1).ResponseHeader} header
* @property {string} kind Type of resource.
* @property {string} nextPageToken The presence of this field indicates that there exist more results following your last page of results in pagination order. To fetch them, make another list request using this value as your page token.

In this way you can retrieve the complete contents of even very large collections one page at a time. However, if the contents of the collection change between the first and last paginated list request, the set of all elements returned will be an inconsistent view of the collection. There is no way to retrieve a consistent snapshot of a collection larger than the maximum page size.
* @property {dns(v2beta1).Operation[]} operations The operation resources.
*/
/**
 * @typedef ManagedZonesDeleteResponse
 * @memberOf! dns(v2beta1)
 * @type object
 * @property {dns(v2beta1).ResponseHeader} header
 */
/**
 * @typedef ManagedZonesListResponse
 * @memberOf! dns(v2beta1)
 * @type object
* @property {dns(v2beta1).ResponseHeader} header
* @property {string} kind Type of resource.
* @property {dns(v2beta1).ManagedZone[]} managedZones The managed zone resources.
* @property {string} nextPageToken The presence of this field indicates that there exist more results following your last page of results in pagination order. To fetch them, make another list request using this value as your page token.

In this way you can retrieve the complete contents of even very large collections one page at a time. However, if the contents of the collection change between the first and last paginated list request, the set of all elements returned will be an inconsistent view of the collection. There is no way to retrieve a consistent snapshot of a collection larger than the maximum page size.
*/
/**
 * @typedef Operation
 * @memberOf! dns(v2beta1)
 * @type object
 * @property {dns(v2beta1).OperationDnsKeyContext} dnsKeyContext Only populated if the operation targeted a DnsKey (output only).
 * @property {string} id Unique identifier for the resource. This is the client_operation_id if the client specified it when the mutation was initiated, otherwise, it is generated by the server. The name must be 1-63 characters long and match the regular expression [-a-z0-9]? (output only)
 * @property {string} kind Identifies what kind of resource this is. Value: the fixed string "dns#operation".
 * @property {string} startTime The time that this operation was started by the server. This is in RFC3339 text format (output only).
 * @property {string} status Status of the operation. Can be one of the following: "PENDING" or "DONE" (output only).
 * @property {string} type Type of the operation. Operations include insert, update, and delete (output only).
 * @property {string} user User who requested the operation, for example: user@example.com. cloud-dns-system for operations automatically done by the system. (output only)
 * @property {dns(v2beta1).OperationManagedZoneContext} zoneContext Only populated if the operation targeted a ManagedZone (output only).
 */
/**
 * @typedef OperationDnsKeyContext
 * @memberOf! dns(v2beta1)
 * @type object
 * @property {dns(v2beta1).DnsKey} newValue The post-operation DnsKey resource.
 * @property {dns(v2beta1).DnsKey} oldValue The pre-operation DnsKey resource.
 */
/**
 * @typedef OperationManagedZoneContext
 * @memberOf! dns(v2beta1)
 * @type object
 * @property {dns(v2beta1).ManagedZone} newValue The post-operation ManagedZone resource.
 * @property {dns(v2beta1).ManagedZone} oldValue The pre-operation ManagedZone resource.
 */
/**
 * @typedef Project
 * @memberOf! dns(v2beta1)
 * @type object
 * @property {string} id User assigned unique identifier for the resource (output only).
 * @property {string} kind Identifies what kind of resource this is. Value: the fixed string "dns#project".
 * @property {string} number Unique numeric identifier for the resource; defined by the server (output only).
 * @property {dns(v2beta1).Quota} quota Quotas assigned to this project (output only).
 */
/**
 * @typedef Quota
 * @memberOf! dns(v2beta1)
 * @type object
 * @property {integer} dnsKeysPerManagedZone Maximum allowed number of DnsKeys per ManagedZone.
 * @property {string} kind Identifies what kind of resource this is. Value: the fixed string "dns#quota".
 * @property {integer} managedZones Maximum allowed number of managed zones in the project.
 * @property {integer} resourceRecordsPerRrset Maximum allowed number of ResourceRecords per ResourceRecordSet.
 * @property {integer} rrsetAdditionsPerChange Maximum allowed number of ResourceRecordSets to add per ChangesCreateRequest.
 * @property {integer} rrsetDeletionsPerChange Maximum allowed number of ResourceRecordSets to delete per ChangesCreateRequest.
 * @property {integer} rrsetsPerManagedZone Maximum allowed number of ResourceRecordSets per zone in the project.
 * @property {integer} totalRrdataSizePerChange Maximum allowed size for total rrdata in one ChangesCreateRequest in bytes.
 * @property {dns(v2beta1).DnsKeySpec[]} whitelistedKeySpecs DNSSEC algorithm and key length types that can be used for DnsKeys.
 */
/**
 * @typedef ResourceRecordSet
 * @memberOf! dns(v2beta1)
 * @type object
 * @property {string} kind Identifies what kind of resource this is. Value: the fixed string "dns#resourceRecordSet".
 * @property {string} name For example, www.example.com.
 * @property {string[]} rrdatas As defined in RFC 1035 (section 5) and RFC 1034 (section 3.6.1).
 * @property {string[]} signatureRrdatas As defined in RFC 4034 (section 3.2).
 * @property {integer} ttl Number of seconds that this ResourceRecordSet can be cached by resolvers.
 * @property {string} type The identifier of a supported record type, for example, A, AAAA, MX, TXT, and so on.
 */
/**
 * @typedef ResourceRecordSetsListResponse
 * @memberOf! dns(v2beta1)
 * @type object
* @property {dns(v2beta1).ResponseHeader} header
* @property {string} kind Type of resource.
* @property {string} nextPageToken The presence of this field indicates that there exist more results following your last page of results in pagination order. To fetch them, make another list request using this value as your pagination token.

In this way you can retrieve the complete contents of even very large collections one page at a time. However, if the contents of the collection change between the first and last paginated list request, the set of all elements returned will be an inconsistent view of the collection. There is no way to retrieve a consistent snapshot of a collection larger than the maximum page size.
* @property {dns(v2beta1).ResourceRecordSet[]} rrsets The resource record set resources.
*/
/**
 * @typedef ResponseHeader
 * @memberOf! dns(v2beta1)
 * @type object
 * @property {string} operationId For mutating operation requests that completed successfully. This is the client_operation_id if the client specified it, otherwise it is generated by the server (output only).
 */
module.exports = Dns;

redpajama_set_name: RedPajamaGithub


text:
Q: MPAndroidChart refresh graph every X inputs How to refresh graph dynamic?

*

*Init Chart.
    final LineData mLineData = mChart.getData();

    final ILineDataSet[] xSet = {mLineData.getDataSetByIndex(0)};

    final int xSetArrayItem = 0;

    if (xSet[xSetArrayItem] == null) {
        xSet[xSetArrayItem] = createSet("Ecg", getResources().getColor(android.R.color.holo_red_dark));
        mLineData.addDataSet(xSet[xSetArrayItem]);
    }

*After this I'm doing subscribe for real data and putting it into graph.
mLineData.addEntry(new Entry(xValue++, ecgModel.getBody().getData()[i]), 0);

mLineData.notifyDataChanged();

// let the chart know it's data has changed
   mChart.notifyDataSetChanged();
// limit the number of visible entries
   mChart.setVisibleXRangeMaximum(200);
// move to the latest entry
  mChart.moveViewToX(xValue);

*And Problem is I don't want to scroll X Axis. I want to put for example 400 inputs clear graph and let chart draw new 400 inputs.
Something like this:
       if (xValue == 400) {
           xValue = 0;
           mLineData.clearValues();
           mChart.invalidate();
         }

- But this clearing graph but then nothing is draw on chart.

A: try this,
yVals.clear();
xLabel.clear();
set = new BarDataSet(yVals, "");
ArrayList<IBarDataSet> dataSets = new ArrayList<>();
dataSets.add(set);
data = new BarData(dataSets);
ArrayList<Float> count = reportPojo.getCounts();
for (int i = 0; i < count.size(); i++) {
    float val = count.get(i);
    yVals.add(new BarEntry(i, val));
}
for (String label : reportPojo.getLabels()) {
    xLabel.add(label);
}
chart.setData(data);
set.notifyDataSetChanged();
chart.getData().notifyDataChanged();
chart.notifyDataSetChanged();
chart.invalidate();
return set;

redpajama_set_name: RedPajamaStackExchange


The Weld 8 School District Homyak PK-8 (Originally name Quest Academy), is a new two-round PK-8 school located in the Sweetgrass neighborhood of Dacono, CO. The current school is currently housed in a campus of modular classroom building. The new site is located 1 mile north and will allow the school to grow from 200 students to 400 students. The 47,000 square foot school will be located on a 12 acre site that includes site amenities of age appropriate playgrounds as well as a multi-purpose grass field.
The school design was focused around the idea and concept that the school is a second home to the students. The architectural style and scale was influenced by the existing neighborhood as well as pays homage to agrarian history of the site.


Turkish Official: Karabakh Issue Is "Taken Out From Freezer"
"The Aim Of My Visit To Yerevan Was To Create A New Atmosphere"
Will Turkey Change Its Stances?
Growing Azeri Defense Budget Build-Up - In Earnest Or For Show?
Benefits The Prosecutor's Office First?
Is There A Local Crisis Threat?
Armenian leader urges Azerbaijan to recognize NK right to self det.
MP's Office Invites Community to Embrace Armenian Art School Progs.
VivaCell-MTS, USAID/CAPS joint sponsoring Monuments Awareness Proj.
Armenian chief prosecutor says recent killing in capital "vendetta"
How much does God love His Christians?
BAKU: Ambassador of Russia to Azerbaijan: new situation beneficial?
BAKU: Election in ROA could be argument in favor of election in Az.
BAKU: Kremlin's position: Main Responsibilityd with Armenia, Azerb.
BAKU: Ambassador of China: "Like Taiwan, NK conflict complicated..."
Dugin: "Russia must improve relations with Azerbaijan, because..."


text:
GdS: Kjaer prepares for long-awaited return – his importance at Milan is evident
By Isak Möller - 2 January 2021, 11:36
In a young team like Milan, it's necessary to have experienced leaders, which the Rossoneri became painfully aware of at the start of the 2019/20 season. Then in January, two players arrived and fixed it all.
They are, of course, Zlatan Ibrahimovic and Simon Kjaer. The former is still recovering from his injury but the Danish international is back and will play from start against Benevento. A big boost for Milan, certainly.
As highlighted by Gazzetta Dello Sport (via MilanNews), Milan have been forced to deal with several injuries as of late and the former Atalanta man will provide them with experience, solidity and leadership.
Without Kjaer, between the Europa League and Serie A, the Rossoneri claimed four wins and two draws. With the Dane, though, it's a completely different story, as Milan conceded eight goals while he was away.
That is the same numbers of goals they had conceded in total prior to his injury, which says a lot about his impact on the pitch. In short, the importance of Kjaer for the team is evident.
The 31-year-old defender is less flashy than Ibrahimovic, but certainly no less effective. And not only from a technical point of view. He is also, in fact, a leader: next to him practically everyone improves, from the very young to Alessio Romagnoli.
READ MORE: Milan begin modernisation of training ground Milanello – the timeline
Tags AC Milan Simon Kjaer

redpajama_set_name: RedPajamaCommonCrawl


text:
Singapore GP: Preview - Sauber
Boosted by an excellent result at the final round of the European season, the Sauber F1 Team is on the move to Asia. In Monza the Swiss outfit secured its third podium in the 2012 FIA Formula One World Championship with Sergio Perez finishing second. The team scored 20 championship points in Italy with Kamui Kobayashi contributing two points when taking the chequered flag in ninth. During the forthcoming chain of Grands Prix in Asia, the Sauber C31-Ferrari will receive some updates on a race-by-race basis.
On the weekend of the 21st to 23rd September it will be the fifth time Formula One will race at the Marina Bay street circuit in Singapore. From the word go in 2008 the spectacular night race established itself as a true asset to the world championship. With its 23 corners the five kilometre track requires a high downforce level and is tough on brakes and tyres. For the drivers it is extremely demanding as well. High humidity and an ambient temperature of more than 30 degrees even at night creates a physical challenge, while the winding circuit with no run-off areas doesn't forgive the slightest driver error.
Kamui Kobayashi: "After our great result in Monza, everybody in the team is very motivated. Singapore is a truly special event. As a night race it has established itself as a real highlight. Personally I like the place. Also it's not too far from my home country, and there are always a lot of Japanese fans. The track is quite demanding with a lot of corners, and mostly slow ones. In the past this kind of track didn't really suit our car, but with this year's Sauber C31 things have changed. I don't see any reason why we shouldn't be competitive there."
Sergio Perez: "The Singapore Grand Prix is a very special race on an extraordinary track with an unique schedule. You race at night and you live at night. Also it will be the first round back in Asia after quite a while. The amount of travelling is increasing a lot now. I generally like street circuits and the one in Singapore is physically quite demanding, but I feel prepared for that. Also for our car it should be an okay track to race on. I am very much looking forward to it and I want to get in another good result for the team at that very prestigious race."
Giampaolo Dall'Ara, Head of Track Engineering: "Singapore is a street circuit with lots of corners and short straights. Therefore overtaking is difficult, which makes qualifying particularly important. Good traction is crucial on this stop-and-go track with mainly low speed and just a couple of medium speed corners. In some places the surface is very bumpy - something to bear in mind when setting up the car. You have to keep an eye on the brakes, because they have very little time to cool down between corners. The track surface is not very rough. Pirelli will allocate the supersoft and the soft compounds, which should work well in qualifying, but I don't expect any chance of a one-stop strategy in the race. Concerning strategy: one thing we have to consider is that the chance of a safety car period is very high on this track. This means we have to bear in mind the tyre requirements and, at the same time, be ready at any moment to change our strategy in case of a safety car deployment. Out of the seven upcoming races I expect this one to be the most difficult for our C31, but we will have our next aero update in Singapore, which should help to compensate for this and still put us in a position for a strong race."
Singapore GP: Preview - Mercedes
Ma Qing Hua to get another GP outing in HRT
Kaltenborn on Sauber's rollercoaster week
Italian GP: Race notes - Sauber
Italian GP: Qualifying notes - Sauber
Italian GP: Practice notes - Sauber
Soft Pauer discounts Live Timing App for remaining races
Key joins Toro Rosso
Italian GP: Preview - Sauber
Belgian GP: Race notes - Sauber


This block can be made by quick piecing or by cutting templates and is suitable for hand as well as machine piecing. This block is effective in two or more colours and if you change the tones of the diamond pieces it can look quite three dimensional.
The block is based on a four patch grid so it is suited to block sizes that are easily divisible by four. The template sizes are for a 12in block. To draw another size take a square the size of the finished block and draw an underlying grid of 64 squares (eight by eight). Mark on the lines that you need and carefully cut apart or trace onto template plastic.
If you are only making one block then these are not so relevant, but if you are making a number then the time saved starts to mount up. Cut the corner squares as strips and piece light to dark. Cut these into strips and turn alternately to make the corner units. Use the same method for the rectangle and square unit. Cut a wide and a narrow strip and cut the 2in strips off after piecing. See Figure 2.
Follow the construction diagram in Figure 1 to piece a three colour Blackford's Beauty block.
If you grade your scraps into light and dark and use as shown in the diagram then the shapes start to appear 3D. A whole quilt could be made using scraps as long as the tones of light and dark were in the same place.
Diamonds can be made using a strip by putting a square the same width RS down on one end and sewing along the diagonal. Press open and add another square to the opposite end ensuring the points are going the right way. See Fig 4. If you are making a lot of blocks it is always quicker to make the same stage at the same time.
This block is also known as Black Beauty.


text:
HomeNortheastNagaland
'Funkaar' Kapil Sharma's biopic will be releasing soon
Fraud collects money from shopkeepers promises to give loan in Ganeshguri
Nagaland: Naga Organizations condemns Centre's Decision To Extend AFSPA; says unacceptable
Nagaland condemned and declared the Centre's decision to extend AFSPA as unacceptable.
After the Ministry of Home Affairs extended the Armed Forces Special Powers Act in Nagaland for a period of 6 more months, several Naga outfits condemned the Centre's decision.
They termed the government's decision as unacceptable. And said that it's an attempt to "suppress Nagas for generations to come."
Nagaland declared as "disturbed area" by Centre
The central government declared the entire Nagaland as a "disturbed area" for six more months with effect from December 30 under the AFSPA.
The K Elu Ndang, general secretary of Naga Hoho said that the Government of India has ignored the wishes of the Naga People.
He further added, "Naga people will not accept it."
Also, as per information, Eastern Nagaland People's Organisation has called a meeting on 7th January to discuss the extension of AFSPA.
A committee will soon be instituted to look into the withdrawal of the AFSPA from Nagaland as asserted by the Government of Nagaland.
On December 23, Union Home Minister Amit Shah chaired a key meeting including Nagaland CM Neiphiu Rio, Nagaland Deputy CM Y Patton, NPFLP leader TR Zeliang and Assam CM Himanta Biswa Sarma.
They decided in the meeting that a committee headed by MHA Additional Secretary N-E will be formed to look into the possibility of withdrawing AFSPA from Nagaland.
ALSO READ: AFSPA EXTENDED IN NAGALAND FOR 6 MONTHS


I am a 6th to 8th grade math teacher and have been at Christ the Teacher since 2003. I was born and raised in Pittsburgh, PA, and am still an avid Pittsburgh sports fan. I am a graduate of Carlow University with teaching credentials from Wilmington University. I am a moderator of Math League and Math Counts.
My husband, John, and I live in Bear and have two grown children, Megan and Sean. In my free time I enjoy reading, going to the beach, and spending time with family and friends.


Life is a journey, and everyone finds themselves in need of a little help or support somewhere along the way. That's why we're here.
The International Well-Being Center was founded to provide the coaching and counseling that so many struggle to find in Jakarta, but earnestly need.
Our services include psychometric therapy and assessments, talk-therapy and wellness coaching. We serve individuals, children, couples, families and corporations.
We offer face-to-face sessions as well as telephonic and web-based services for individuals who might find an appointment difficult to attend.
Whether you're looking for solution-based therapy, general wellness information, one-off consultations, or long term counseling, we help you achieve your goals.
All services are available in English, French, Indonesian and Korean.


This method uses the fact that if a star has a planet (or planets) around it, it is not strictly correct to say that the planet orbits the star. Instead, the planet and the star orbit their common center of mass. Because the star is so much more massive than the planets, the center of mass is within the star and the star appears to wobble slightly as the planet travels around it. Astronomers can measure this wobble by using spectroscopy. If a star is traveling towards us, its light will appear blueshifted, and if it is traveling away the light will be redshifted. Spectroscopy can show this change in color from a star as it moves towards and away from us, orbiting the center of mass of the star-planet system.
Many of the planets that have been discovered by this method are very large and very close to their stars. These planets, called super-Jupiters, are much larger than Jupiter, and orbit their stars in a matter of days. Such a large planet causes a large wobble, and this, as well as the short orbit time, makes these planets easier to detect than ones that are smaller or farther from their stars. Over 784 planets have been discovered (as of October 2018) by this method.


text:
LUXURY EXTERNAL SHADING SINCE 1987
Showsites
CB x Bridgman
Shading Guide
Patio Awnings
Anguilla Awning
Tortola Awning
Cuba Awning
Electric Awnings
Pergola Awnings
Waterproof Awnings
Our Patio Awning Models
Classic Pod
Deluxe Pod
Prestige Pod
Pergola – Opening Roof
Pergola – Retractable Roof
Outdoor Living Pod
Our Louvered Roof Models
External Blinds
Antiguan Blind
Cayman Blind
Automated External Blinds
External Roller Blinds
External Roof Blinds
Conservatory Roof Blinds
Patio Door Blinds
Pergola & Veranda Blinds
Skylight & Roof Window Blinds
Our External Blind Models
Home > Blog > The Top Five Things to Consider When Choosing a Patio Awning
Caribbean Blinds Icons
US 0344 800 1947
The Top Five Things to Consider When Choosing a Patio Awning
Patio awnings are fast becoming the external shading product of choice within many residential properties as they provide a quick, easy and affordable solution to transform any outdoor space. Both practical and stylish, awnings offer instant shade and shelter and can be designed and built to a bespoke brief.
With travel restrictions still very much up in the air, outdoor living is certain to remain in full swing this summer as much of the UK will continue to 'holiday at home'. Here are five things to be aware of when choosing a patio awning, taking into consideration fabrics, operation and installation.
Is it fully waterproof?
All patio awnings will get wet (especially with the unpredictable British weather) however, it's how you look after your awning that will determine how it performs and lasts. Continuous and consistent use of a patio awning in rain showers will affect the look and appearance of the fabric, so leaving a wet awning to fully dry out before retracting away will help minimise any rippling or waviness in the material. In persistent rain showers where this is not possible and the fabric has to be rolled away while it's still damp, it's essential that the awning be opened up at the soonest opportunity to allow it to breathe and properly dry out. Choosing a premium fabric that incorporates a self-clean effect coating such as TEXGard® will help deter dirt and most importantly water from the surface of your awning, preventing the growth of mould and algae. This combined with a 14-degree pitch (or greater) on the awning will ensure rainwater will run off and not 'pool' on the material, effectively providing shelter from rain showers and with the additional benefit of reduced surface dirt and debris.
Will it withstand strong winds?
If extreme weather is predicted, it's important for your awning to be fully retracted beforehand, as attempting to do this during high winds can cause serious damage to both the awning, the property and the user. If the fabric is flapping around and the mechanism is flexing, this is another sign that the awning should be rolled away. Awnings with cable tensioned folding arms will offer the highest wind resistance, withstanding wind speeds of up to 30mph. They will also help keep the fabric taut even in exposed locations where gusts and breezes can be much stronger. If you've opted for an electric awning, you can choose to add wind sensors that will detect the wind speed and automatically retract an awning should strong winds exceed safe levels. Whilst these sensors are not a fail-safe device, they do offer additional protection and peace of mind and are therefore highly recommended to protect both your patio awning and property.
Is planning permissioned required?
In the majority of cases, planning permission is not required for a patio awning as they are not considered a permanent structure (like an extension). However, if you live in a conservation, green belt or area of outstanding natural beauty, you will most likely need to obtain permission. It is always recommended to contact your local planning authority to check whether permission is required, as the rules can vary. The width and depth of a patio awning are vital to how it will perform, so when deciding on the size of your awning you will need to consider a number of factors including any obstructions (trees, fences and pipes/guttering), the position of the sun when it sets and rises (as this will determine appropriate levels of sun protection) and whether the space will be used primarily for outdoor dining. For a small dining table, a projection of 2.5m is adequate, however, for a larger family or for those who like to entertain, a minimum projection of 3m is required.
How easy is it to use?
Patio awnings are widely considered to be more versatile than other external shading systems including gazebos and parasols due to their ease of use, as well as the adequate shelter, privacy and instant style they add to any property. A motorised awning will allow you to extend and retract at just the touch of a button, with any add-ons such as lighting and heating operated from the same hand-held remote. The latest bi-directional motors offer even more control, enabling you to view the exact position of the awning via an app on your smartphone and adjust it to suit your needs.
How long will it take to install?
A professional and expert installation is just as important as the quality of the awning itself. Bespoke awnings are made to measure with specific brackets and fixings to suit the property in which they are being installed – whether that be a two-storey house or single storey façade such as a bungalow or extension – with the installation period ranging from less than half a day to a full day. Attention to detail is key, so finishing touches such as concealed fixing brackets and colour co-ordinated stitching on the fabric along a full cassette casing that offers protection from harsh weather when the awning is not in use, will ensure an elegant installation that provides exemplary cover and fully transforms your outdoor space.
If you've found this article useful why not visit our knowledge hub which is packed full of FAQs covering everything to consider when choosing a patio awning and supplier.
Let's Get Summer Ready
With Christmas now a distant memory (albeit it was only 2 weeks ago) our thoughts turn to Summer and in particular our gardens. With longer than usual lead times, due to the ongoing…
2021 Review: The Perfect Storm
The end of the year is fast approaching, with just 10 days until New Year. As in 2020, the outdoor living and solar shading industry has seen tremendous growth. The pandemic with its various lockdowns, restrictions and travel bans has meant we all continue to invest in our…
MD Appointed Family Business United Awards Judge
We are delighted to announce that our Managing Director, Stuart Dantzic, has joined the judging panel for the Family Business of the Year Awards 2022 along…
Discover the lifestyle enhancing benefits and superior features of our products.
Be inspired by some of our thousands of installations around the country.
Find out why external shading is the most effective way to prevent solar heat gain.
Multi Award Winning Family Run Business
Caribbean Blinds UK Ltd
Head Office, Factory & Showsite
Woodhall Business Park
CO10 1WH
Sign up for offers and updates
LUXURY UK MANUFACTURED EXTERNAL SHADING SINCE 1987
Website Designby This is Fever
© Copyright Caribbean Blinds UK Ltd 2022
Caribbean Blinds (UK) Ltd is registered in England No. 2192658


text:
ATTO Technology Host Adapters Used in
Video Workflows at the 2009 French Tennis Open
Amherst, NY (June 2, 2009) — ATTO Technology, Inc., a global leader of storage connectivity and infrastructure solutions for data-intensive computing environments, announced today that its Celerity FC-41ES and FC-42XS Fibre Channel Host Adapters are being used as part of Avid editing systems provided by Cap Ciné at the 2009 French Tennis Open. ATTO Celerity host adapters will be used to connect an Avid workflow including: one Avid Interplay with two Media Indexer servers, three Interplay Transfer servers, one 16TB Unity MediaNetworks, eight Media Composer Nitris DX and DigiDesign Pro Tools system for France Television. This solution is working in conjunction with the same EVS workflow that was used for the 2008 Olympic Games in Beijing.
The Celerity Fibre Channel host adapters used are 4Gb/s single-channel Fibre Channel cards – with PCIe (FC-42ES) and PCI-X (FC-41-XS) connectivity offering up to 400MB/s performance, supporting the most intensive data applications, including digital content creation, tape streaming and backup, rich content delivery and complex databases. The host adapters feature ATTO's exclusive Advanced Data Streaming (ADS™) Technology that provides controlled acceleration of large and small blocks of data and manages latency, enabling users to achieve smoother and more efficient data transfers in streaming environments.
"ATTO is proud to be a part of the high-performance editing solution used for this internationally recognized tennis tournament," states Tim Klein, president and CEO for ATTO Technology, Inc. "With 20 years of experience providing reliable connectivity solutions to the media and entertainment industry, ATTO continues to build our brand through well-established partner relationships."
Purchase ATTO products through leading Value Added Resellers, System Integrators and the ATTO Web Store. Learn more: www.atto.com/howtobuy/
Follow ATTO on Twitter, LinkedIn, Instagram and Facebook (@ATTOTechnology).
For over 30 years ATTO Technology, Inc. has been a global leader across the IT and media & entertainment markets, specializing in network and storage connectivity and infrastructure solutions for the most data-intensive computing environments. ATTO works with customers and partners to deliver end-to-end solutions to better store, manage and deliver data, often as an extension of their design teams. ATTO manufactures host adapters, smart NICs, storage appliances and controllers, intelligent bridges, Thunderbolt™ adapters, and software. ATTO solutions provide a high level of connectivity to all storage interfaces, including Fibre Channel, SAS, SATA, iSCSI, Ethernet, NVMe and Thunderbolt. ATTO is the Power Behind the Storage.
All trademarks, trade names, service marks and logos referenced herein belong to their respective companies.
Contact: Richard Root
ATTO Technology, Inc.
Contact ATTO
Phone +1 (716) 691-1999 x285