A record number of American adults will make food and beverage purchases for the Big Game this year, according to a survey by the National Retail Federation and Prosper Insights & Analytics. Of the 76% of American adults who plan to watch, 82% plan to purchase food and beverages, up from 80% in 2017. Five percent of adults will watch the game at their favorite local bar or restaurant.
Americans are expected to spend $81.17 on average for Big Game supplies, for a total of $15.3 billion, up 8.5% from $14.1 billion in 2017. Those aged 25-34 will spend the most of any age group at an average of $118.43.
One of the most popular food choices for the game is chicken wings, and U.S. adults are expected to eat 1.4 billion wings during the weekend of the Big Game, according to the National Chicken Council. This is an all-time high, up 1.5% from 2017. It is enough wings to put 625 wings on every seat in all 32 NFL stadiums or to circle the Earth three times.
More than half of chicken wing eaters typically like their wings with ranch dressing, followed by buffalo/hot sauce, BBQ sauce, honey mustard blue cheese, teriyaki sauce, and sriracha. Sixty percent of wing eaters prefer traditional, bone-in wings, while 40% choose boneless.
Two of the biggest winners of the Big Game might be local grocers and restaurants, as a survey from Valassis shows 43% of consumers will primarily shop through local retailers and grocers for the game. More than half are only willing to travel less than four miles for their purchases, while half of those planning to order food will do so from restaurants within just five miles.
Even though the game is less than a week away, Valassis suggests it is not too late for retailers to market their products for event. A majority of consumers will complete their purchases just a day or two before, or even the day of, the Big Game. Most customers, 75%, will shop for groceries and supplies in-store, compared to 15% who will do so both in-store and online and 10% who plan to shop only online.


Trachtenberg School students are invited to attend The Wilson Center-Arctic Circle Forum: The United States and Russia in the Arctic on Wednesday, June 21, from 8:30 am-5:40 pm at the Ronald Reagan Building and International Trade Center Amphitheater. Register to attend.
Join us to explore this crucial Arctic relationship and the implications for all Arctic nations, the communities that call the region home, and the countries and organizations that have a vested interest in a peaceful and sustainable Arctic.


text:
InLiving
Then the Earthquake Happened
Andrew and Katja spent more than three years looking in Abruzzo until they found their perfect home. Something that had enough space for living and working — plus fantastic views. Then came the earthquake . . . here's how they recovered their dream and are discovering all the pleasures of living in Abruzzo.
"I discovered Abruzzo on the internet," says Andrew Miles, a British photographer and former tv producer for National Geographic. He and his then-girlfriend, German-born Katja von Schweitzer, decided to come for a ski holiday in 2005. "We stayed in Pescocostanzo and skied Roccarasso and were hooked," says Katja, who had lived in Switzerland and Austria previously, so she knows a thing or two about skiing. She was enchanted by what she found in Abruzzo.
Featured image: Andrew Miles, Katja von Schweitzer and their children Safina and Rocco
The two married, had two children (Safina, now 12 and Rocco, 11) and, as Andrew became more and more disillusioned about all the travel he had to do for his job (it was about 90% travel), decided to set their sights on Abruzzo, which they had both fallen hard for. They left their home in Brighton (UK) many, many times in search of the perfect property. Andrew estimates they saw at least 100 houses. But that all changed in 2008 when they went to San Benedetto in Perillis.
Andrew was searching the internet when he saw it. It seemed perfect, but he phoned a local friend and asked her to go and have a look before they made yet another dead-end trip. Her response was simply, "I think you should come." Turns out, if they hadn't bought it, she was going to!
"The house is massive," says Andrew. "It is a mix of a 15th century palazzo, an 8th century fortified building, and an 11th century watch tower. We learned that the palazzo was built by a Spanish captain." The 1000-square-meters property was well situated in the middle of four national parks, affording great views, and had the potential to give them everything they were looking for: a home for their family, four apartments for tourists, a place where they could work, a space for a garden and quick access to the wilderness of Abruzzo. Everything was falling into place, they were getting ready to start the renovation but then came 2009 and the earthquake.
The watch tower collapsed, although there was not much damage to the rest of the property. "Still, the house was put into the red zone," says Andrew. "And time stopped in its tracks. Now we owned a house that we couldn't live in and the money we might get from the Italian government would barely fix the watch tower."
The house before and after the post-earthquake restoration
Eventually they learned that they could have the house declared a historically important property in Italy, which they did. The exterior construction was taken entirely out of their hands and they had neither a key nor a say in the work for more than a year. In 2018, Katja took a rental in nearby Popoli so they could be closer to the project, and in mid-September this year, they got their keys. But while the house looks amazing on the outside — restored to a high standard, and as original as possible — inside it has no electricity, kitchen, or internet, and their furniture is stuck on a truck in France. So Popoli it is for a while longer, but they are hoping to move in by the spring.
Why San Benedetto?
Apart from it being in a simply beautiful corner of Abruzzo, Andrew and Katja chose San Benedetto in Perilis because it is such a special place. "There's lots going on here," says Katja. "There's an 8th century Abbey and a gorgeous main street, which is being restored at the same time as our palazzo." The last time there were even 1,000 residents in the town was the 1950s, but they both agree that this will change.
An ancient stone incorporated in the building
"It's in the middle of four parks, close to the motorway and it's easy to get to anywhere from here," adds Andrew. "Mountains, hiking, skiing, the beach – it's all here. And it's being discovered."
Andrew especially loves all the open spaces. He enjoys being so close to nature and calls it "very elemental." Having four proper seasons is incredibly important to them both, and they are struck by the kindness and generosity of the people they've met as well as by what they agree is the best food they've had anywhere. And they swear by the Montepulciano wine. . .
"I love the intergenerational aspect of living in Abruzzo," says Andrew. "Go to a restaurant and you'll see the young and the old interacting together, enjoying themselves and their lives in this amazing place."
The old part of San Benedetto in Perilis
Andrew and Katja have been building a travel business since arriving in Abruzzo, with the aim of sharing the bounties of this place with tourists. First there was Sacred-Walks holidays, which is now being incorporated into the larger Exploring Abruzzo site where, with their friend and guide Lorenzo, they offer everything from food and wine tours to guided private one-day tours, bespoke holidays and the sacred walks experience.
Andrew and Katja in front of their home
The earthquake could have dissuaded them. Not speaking much Italian could have stopped them in their tracks (although Andrew admits to knowing a lot of construction terms by now). And the time factor could have been a negative. But they are realistic about what they've been through and have some advice for people considering a move to Italy. First, don't just visit once, they say. Come a few times, at different times of the year, and see what the seasons have to offer. "The summers are very hot and the winters are very cold in the mountains here," says Andrew. "Come with a different head on your shoulders in terms of how and how fast things should be done. Money is not the most important thing here. Relationships are, nature is, enjoying life is."
As for the lives they left behind? As the saying goes, living well is the best revenge.
By Linda Dini Jenkins
MaJella Forever!
On January 18, 2022 | In News
On January 15, 2022 | In Outdoors

redpajama_set_name: RedPajamaCommonCrawl


text:
import {AxiosPromise} from 'axios';
import {Compute, JWT, OAuth2Client, UserRefreshClient} from 'google-auth-library';
import {BodyResponseCallback, createAPIRequest, GlobalOptions, GoogleConfigurable, MethodOptions} from 'googleapis-common';

// tslint:disable: no-any
// tslint:disable: class-name
// tslint:disable: variable-name
// tslint:disable: jsdoc-format
// tslint:disable: no-namespace

export namespace storage_v1beta1 {
  export interface Options extends GlobalOptions {
    version: 'v1beta1';
  }

  /**
   * Cloud Storage JSON API
   *
   * Lets you store and retrieve potentially-large, immutable data objects.
   *
   * @example
   * const {google} = require('googleapis');
   * const storage = google.storage('v1beta1');
   *
   * @namespace storage
   * @type {Function}
   * @version v1beta1
   * @variation v1beta1
   * @param {object=} options Options for Storage
   */
  export class Storage {
    _options: GlobalOptions;
    google?: GoogleConfigurable;
    root = this;

    bucketAccessControls: Resource$Bucketaccesscontrols;
    buckets: Resource$Buckets;
    objectAccessControls: Resource$Objectaccesscontrols;
    objects: Resource$Objects;

    constructor(options: GlobalOptions, google?: GoogleConfigurable) {
      this._options = options || {};
      this.google = google;
      this.getRoot.bind(this);

      this.bucketAccessControls = new Resource$Bucketaccesscontrols(this);
      this.buckets = new Resource$Buckets(this);
      this.objectAccessControls = new Resource$Objectaccesscontrols(this);
      this.objects = new Resource$Objects(this);
    }

    getRoot() {
      return this.root;
    }
  }

  /**
   * A bucket.
   */
  export interface Schema$Bucket {
    /**
     * Access controls on the bucket.
     */
    acl?: Schema$BucketAccessControl[];
    /**
     * Default access controls to apply to new objects when no ACL is provided.
     */
    defaultObjectAcl?: Schema$ObjectAccessControl[];
    /**
     * The name of the bucket.
     */
    id?: string;
    /**
     * The kind of item this is. For buckets, this is always storage#bucket.
     */
    kind?: string;
    /**
     * The location of the bucket. Object data for objects in the bucket resides
     * in physical storage in this location. Can be US or EU. Defaults to US.
     */
    location?: string;
    /**
     * The owner of the bucket. This will always be the project team's owner
     * group.
     */
    owner?: any;
    /**
     * The project the bucket belongs to.
     */
    projectId?: string;
    /**
     * The URI of this bucket.
     */
    selfLink?: string;
    /**
     * Creation time of the bucket in RFC 3339 format.
     */
    timeCreated?: string;
    /**
     * The bucket's website configuration.
     */
    website?: any;
  }
  /**
   * An access-control entry.
   */
  export interface Schema$BucketAccessControl {
    /**
     * The name of the bucket.
     */
    bucket?: string;
    /**
     * The domain associated with the entity, if any.
     */
    domain?: string;
    /**
     * The email address associated with the entity, if any.
     */
    email?: string;
    /**
     * The entity holding the permission, in one of the following forms:  -
     * user-userId  - user-email  - group-groupId  - group-email  -
     * domain-domain  - allUsers  - allAuthenticatedUsers Examples:  - The user
     * liz@example.com would be user-liz@example.com.  - The group
     * example@googlegroups.com would be group-example@googlegroups.com.  - To
     * refer to all members of the Google Apps for Business domain example.com,
     * the entity would be domain-example.com.
     */
    entity?: string;
    /**
     * The ID for the entity, if any.
     */
    entityId?: string;
    /**
     * The ID of the access-control entry.
     */
    id?: string;
    /**
     * The kind of item this is. For bucket access control entries, this is
     * always storage#bucketAccessControl.
     */
    kind?: string;
    /**
     * The access permission for the entity. Can be READER, WRITER, or OWNER.
     */
    role?: string;
    /**
     * The link to this access-control entry.
     */
    selfLink?: string;
  }
  /**
   * An access-control list.
   */
  export interface Schema$BucketAccessControls {
    /**
     * The list of items.
     */
    items?: Schema$BucketAccessControl[];
    /**
     * The kind of item this is. For lists of bucket access control entries,
     * this is always storage#bucketAccessControls.
     */
    kind?: string;
  }
  /**
   * A list of buckets.
   */
  export interface Schema$Buckets {
    /**
     * The list of items.
     */
    items?: Schema$Bucket[];
    /**
     * The kind of item this is. For lists of buckets, this is always
     * storage#buckets.
     */
    kind?: string;
    /**
     * The continuation token, used to page through large result sets. Provide
     * this value in a subsequent request to return the next page of results.
     */
    nextPageToken?: string;
  }
  /**
   * An object.
   */
  export interface Schema$Object {
    /**
     * Access controls on the object.
     */
    acl?: Schema$ObjectAccessControl[];
    /**
     * The bucket containing this object.
     */
    bucket?: string;
    /**
     * Cache-Control directive for the object data.
     */
    cacheControl?: string;
    /**
     * Content-Disposition of the object data.
     */
    contentDisposition?: string;
    /**
     * Content-Encoding of the object data.
     */
    contentEncoding?: string;
    /**
     * Content-Language of the object data.
     */
    contentLanguage?: string;
    /**
     * The ID of the object.
     */
    id?: string;
    /**
     * The kind of item this is. For objects, this is always storage#object.
     */
    kind?: string;
    /**
     * Object media data. Provided on your behalf when uploading raw media or
     * multipart/related with an auxiliary media part.
     */
    media?: any;
    /**
     * User-provided metadata, in key/value pairs.
     */
    metadata?: any;
    /**
     * The name of this object. Required if not specified by URL parameter.
     */
    name?: string;
    /**
     * The owner of the object. This will always be the uploader of the object.
     */
    owner?: any;
    /**
     * The link to this object.
     */
    selfLink?: string;
  }
  /**
   * An access-control entry.
   */
  export interface Schema$ObjectAccessControl {
    /**
     * The name of the bucket.
     */
    bucket?: string;
    /**
     * The domain associated with the entity, if any.
     */
    domain?: string;
    /**
     * The email address associated with the entity, if any.
     */
    email?: string;
    /**
     * The entity holding the permission, in one of the following forms:  -
     * user-userId  - user-email  - group-groupId  - group-email  -
     * domain-domain  - allUsers  - allAuthenticatedUsers Examples:  - The user
     * liz@example.com would be user-liz@example.com.  - The group
     * example@googlegroups.com would be group-example@googlegroups.com.  - To
     * refer to all members of the Google Apps for Business domain example.com,
     * the entity would be domain-example.com.
     */
    entity?: string;
    /**
     * The ID for the entity, if any.
     */
    entityId?: string;
    /**
     * The ID of the access-control entry.
     */
    id?: string;
    /**
     * The kind of item this is. For object access control entries, this is
     * always storage#objectAccessControl.
     */
    kind?: string;
    /**
     * The name of the object.
     */
    object?: string;
    /**
     * The access permission for the entity. Can be READER or OWNER.
     */
    role?: string;
    /**
     * The link to this access-control entry.
     */
    selfLink?: string;
  }
  /**
   * An access-control list.
   */
  export interface Schema$ObjectAccessControls {
    /**
     * The list of items.
     */
    items?: Schema$ObjectAccessControl[];
    /**
     * The kind of item this is. For lists of object access control entries,
     * this is always storage#objectAccessControls.
     */
    kind?: string;
  }
  /**
   * A list of objects.
   */
  export interface Schema$Objects {
    /**
     * The list of items.
     */
    items?: Schema$Object[];
    /**
     * The kind of item this is. For lists of objects, this is always
     * storage#objects.
     */
    kind?: string;
    /**
     * The continuation token, used to page through large result sets. Provide
     * this value in a subsequent request to return the next page of results.
     */
    nextPageToken?: string;
    /**
     * The list of prefixes of objects matching-but-not-listed up to and
     * including the requested delimiter.
     */
    prefixes?: string[];
  }

  export class Resource$Bucketaccesscontrols {
    root: Storage;
    constructor(root: Storage) {
      this.root = root;
      this.getRoot.bind(this);
    }

    getRoot() {
      return this.root;
    }

    /**
     * storage.bucketAccessControls.delete
     * @desc Deletes the ACL entry for the specified entity on the specified
     * bucket.
     * @alias storage.bucketAccessControls.delete
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.bucket Name of a bucket.
     * @param {string} params.entity The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.
     * @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(
        params?: Params$Resource$Bucketaccesscontrols$Delete,
        options?: MethodOptions): AxiosPromise<void>;
    delete(
        params: Params$Resource$Bucketaccesscontrols$Delete,
        options: MethodOptions|BodyResponseCallback<void>,
        callback: BodyResponseCallback<void>): void;
    delete(
        params: Params$Resource$Bucketaccesscontrols$Delete,
        callback: BodyResponseCallback<void>): void;
    delete(callback: BodyResponseCallback<void>): void;
    delete(
        paramsOrCallback?: Params$Resource$Bucketaccesscontrols$Delete|
        BodyResponseCallback<void>,
        optionsOrCallback?: MethodOptions|BodyResponseCallback<void>,
        callback?: BodyResponseCallback<void>): void|AxiosPromise<void> {
      let params = (paramsOrCallback || {}) as
          Params$Resource$Bucketaccesscontrols$Delete;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Bucketaccesscontrols$Delete;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
            {
              url: (rootUrl + '/storage/v1beta1/b/{bucket}/acl/{entity}')
                       .replace(/([^:]\/)\/+/g, '$1'),
              method: 'DELETE'
            },
            options),
        params,
        requiredParams: ['bucket', 'entity'],
        pathParams: ['bucket', 'entity'],
        context: this.getRoot()
      };
      if (callback) {
        createAPIRequest<void>(parameters, callback);
      } else {
        return createAPIRequest<void>(parameters);
      }
    }

    /**
     * storage.bucketAccessControls.get
     * @desc Returns the ACL entry for the specified entity on the specified
     * bucket.
     * @alias storage.bucketAccessControls.get
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.bucket Name of a bucket.
     * @param {string} params.entity The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.
     * @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(params?: Params$Resource$Bucketaccesscontrols$Get,
        options?: MethodOptions): AxiosPromise<Schema$BucketAccessControl>;
    get(params: Params$Resource$Bucketaccesscontrols$Get,
        options: MethodOptions|BodyResponseCallback<Schema$BucketAccessControl>,
        callback: BodyResponseCallback<Schema$BucketAccessControl>): void;
    get(params: Params$Resource$Bucketaccesscontrols$Get,
        callback: BodyResponseCallback<Schema$BucketAccessControl>): void;
    get(callback: BodyResponseCallback<Schema$BucketAccessControl>): void;
    get(paramsOrCallback?: Params$Resource$Bucketaccesscontrols$Get|
        BodyResponseCallback<Schema$BucketAccessControl>,
        optionsOrCallback?: MethodOptions|
        BodyResponseCallback<Schema$BucketAccessControl>,
        callback?: BodyResponseCallback<Schema$BucketAccessControl>):
        void|AxiosPromise<Schema$BucketAccessControl> {
      let params =
          (paramsOrCallback || {}) as Params$Resource$Bucketaccesscontrols$Get;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Bucketaccesscontrols$Get;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
            {
              url: (rootUrl + '/storage/v1beta1/b/{bucket}/acl/{entity}')
                       .replace(/([^:]\/)\/+/g, '$1'),
              method: 'GET'
            },
            options),
        params,
        requiredParams: ['bucket', 'entity'],
        pathParams: ['bucket', 'entity'],
        context: this.getRoot()
      };
      if (callback) {
        createAPIRequest<Schema$BucketAccessControl>(parameters, callback);
      } else {
        return createAPIRequest<Schema$BucketAccessControl>(parameters);
      }
    }

    /**
     * storage.bucketAccessControls.insert
     * @desc Creates a new ACL entry on the specified bucket.
     * @alias storage.bucketAccessControls.insert
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.bucket Name of a bucket.
     * @param {().BucketAccessControl} 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
     */
    insert(
        params?: Params$Resource$Bucketaccesscontrols$Insert,
        options?: MethodOptions): AxiosPromise<Schema$BucketAccessControl>;
    insert(
        params: Params$Resource$Bucketaccesscontrols$Insert,
        options: MethodOptions|BodyResponseCallback<Schema$BucketAccessControl>,
        callback: BodyResponseCallback<Schema$BucketAccessControl>): void;
    insert(
        params: Params$Resource$Bucketaccesscontrols$Insert,
        callback: BodyResponseCallback<Schema$BucketAccessControl>): void;
    insert(callback: BodyResponseCallback<Schema$BucketAccessControl>): void;
    insert(
        paramsOrCallback?: Params$Resource$Bucketaccesscontrols$Insert|
        BodyResponseCallback<Schema$BucketAccessControl>,
        optionsOrCallback?: MethodOptions|
        BodyResponseCallback<Schema$BucketAccessControl>,
        callback?: BodyResponseCallback<Schema$BucketAccessControl>):
        void|AxiosPromise<Schema$BucketAccessControl> {
      let params = (paramsOrCallback || {}) as
          Params$Resource$Bucketaccesscontrols$Insert;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Bucketaccesscontrols$Insert;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
            {
              url: (rootUrl + '/storage/v1beta1/b/{bucket}/acl')
                       .replace(/([^:]\/)\/+/g, '$1'),
              method: 'POST'
            },
            options),
        params,
        requiredParams: ['bucket'],
        pathParams: ['bucket'],
        context: this.getRoot()
      };
      if (callback) {
        createAPIRequest<Schema$BucketAccessControl>(parameters, callback);
      } else {
        return createAPIRequest<Schema$BucketAccessControl>(parameters);
      }
    }

    /**
     * storage.bucketAccessControls.list
     * @desc Retrieves ACL entries on the specified bucket.
     * @alias storage.bucketAccessControls.list
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.bucket Name of a bucket.
     * @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(
        params?: Params$Resource$Bucketaccesscontrols$List,
        options?: MethodOptions): AxiosPromise<Schema$BucketAccessControls>;
    list(
        params: Params$Resource$Bucketaccesscontrols$List,
        options: MethodOptions|
        BodyResponseCallback<Schema$BucketAccessControls>,
        callback: BodyResponseCallback<Schema$BucketAccessControls>): void;
    list(
        params: Params$Resource$Bucketaccesscontrols$List,
        callback: BodyResponseCallback<Schema$BucketAccessControls>): void;
    list(callback: BodyResponseCallback<Schema$BucketAccessControls>): void;
    list(
        paramsOrCallback?: Params$Resource$Bucketaccesscontrols$List|
        BodyResponseCallback<Schema$BucketAccessControls>,
        optionsOrCallback?: MethodOptions|
        BodyResponseCallback<Schema$BucketAccessControls>,
        callback?: BodyResponseCallback<Schema$BucketAccessControls>):
        void|AxiosPromise<Schema$BucketAccessControls> {
      let params =
          (paramsOrCallback || {}) as Params$Resource$Bucketaccesscontrols$List;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Bucketaccesscontrols$List;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
            {
              url: (rootUrl + '/storage/v1beta1/b/{bucket}/acl')
                       .replace(/([^:]\/)\/+/g, '$1'),
              method: 'GET'
            },
            options),
        params,
        requiredParams: ['bucket'],
        pathParams: ['bucket'],
        context: this.getRoot()
      };
      if (callback) {
        createAPIRequest<Schema$BucketAccessControls>(parameters, callback);
      } else {
        return createAPIRequest<Schema$BucketAccessControls>(parameters);
      }
    }

    /**
     * storage.bucketAccessControls.patch
     * @desc Updates an ACL entry on the specified bucket. This method supports
     * patch semantics.
     * @alias storage.bucketAccessControls.patch
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.bucket Name of a bucket.
     * @param {string} params.entity The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.
     * @param {().BucketAccessControl} 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(
        params?: Params$Resource$Bucketaccesscontrols$Patch,
        options?: MethodOptions): AxiosPromise<Schema$BucketAccessControl>;
    patch(
        params: Params$Resource$Bucketaccesscontrols$Patch,
        options: MethodOptions|BodyResponseCallback<Schema$BucketAccessControl>,
        callback: BodyResponseCallback<Schema$BucketAccessControl>): void;
    patch(
        params: Params$Resource$Bucketaccesscontrols$Patch,
        callback: BodyResponseCallback<Schema$BucketAccessControl>): void;
    patch(callback: BodyResponseCallback<Schema$BucketAccessControl>): void;
    patch(
        paramsOrCallback?: Params$Resource$Bucketaccesscontrols$Patch|
        BodyResponseCallback<Schema$BucketAccessControl>,
        optionsOrCallback?: MethodOptions|
        BodyResponseCallback<Schema$BucketAccessControl>,
        callback?: BodyResponseCallback<Schema$BucketAccessControl>):
        void|AxiosPromise<Schema$BucketAccessControl> {
      let params = (paramsOrCallback || {}) as
          Params$Resource$Bucketaccesscontrols$Patch;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Bucketaccesscontrols$Patch;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
            {
              url: (rootUrl + '/storage/v1beta1/b/{bucket}/acl/{entity}')
                       .replace(/([^:]\/)\/+/g, '$1'),
              method: 'PATCH'
            },
            options),
        params,
        requiredParams: ['bucket', 'entity'],
        pathParams: ['bucket', 'entity'],
        context: this.getRoot()
      };
      if (callback) {
        createAPIRequest<Schema$BucketAccessControl>(parameters, callback);
      } else {
        return createAPIRequest<Schema$BucketAccessControl>(parameters);
      }
    }

    /**
     * storage.bucketAccessControls.update
     * @desc Updates an ACL entry on the specified bucket.
     * @alias storage.bucketAccessControls.update
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.bucket Name of a bucket.
     * @param {string} params.entity The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.
     * @param {().BucketAccessControl} 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(
        params?: Params$Resource$Bucketaccesscontrols$Update,
        options?: MethodOptions): AxiosPromise<Schema$BucketAccessControl>;
    update(
        params: Params$Resource$Bucketaccesscontrols$Update,
        options: MethodOptions|BodyResponseCallback<Schema$BucketAccessControl>,
        callback: BodyResponseCallback<Schema$BucketAccessControl>): void;
    update(
        params: Params$Resource$Bucketaccesscontrols$Update,
        callback: BodyResponseCallback<Schema$BucketAccessControl>): void;
    update(callback: BodyResponseCallback<Schema$BucketAccessControl>): void;
    update(
        paramsOrCallback?: Params$Resource$Bucketaccesscontrols$Update|
        BodyResponseCallback<Schema$BucketAccessControl>,
        optionsOrCallback?: MethodOptions|
        BodyResponseCallback<Schema$BucketAccessControl>,
        callback?: BodyResponseCallback<Schema$BucketAccessControl>):
        void|AxiosPromise<Schema$BucketAccessControl> {
      let params = (paramsOrCallback || {}) as
          Params$Resource$Bucketaccesscontrols$Update;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Bucketaccesscontrols$Update;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
            {
              url: (rootUrl + '/storage/v1beta1/b/{bucket}/acl/{entity}')
                       .replace(/([^:]\/)\/+/g, '$1'),
              method: 'PUT'
            },
            options),
        params,
        requiredParams: ['bucket', 'entity'],
        pathParams: ['bucket', 'entity'],
        context: this.getRoot()
      };
      if (callback) {
        createAPIRequest<Schema$BucketAccessControl>(parameters, callback);
      } else {
        return createAPIRequest<Schema$BucketAccessControl>(parameters);
      }
    }
  }

  export interface Params$Resource$Bucketaccesscontrols$Delete {
    /**
     * Auth client or API Key for the request
     */
    auth?: string|OAuth2Client|JWT|Compute|UserRefreshClient;

    /**
     * Name of a bucket.
     */
    bucket?: string;
    /**
     * The entity holding the permission. Can be user-userId, user-emailAddress,
     * group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.
     */
    entity?: string;
  }
  export interface Params$Resource$Bucketaccesscontrols$Get {
    /**
     * Auth client or API Key for the request
     */
    auth?: string|OAuth2Client|JWT|Compute|UserRefreshClient;

    /**
     * Name of a bucket.
     */
    bucket?: string;
    /**
     * The entity holding the permission. Can be user-userId, user-emailAddress,
     * group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.
     */
    entity?: string;
  }
  export interface Params$Resource$Bucketaccesscontrols$Insert {
    /**
     * Auth client or API Key for the request
     */
    auth?: string|OAuth2Client|JWT|Compute|UserRefreshClient;

    /**
     * Name of a bucket.
     */
    bucket?: string;

    /**
     * Request body metadata
     */
    requestBody?: Schema$BucketAccessControl;
  }
  export interface Params$Resource$Bucketaccesscontrols$List {
    /**
     * Auth client or API Key for the request
     */
    auth?: string|OAuth2Client|JWT|Compute|UserRefreshClient;

    /**
     * Name of a bucket.
     */
    bucket?: string;
  }
  export interface Params$Resource$Bucketaccesscontrols$Patch {
    /**
     * Auth client or API Key for the request
     */
    auth?: string|OAuth2Client|JWT|Compute|UserRefreshClient;

    /**
     * Name of a bucket.
     */
    bucket?: string;
    /**
     * The entity holding the permission. Can be user-userId, user-emailAddress,
     * group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.
     */
    entity?: string;

    /**
     * Request body metadata
     */
    requestBody?: Schema$BucketAccessControl;
  }
  export interface Params$Resource$Bucketaccesscontrols$Update {
    /**
     * Auth client or API Key for the request
     */
    auth?: string|OAuth2Client|JWT|Compute|UserRefreshClient;

    /**
     * Name of a bucket.
     */
    bucket?: string;
    /**
     * The entity holding the permission. Can be user-userId, user-emailAddress,
     * group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.
     */
    entity?: string;

    /**
     * Request body metadata
     */
    requestBody?: Schema$BucketAccessControl;
  }

  export class Resource$Buckets {
    root: Storage;
    constructor(root: Storage) {
      this.root = root;
      this.getRoot.bind(this);
    }

    getRoot() {
      return this.root;
    }

    /**
     * storage.buckets.delete
     * @desc Deletes an empty bucket.
     * @alias storage.buckets.delete
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.bucket Name of a bucket.
     * @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(params?: Params$Resource$Buckets$Delete, options?: MethodOptions):
        AxiosPromise<void>;
    delete(
        params: Params$Resource$Buckets$Delete,
        options: MethodOptions|BodyResponseCallback<void>,
        callback: BodyResponseCallback<void>): void;
    delete(
        params: Params$Resource$Buckets$Delete,
        callback: BodyResponseCallback<void>): void;
    delete(callback: BodyResponseCallback<void>): void;
    delete(
        paramsOrCallback?: Params$Resource$Buckets$Delete|
        BodyResponseCallback<void>,
        optionsOrCallback?: MethodOptions|BodyResponseCallback<void>,
        callback?: BodyResponseCallback<void>): void|AxiosPromise<void> {
      let params = (paramsOrCallback || {}) as Params$Resource$Buckets$Delete;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Buckets$Delete;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
            {
              url: (rootUrl + '/storage/v1beta1/b/{bucket}')
                       .replace(/([^:]\/)\/+/g, '$1'),
              method: 'DELETE'
            },
            options),
        params,
        requiredParams: ['bucket'],
        pathParams: ['bucket'],
        context: this.getRoot()
      };
      if (callback) {
        createAPIRequest<void>(parameters, callback);
      } else {
        return createAPIRequest<void>(parameters);
      }
    }

    /**
     * storage.buckets.get
     * @desc Returns metadata for the specified bucket.
     * @alias storage.buckets.get
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.bucket Name of a bucket.
     * @param {string=} params.projection Set of properties to return. Defaults to no_acl.
     * @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(params?: Params$Resource$Buckets$Get,
        options?: MethodOptions): AxiosPromise<Schema$Bucket>;
    get(params: Params$Resource$Buckets$Get,
        options: MethodOptions|BodyResponseCallback<Schema$Bucket>,
        callback: BodyResponseCallback<Schema$Bucket>): void;
    get(params: Params$Resource$Buckets$Get,
        callback: BodyResponseCallback<Schema$Bucket>): void;
    get(callback: BodyResponseCallback<Schema$Bucket>): void;
    get(paramsOrCallback?: Params$Resource$Buckets$Get|
        BodyResponseCallback<Schema$Bucket>,
        optionsOrCallback?: MethodOptions|BodyResponseCallback<Schema$Bucket>,
        callback?: BodyResponseCallback<Schema$Bucket>):
        void|AxiosPromise<Schema$Bucket> {
      let params = (paramsOrCallback || {}) as Params$Resource$Buckets$Get;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Buckets$Get;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
            {
              url: (rootUrl + '/storage/v1beta1/b/{bucket}')
                       .replace(/([^:]\/)\/+/g, '$1'),
              method: 'GET'
            },
            options),
        params,
        requiredParams: ['bucket'],
        pathParams: ['bucket'],
        context: this.getRoot()
      };
      if (callback) {
        createAPIRequest<Schema$Bucket>(parameters, callback);
      } else {
        return createAPIRequest<Schema$Bucket>(parameters);
      }
    }

    /**
     * storage.buckets.insert
     * @desc Creates a new bucket.
     * @alias storage.buckets.insert
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string=} params.projection Set of properties to return. Defaults to no_acl, unless the bucket resource specifies acl or defaultObjectAcl properties, when it defaults to full.
     * @param {().Bucket} 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
     */
    insert(params?: Params$Resource$Buckets$Insert, options?: MethodOptions):
        AxiosPromise<Schema$Bucket>;
    insert(
        params: Params$Resource$Buckets$Insert,
        options: MethodOptions|BodyResponseCallback<Schema$Bucket>,
        callback: BodyResponseCallback<Schema$Bucket>): void;
    insert(
        params: Params$Resource$Buckets$Insert,
        callback: BodyResponseCallback<Schema$Bucket>): void;
    insert(callback: BodyResponseCallback<Schema$Bucket>): void;
    insert(
        paramsOrCallback?: Params$Resource$Buckets$Insert|
        BodyResponseCallback<Schema$Bucket>,
        optionsOrCallback?: MethodOptions|BodyResponseCallback<Schema$Bucket>,
        callback?: BodyResponseCallback<Schema$Bucket>):
        void|AxiosPromise<Schema$Bucket> {
      let params = (paramsOrCallback || {}) as Params$Resource$Buckets$Insert;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Buckets$Insert;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
            {
              url: (rootUrl + '/storage/v1beta1/b')
                       .replace(/([^:]\/)\/+/g, '$1'),
              method: 'POST'
            },
            options),
        params,
        requiredParams: [],
        pathParams: [],
        context: this.getRoot()
      };
      if (callback) {
        createAPIRequest<Schema$Bucket>(parameters, callback);
      } else {
        return createAPIRequest<Schema$Bucket>(parameters);
      }
    }

    /**
     * storage.buckets.list
     * @desc Retrieves a list of buckets for a given project.
     * @alias storage.buckets.list
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {integer=} params.max-results Maximum number of buckets to return.
     * @param {string=} params.pageToken A previously-returned page token representing part of the larger set of results to view.
     * @param {string} params.projectId A valid API project identifier.
     * @param {string=} params.projection Set of properties to return. Defaults to no_acl.
     * @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(params?: Params$Resource$Buckets$List, options?: MethodOptions):
        AxiosPromise<Schema$Buckets>;
    list(
        params: Params$Resource$Buckets$List,
        options: MethodOptions|BodyResponseCallback<Schema$Buckets>,
        callback: BodyResponseCallback<Schema$Buckets>): void;
    list(
        params: Params$Resource$Buckets$List,
        callback: BodyResponseCallback<Schema$Buckets>): void;
    list(callback: BodyResponseCallback<Schema$Buckets>): void;
    list(
        paramsOrCallback?: Params$Resource$Buckets$List|
        BodyResponseCallback<Schema$Buckets>,
        optionsOrCallback?: MethodOptions|BodyResponseCallback<Schema$Buckets>,
        callback?: BodyResponseCallback<Schema$Buckets>):
        void|AxiosPromise<Schema$Buckets> {
      let params = (paramsOrCallback || {}) as Params$Resource$Buckets$List;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Buckets$List;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
            {
              url: (rootUrl + '/storage/v1beta1/b')
                       .replace(/([^:]\/)\/+/g, '$1'),
              method: 'GET'
            },
            options),
        params,
        requiredParams: ['projectId'],
        pathParams: [],
        context: this.getRoot()
      };
      if (callback) {
        createAPIRequest<Schema$Buckets>(parameters, callback);
      } else {
        return createAPIRequest<Schema$Buckets>(parameters);
      }
    }

    /**
     * storage.buckets.patch
     * @desc Updates a bucket. This method supports patch semantics.
     * @alias storage.buckets.patch
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.bucket Name of a bucket.
     * @param {string=} params.projection Set of properties to return. Defaults to full.
     * @param {().Bucket} 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(params?: Params$Resource$Buckets$Patch, options?: MethodOptions):
        AxiosPromise<Schema$Bucket>;
    patch(
        params: Params$Resource$Buckets$Patch,
        options: MethodOptions|BodyResponseCallback<Schema$Bucket>,
        callback: BodyResponseCallback<Schema$Bucket>): void;
    patch(
        params: Params$Resource$Buckets$Patch,
        callback: BodyResponseCallback<Schema$Bucket>): void;
    patch(callback: BodyResponseCallback<Schema$Bucket>): void;
    patch(
        paramsOrCallback?: Params$Resource$Buckets$Patch|
        BodyResponseCallback<Schema$Bucket>,
        optionsOrCallback?: MethodOptions|BodyResponseCallback<Schema$Bucket>,
        callback?: BodyResponseCallback<Schema$Bucket>):
        void|AxiosPromise<Schema$Bucket> {
      let params = (paramsOrCallback || {}) as Params$Resource$Buckets$Patch;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Buckets$Patch;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
            {
              url: (rootUrl + '/storage/v1beta1/b/{bucket}')
                       .replace(/([^:]\/)\/+/g, '$1'),
              method: 'PATCH'
            },
            options),
        params,
        requiredParams: ['bucket'],
        pathParams: ['bucket'],
        context: this.getRoot()
      };
      if (callback) {
        createAPIRequest<Schema$Bucket>(parameters, callback);
      } else {
        return createAPIRequest<Schema$Bucket>(parameters);
      }
    }

    /**
     * storage.buckets.update
     * @desc Updates a bucket.
     * @alias storage.buckets.update
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.bucket Name of a bucket.
     * @param {string=} params.projection Set of properties to return. Defaults to full.
     * @param {().Bucket} 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(params?: Params$Resource$Buckets$Update, options?: MethodOptions):
        AxiosPromise<Schema$Bucket>;
    update(
        params: Params$Resource$Buckets$Update,
        options: MethodOptions|BodyResponseCallback<Schema$Bucket>,
        callback: BodyResponseCallback<Schema$Bucket>): void;
    update(
        params: Params$Resource$Buckets$Update,
        callback: BodyResponseCallback<Schema$Bucket>): void;
    update(callback: BodyResponseCallback<Schema$Bucket>): void;
    update(
        paramsOrCallback?: Params$Resource$Buckets$Update|
        BodyResponseCallback<Schema$Bucket>,
        optionsOrCallback?: MethodOptions|BodyResponseCallback<Schema$Bucket>,
        callback?: BodyResponseCallback<Schema$Bucket>):
        void|AxiosPromise<Schema$Bucket> {
      let params = (paramsOrCallback || {}) as Params$Resource$Buckets$Update;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Buckets$Update;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
            {
              url: (rootUrl + '/storage/v1beta1/b/{bucket}')
                       .replace(/([^:]\/)\/+/g, '$1'),
              method: 'PUT'
            },
            options),
        params,
        requiredParams: ['bucket'],
        pathParams: ['bucket'],
        context: this.getRoot()
      };
      if (callback) {
        createAPIRequest<Schema$Bucket>(parameters, callback);
      } else {
        return createAPIRequest<Schema$Bucket>(parameters);
      }
    }
  }

  export interface Params$Resource$Buckets$Delete {
    /**
     * Auth client or API Key for the request
     */
    auth?: string|OAuth2Client|JWT|Compute|UserRefreshClient;

    /**
     * Name of a bucket.
     */
    bucket?: string;
  }
  export interface Params$Resource$Buckets$Get {
    /**
     * Auth client or API Key for the request
     */
    auth?: string|OAuth2Client|JWT|Compute|UserRefreshClient;

    /**
     * Name of a bucket.
     */
    bucket?: string;
    /**
     * Set of properties to return. Defaults to no_acl.
     */
    projection?: string;
  }
  export interface Params$Resource$Buckets$Insert {
    /**
     * Auth client or API Key for the request
     */
    auth?: string|OAuth2Client|JWT|Compute|UserRefreshClient;

    /**
     * Set of properties to return. Defaults to no_acl, unless the bucket
     * resource specifies acl or defaultObjectAcl properties, when it defaults
     * to full.
     */
    projection?: string;

    /**
     * Request body metadata
     */
    requestBody?: Schema$Bucket;
  }
  export interface Params$Resource$Buckets$List {
    /**
     * Auth client or API Key for the request
     */
    auth?: string|OAuth2Client|JWT|Compute|UserRefreshClient;

    /**
     * Maximum number of buckets to return.
     */
    'max-results'?: number;
    /**
     * A previously-returned page token representing part of the larger set of
     * results to view.
     */
    pageToken?: string;
    /**
     * A valid API project identifier.
     */
    projectId?: string;
    /**
     * Set of properties to return. Defaults to no_acl.
     */
    projection?: string;
  }
  export interface Params$Resource$Buckets$Patch {
    /**
     * Auth client or API Key for the request
     */
    auth?: string|OAuth2Client|JWT|Compute|UserRefreshClient;

    /**
     * Name of a bucket.
     */
    bucket?: string;
    /**
     * Set of properties to return. Defaults to full.
     */
    projection?: string;

    /**
     * Request body metadata
     */
    requestBody?: Schema$Bucket;
  }
  export interface Params$Resource$Buckets$Update {
    /**
     * Auth client or API Key for the request
     */
    auth?: string|OAuth2Client|JWT|Compute|UserRefreshClient;

    /**
     * Name of a bucket.
     */
    bucket?: string;
    /**
     * Set of properties to return. Defaults to full.
     */
    projection?: string;

    /**
     * Request body metadata
     */
    requestBody?: Schema$Bucket;
  }

  export class Resource$Objectaccesscontrols {
    root: Storage;
    constructor(root: Storage) {
      this.root = root;
      this.getRoot.bind(this);
    }

    getRoot() {
      return this.root;
    }

    /**
     * storage.objectAccessControls.delete
     * @desc Deletes the ACL entry for the specified entity on the specified
     * object.
     * @alias storage.objectAccessControls.delete
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.bucket Name of a bucket.
     * @param {string} params.entity The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.
     * @param {string} params.object Name of the object.
     * @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(
        params?: Params$Resource$Objectaccesscontrols$Delete,
        options?: MethodOptions): AxiosPromise<void>;
    delete(
        params: Params$Resource$Objectaccesscontrols$Delete,
        options: MethodOptions|BodyResponseCallback<void>,
        callback: BodyResponseCallback<void>): void;
    delete(
        params: Params$Resource$Objectaccesscontrols$Delete,
        callback: BodyResponseCallback<void>): void;
    delete(callback: BodyResponseCallback<void>): void;
    delete(
        paramsOrCallback?: Params$Resource$Objectaccesscontrols$Delete|
        BodyResponseCallback<void>,
        optionsOrCallback?: MethodOptions|BodyResponseCallback<void>,
        callback?: BodyResponseCallback<void>): void|AxiosPromise<void> {
      let params = (paramsOrCallback || {}) as
          Params$Resource$Objectaccesscontrols$Delete;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Objectaccesscontrols$Delete;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
            {
              url: (rootUrl +
                    '/storage/v1beta1/b/{bucket}/o/{object}/acl/{entity}')
                       .replace(/([^:]\/)\/+/g, '$1'),
              method: 'DELETE'
            },
            options),
        params,
        requiredParams: ['bucket', 'object', 'entity'],
        pathParams: ['bucket', 'entity', 'object'],
        context: this.getRoot()
      };
      if (callback) {
        createAPIRequest<void>(parameters, callback);
      } else {
        return createAPIRequest<void>(parameters);
      }
    }

    /**
     * storage.objectAccessControls.get
     * @desc Returns the ACL entry for the specified entity on the specified
     * object.
     * @alias storage.objectAccessControls.get
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.bucket Name of a bucket.
     * @param {string} params.entity The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.
     * @param {string} params.object Name of the object.
     * @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(params?: Params$Resource$Objectaccesscontrols$Get,
        options?: MethodOptions): AxiosPromise<Schema$ObjectAccessControl>;
    get(params: Params$Resource$Objectaccesscontrols$Get,
        options: MethodOptions|BodyResponseCallback<Schema$ObjectAccessControl>,
        callback: BodyResponseCallback<Schema$ObjectAccessControl>): void;
    get(params: Params$Resource$Objectaccesscontrols$Get,
        callback: BodyResponseCallback<Schema$ObjectAccessControl>): void;
    get(callback: BodyResponseCallback<Schema$ObjectAccessControl>): void;
    get(paramsOrCallback?: Params$Resource$Objectaccesscontrols$Get|
        BodyResponseCallback<Schema$ObjectAccessControl>,
        optionsOrCallback?: MethodOptions|
        BodyResponseCallback<Schema$ObjectAccessControl>,
        callback?: BodyResponseCallback<Schema$ObjectAccessControl>):
        void|AxiosPromise<Schema$ObjectAccessControl> {
      let params =
          (paramsOrCallback || {}) as Params$Resource$Objectaccesscontrols$Get;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Objectaccesscontrols$Get;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
            {
              url: (rootUrl +
                    '/storage/v1beta1/b/{bucket}/o/{object}/acl/{entity}')
                       .replace(/([^:]\/)\/+/g, '$1'),
              method: 'GET'
            },
            options),
        params,
        requiredParams: ['bucket', 'object', 'entity'],
        pathParams: ['bucket', 'entity', 'object'],
        context: this.getRoot()
      };
      if (callback) {
        createAPIRequest<Schema$ObjectAccessControl>(parameters, callback);
      } else {
        return createAPIRequest<Schema$ObjectAccessControl>(parameters);
      }
    }

    /**
     * storage.objectAccessControls.insert
     * @desc Creates a new ACL entry on the specified object.
     * @alias storage.objectAccessControls.insert
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.bucket Name of a bucket.
     * @param {string} params.object Name of the object.
     * @param {().ObjectAccessControl} 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
     */
    insert(
        params?: Params$Resource$Objectaccesscontrols$Insert,
        options?: MethodOptions): AxiosPromise<Schema$ObjectAccessControl>;
    insert(
        params: Params$Resource$Objectaccesscontrols$Insert,
        options: MethodOptions|BodyResponseCallback<Schema$ObjectAccessControl>,
        callback: BodyResponseCallback<Schema$ObjectAccessControl>): void;
    insert(
        params: Params$Resource$Objectaccesscontrols$Insert,
        callback: BodyResponseCallback<Schema$ObjectAccessControl>): void;
    insert(callback: BodyResponseCallback<Schema$ObjectAccessControl>): void;
    insert(
        paramsOrCallback?: Params$Resource$Objectaccesscontrols$Insert|
        BodyResponseCallback<Schema$ObjectAccessControl>,
        optionsOrCallback?: MethodOptions|
        BodyResponseCallback<Schema$ObjectAccessControl>,
        callback?: BodyResponseCallback<Schema$ObjectAccessControl>):
        void|AxiosPromise<Schema$ObjectAccessControl> {
      let params = (paramsOrCallback || {}) as
          Params$Resource$Objectaccesscontrols$Insert;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Objectaccesscontrols$Insert;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
            {
              url: (rootUrl + '/storage/v1beta1/b/{bucket}/o/{object}/acl')
                       .replace(/([^:]\/)\/+/g, '$1'),
              method: 'POST'
            },
            options),
        params,
        requiredParams: ['bucket', 'object'],
        pathParams: ['bucket', 'object'],
        context: this.getRoot()
      };
      if (callback) {
        createAPIRequest<Schema$ObjectAccessControl>(parameters, callback);
      } else {
        return createAPIRequest<Schema$ObjectAccessControl>(parameters);
      }
    }

    /**
     * storage.objectAccessControls.list
     * @desc Retrieves ACL entries on the specified object.
     * @alias storage.objectAccessControls.list
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.bucket Name of a bucket.
     * @param {string} params.object Name of the object.
     * @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(
        params?: Params$Resource$Objectaccesscontrols$List,
        options?: MethodOptions): AxiosPromise<Schema$ObjectAccessControls>;
    list(
        params: Params$Resource$Objectaccesscontrols$List,
        options: MethodOptions|
        BodyResponseCallback<Schema$ObjectAccessControls>,
        callback: BodyResponseCallback<Schema$ObjectAccessControls>): void;
    list(
        params: Params$Resource$Objectaccesscontrols$List,
        callback: BodyResponseCallback<Schema$ObjectAccessControls>): void;
    list(callback: BodyResponseCallback<Schema$ObjectAccessControls>): void;
    list(
        paramsOrCallback?: Params$Resource$Objectaccesscontrols$List|
        BodyResponseCallback<Schema$ObjectAccessControls>,
        optionsOrCallback?: MethodOptions|
        BodyResponseCallback<Schema$ObjectAccessControls>,
        callback?: BodyResponseCallback<Schema$ObjectAccessControls>):
        void|AxiosPromise<Schema$ObjectAccessControls> {
      let params =
          (paramsOrCallback || {}) as Params$Resource$Objectaccesscontrols$List;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Objectaccesscontrols$List;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
            {
              url: (rootUrl + '/storage/v1beta1/b/{bucket}/o/{object}/acl')
                       .replace(/([^:]\/)\/+/g, '$1'),
              method: 'GET'
            },
            options),
        params,
        requiredParams: ['bucket', 'object'],
        pathParams: ['bucket', 'object'],
        context: this.getRoot()
      };
      if (callback) {
        createAPIRequest<Schema$ObjectAccessControls>(parameters, callback);
      } else {
        return createAPIRequest<Schema$ObjectAccessControls>(parameters);
      }
    }

    /**
     * storage.objectAccessControls.patch
     * @desc Updates an ACL entry on the specified object. This method supports
     * patch semantics.
     * @alias storage.objectAccessControls.patch
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.bucket Name of a bucket.
     * @param {string} params.entity The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.
     * @param {string} params.object Name of the object.
     * @param {().ObjectAccessControl} 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(
        params?: Params$Resource$Objectaccesscontrols$Patch,
        options?: MethodOptions): AxiosPromise<Schema$ObjectAccessControl>;
    patch(
        params: Params$Resource$Objectaccesscontrols$Patch,
        options: MethodOptions|BodyResponseCallback<Schema$ObjectAccessControl>,
        callback: BodyResponseCallback<Schema$ObjectAccessControl>): void;
    patch(
        params: Params$Resource$Objectaccesscontrols$Patch,
        callback: BodyResponseCallback<Schema$ObjectAccessControl>): void;
    patch(callback: BodyResponseCallback<Schema$ObjectAccessControl>): void;
    patch(
        paramsOrCallback?: Params$Resource$Objectaccesscontrols$Patch|
        BodyResponseCallback<Schema$ObjectAccessControl>,
        optionsOrCallback?: MethodOptions|
        BodyResponseCallback<Schema$ObjectAccessControl>,
        callback?: BodyResponseCallback<Schema$ObjectAccessControl>):
        void|AxiosPromise<Schema$ObjectAccessControl> {
      let params = (paramsOrCallback || {}) as
          Params$Resource$Objectaccesscontrols$Patch;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Objectaccesscontrols$Patch;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
            {
              url: (rootUrl +
                    '/storage/v1beta1/b/{bucket}/o/{object}/acl/{entity}')
                       .replace(/([^:]\/)\/+/g, '$1'),
              method: 'PATCH'
            },
            options),
        params,
        requiredParams: ['bucket', 'object', 'entity'],
        pathParams: ['bucket', 'entity', 'object'],
        context: this.getRoot()
      };
      if (callback) {
        createAPIRequest<Schema$ObjectAccessControl>(parameters, callback);
      } else {
        return createAPIRequest<Schema$ObjectAccessControl>(parameters);
      }
    }

    /**
     * storage.objectAccessControls.update
     * @desc Updates an ACL entry on the specified object.
     * @alias storage.objectAccessControls.update
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.bucket Name of a bucket.
     * @param {string} params.entity The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.
     * @param {string} params.object Name of the object.
     * @param {().ObjectAccessControl} 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(
        params?: Params$Resource$Objectaccesscontrols$Update,
        options?: MethodOptions): AxiosPromise<Schema$ObjectAccessControl>;
    update(
        params: Params$Resource$Objectaccesscontrols$Update,
        options: MethodOptions|BodyResponseCallback<Schema$ObjectAccessControl>,
        callback: BodyResponseCallback<Schema$ObjectAccessControl>): void;
    update(
        params: Params$Resource$Objectaccesscontrols$Update,
        callback: BodyResponseCallback<Schema$ObjectAccessControl>): void;
    update(callback: BodyResponseCallback<Schema$ObjectAccessControl>): void;
    update(
        paramsOrCallback?: Params$Resource$Objectaccesscontrols$Update|
        BodyResponseCallback<Schema$ObjectAccessControl>,
        optionsOrCallback?: MethodOptions|
        BodyResponseCallback<Schema$ObjectAccessControl>,
        callback?: BodyResponseCallback<Schema$ObjectAccessControl>):
        void|AxiosPromise<Schema$ObjectAccessControl> {
      let params = (paramsOrCallback || {}) as
          Params$Resource$Objectaccesscontrols$Update;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Objectaccesscontrols$Update;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
            {
              url: (rootUrl +
                    '/storage/v1beta1/b/{bucket}/o/{object}/acl/{entity}')
                       .replace(/([^:]\/)\/+/g, '$1'),
              method: 'PUT'
            },
            options),
        params,
        requiredParams: ['bucket', 'object', 'entity'],
        pathParams: ['bucket', 'entity', 'object'],
        context: this.getRoot()
      };
      if (callback) {
        createAPIRequest<Schema$ObjectAccessControl>(parameters, callback);
      } else {
        return createAPIRequest<Schema$ObjectAccessControl>(parameters);
      }
    }
  }

  export interface Params$Resource$Objectaccesscontrols$Delete {
    /**
     * Auth client or API Key for the request
     */
    auth?: string|OAuth2Client|JWT|Compute|UserRefreshClient;

    /**
     * Name of a bucket.
     */
    bucket?: string;
    /**
     * The entity holding the permission. Can be user-userId, user-emailAddress,
     * group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.
     */
    entity?: string;
    /**
     * Name of the object.
     */
    object?: string;
  }
  export interface Params$Resource$Objectaccesscontrols$Get {
    /**
     * Auth client or API Key for the request
     */
    auth?: string|OAuth2Client|JWT|Compute|UserRefreshClient;

    /**
     * Name of a bucket.
     */
    bucket?: string;
    /**
     * The entity holding the permission. Can be user-userId, user-emailAddress,
     * group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.
     */
    entity?: string;
    /**
     * Name of the object.
     */
    object?: string;
  }
  export interface Params$Resource$Objectaccesscontrols$Insert {
    /**
     * Auth client or API Key for the request
     */
    auth?: string|OAuth2Client|JWT|Compute|UserRefreshClient;

    /**
     * Name of a bucket.
     */
    bucket?: string;
    /**
     * Name of the object.
     */
    object?: string;

    /**
     * Request body metadata
     */
    requestBody?: Schema$ObjectAccessControl;
  }
  export interface Params$Resource$Objectaccesscontrols$List {
    /**
     * Auth client or API Key for the request
     */
    auth?: string|OAuth2Client|JWT|Compute|UserRefreshClient;

    /**
     * Name of a bucket.
     */
    bucket?: string;
    /**
     * Name of the object.
     */
    object?: string;
  }
  export interface Params$Resource$Objectaccesscontrols$Patch {
    /**
     * Auth client or API Key for the request
     */
    auth?: string|OAuth2Client|JWT|Compute|UserRefreshClient;

    /**
     * Name of a bucket.
     */
    bucket?: string;
    /**
     * The entity holding the permission. Can be user-userId, user-emailAddress,
     * group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.
     */
    entity?: string;
    /**
     * Name of the object.
     */
    object?: string;

    /**
     * Request body metadata
     */
    requestBody?: Schema$ObjectAccessControl;
  }
  export interface Params$Resource$Objectaccesscontrols$Update {
    /**
     * Auth client or API Key for the request
     */
    auth?: string|OAuth2Client|JWT|Compute|UserRefreshClient;

    /**
     * Name of a bucket.
     */
    bucket?: string;
    /**
     * The entity holding the permission. Can be user-userId, user-emailAddress,
     * group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.
     */
    entity?: string;
    /**
     * Name of the object.
     */
    object?: string;

    /**
     * Request body metadata
     */
    requestBody?: Schema$ObjectAccessControl;
  }

  export class Resource$Objects {
    root: Storage;
    constructor(root: Storage) {
      this.root = root;
      this.getRoot.bind(this);
    }

    getRoot() {
      return this.root;
    }

    /**
     * storage.objects.delete
     * @desc Deletes data blobs and associated metadata.
     * @alias storage.objects.delete
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.bucket Name of the bucket in which the object resides.
     * @param {string} params.object Name of the object.
     * @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(params?: Params$Resource$Objects$Delete, options?: MethodOptions):
        AxiosPromise<void>;
    delete(
        params: Params$Resource$Objects$Delete,
        options: MethodOptions|BodyResponseCallback<void>,
        callback: BodyResponseCallback<void>): void;
    delete(
        params: Params$Resource$Objects$Delete,
        callback: BodyResponseCallback<void>): void;
    delete(callback: BodyResponseCallback<void>): void;
    delete(
        paramsOrCallback?: Params$Resource$Objects$Delete|
        BodyResponseCallback<void>,
        optionsOrCallback?: MethodOptions|BodyResponseCallback<void>,
        callback?: BodyResponseCallback<void>): void|AxiosPromise<void> {
      let params = (paramsOrCallback || {}) as Params$Resource$Objects$Delete;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Objects$Delete;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
            {
              url: (rootUrl + '/storage/v1beta1/b/{bucket}/o/{object}')
                       .replace(/([^:]\/)\/+/g, '$1'),
              method: 'DELETE'
            },
            options),
        params,
        requiredParams: ['bucket', 'object'],
        pathParams: ['bucket', 'object'],
        context: this.getRoot()
      };
      if (callback) {
        createAPIRequest<void>(parameters, callback);
      } else {
        return createAPIRequest<void>(parameters);
      }
    }

    /**
     * storage.objects.get
     * @desc Retrieves objects or their associated metadata.
     * @alias storage.objects.get
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.bucket Name of the bucket in which the object resides.
     * @param {string} params.object Name of the object.
     * @param {string=} params.projection Set of properties to return. Defaults to no_acl.
     * @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(params?: Params$Resource$Objects$Get,
        options?: MethodOptions): AxiosPromise<Schema$Object>;
    get(params: Params$Resource$Objects$Get,
        options: MethodOptions|BodyResponseCallback<Schema$Object>,
        callback: BodyResponseCallback<Schema$Object>): void;
    get(params: Params$Resource$Objects$Get,
        callback: BodyResponseCallback<Schema$Object>): void;
    get(callback: BodyResponseCallback<Schema$Object>): void;
    get(paramsOrCallback?: Params$Resource$Objects$Get|
        BodyResponseCallback<Schema$Object>,
        optionsOrCallback?: MethodOptions|BodyResponseCallback<Schema$Object>,
        callback?: BodyResponseCallback<Schema$Object>):
        void|AxiosPromise<Schema$Object> {
      let params = (paramsOrCallback || {}) as Params$Resource$Objects$Get;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Objects$Get;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
            {
              url: (rootUrl + '/storage/v1beta1/b/{bucket}/o/{object}')
                       .replace(/([^:]\/)\/+/g, '$1'),
              method: 'GET'
            },
            options),
        params,
        requiredParams: ['bucket', 'object'],
        pathParams: ['bucket', 'object'],
        context: this.getRoot()
      };
      if (callback) {
        createAPIRequest<Schema$Object>(parameters, callback);
      } else {
        return createAPIRequest<Schema$Object>(parameters);
      }
    }

    /**
     * storage.objects.insert
     * @desc Stores new data blobs and associated metadata.
     * @alias storage.objects.insert
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.bucket Name of the bucket in which to store the new object. Overrides the provided object metadata's bucket value, if any.
     * @param {string=} params.name Name of the object. Required when the object metadata is not otherwise provided. Overrides the object metadata's name value, if any.
     * @param {string=} params.projection Set of properties to return. Defaults to no_acl, unless the object resource specifies the acl property, when it defaults to full.
     * @param  {object} params.resource Media resource metadata
     * @param {object} params.media Media object
     * @param {string} params.media.mimeType Media mime-type
     * @param {string|object} params.media.body Media body contents
     * @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
     */
    insert(params?: Params$Resource$Objects$Insert, options?: MethodOptions):
        AxiosPromise<Schema$Object>;
    insert(
        params: Params$Resource$Objects$Insert,
        options: MethodOptions|BodyResponseCallback<Schema$Object>,
        callback: BodyResponseCallback<Schema$Object>): void;
    insert(
        params: Params$Resource$Objects$Insert,
        callback: BodyResponseCallback<Schema$Object>): void;
    insert(callback: BodyResponseCallback<Schema$Object>): void;
    insert(
        paramsOrCallback?: Params$Resource$Objects$Insert|
        BodyResponseCallback<Schema$Object>,
        optionsOrCallback?: MethodOptions|BodyResponseCallback<Schema$Object>,
        callback?: BodyResponseCallback<Schema$Object>):
        void|AxiosPromise<Schema$Object> {
      let params = (paramsOrCallback || {}) as Params$Resource$Objects$Insert;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Objects$Insert;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
            {
              url: (rootUrl + '/storage/v1beta1/b/{bucket}/o')
                       .replace(/([^:]\/)\/+/g, '$1'),
              method: 'POST'
            },
            options),
        params,
        mediaUrl: (rootUrl + '/upload/storage/v1beta1/b/{bucket}/o')
                      .replace(/([^:]\/)\/+/g, '$1'),
        requiredParams: ['bucket'],
        pathParams: ['bucket'],
        context: this.getRoot()
      };
      if (callback) {
        createAPIRequest<Schema$Object>(parameters, callback);
      } else {
        return createAPIRequest<Schema$Object>(parameters);
      }
    }

    /**
     * storage.objects.list
     * @desc Retrieves a list of objects matching the criteria.
     * @alias storage.objects.list
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.bucket Name of the bucket in which to look for objects.
     * @param {string=} params.delimiter Returns results in a directory-like mode. items will contain only objects whose names, aside from the prefix, do not contain delimiter. Objects whose names, aside from the prefix, contain delimiter will have their name, truncated after the delimiter, returned in prefixes. Duplicate prefixes are omitted.
     * @param {integer=} params.max-results Maximum number of items plus prefixes to return. As duplicate prefixes are omitted, fewer total results may be returned than requested.
     * @param {string=} params.pageToken A previously-returned page token representing part of the larger set of results to view.
     * @param {string=} params.prefix Filter results to objects whose names begin with this prefix.
     * @param {string=} params.projection Set of properties to return. Defaults to no_acl.
     * @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(params?: Params$Resource$Objects$List, options?: MethodOptions):
        AxiosPromise<Schema$Objects>;
    list(
        params: Params$Resource$Objects$List,
        options: MethodOptions|BodyResponseCallback<Schema$Objects>,
        callback: BodyResponseCallback<Schema$Objects>): void;
    list(
        params: Params$Resource$Objects$List,
        callback: BodyResponseCallback<Schema$Objects>): void;
    list(callback: BodyResponseCallback<Schema$Objects>): void;
    list(
        paramsOrCallback?: Params$Resource$Objects$List|
        BodyResponseCallback<Schema$Objects>,
        optionsOrCallback?: MethodOptions|BodyResponseCallback<Schema$Objects>,
        callback?: BodyResponseCallback<Schema$Objects>):
        void|AxiosPromise<Schema$Objects> {
      let params = (paramsOrCallback || {}) as Params$Resource$Objects$List;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Objects$List;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
            {
              url: (rootUrl + '/storage/v1beta1/b/{bucket}/o')
                       .replace(/([^:]\/)\/+/g, '$1'),
              method: 'GET'
            },
            options),
        params,
        requiredParams: ['bucket'],
        pathParams: ['bucket'],
        context: this.getRoot()
      };
      if (callback) {
        createAPIRequest<Schema$Objects>(parameters, callback);
      } else {
        return createAPIRequest<Schema$Objects>(parameters);
      }
    }

    /**
     * storage.objects.patch
     * @desc Updates a data blob's associated metadata. This method supports
     * patch semantics.
     * @alias storage.objects.patch
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.bucket Name of the bucket in which the object resides.
     * @param {string} params.object Name of the object.
     * @param {string=} params.projection Set of properties to return. Defaults to full.
     * @param {().Object} 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(params?: Params$Resource$Objects$Patch, options?: MethodOptions):
        AxiosPromise<Schema$Object>;
    patch(
        params: Params$Resource$Objects$Patch,
        options: MethodOptions|BodyResponseCallback<Schema$Object>,
        callback: BodyResponseCallback<Schema$Object>): void;
    patch(
        params: Params$Resource$Objects$Patch,
        callback: BodyResponseCallback<Schema$Object>): void;
    patch(callback: BodyResponseCallback<Schema$Object>): void;
    patch(
        paramsOrCallback?: Params$Resource$Objects$Patch|
        BodyResponseCallback<Schema$Object>,
        optionsOrCallback?: MethodOptions|BodyResponseCallback<Schema$Object>,
        callback?: BodyResponseCallback<Schema$Object>):
        void|AxiosPromise<Schema$Object> {
      let params = (paramsOrCallback || {}) as Params$Resource$Objects$Patch;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Objects$Patch;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
            {
              url: (rootUrl + '/storage/v1beta1/b/{bucket}/o/{object}')
                       .replace(/([^:]\/)\/+/g, '$1'),
              method: 'PATCH'
            },
            options),
        params,
        requiredParams: ['bucket', 'object'],
        pathParams: ['bucket', 'object'],
        context: this.getRoot()
      };
      if (callback) {
        createAPIRequest<Schema$Object>(parameters, callback);
      } else {
        return createAPIRequest<Schema$Object>(parameters);
      }
    }

    /**
     * storage.objects.update
     * @desc Updates a data blob's associated metadata.
     * @alias storage.objects.update
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.bucket Name of the bucket in which the object resides.
     * @param {string} params.object Name of the object.
     * @param {string=} params.projection Set of properties to return. Defaults to full.
     * @param {().Object} 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(params?: Params$Resource$Objects$Update, options?: MethodOptions):
        AxiosPromise<Schema$Object>;
    update(
        params: Params$Resource$Objects$Update,
        options: MethodOptions|BodyResponseCallback<Schema$Object>,
        callback: BodyResponseCallback<Schema$Object>): void;
    update(
        params: Params$Resource$Objects$Update,
        callback: BodyResponseCallback<Schema$Object>): void;
    update(callback: BodyResponseCallback<Schema$Object>): void;
    update(
        paramsOrCallback?: Params$Resource$Objects$Update|
        BodyResponseCallback<Schema$Object>,
        optionsOrCallback?: MethodOptions|BodyResponseCallback<Schema$Object>,
        callback?: BodyResponseCallback<Schema$Object>):
        void|AxiosPromise<Schema$Object> {
      let params = (paramsOrCallback || {}) as Params$Resource$Objects$Update;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Objects$Update;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
            {
              url: (rootUrl + '/storage/v1beta1/b/{bucket}/o/{object}')
                       .replace(/([^:]\/)\/+/g, '$1'),
              method: 'PUT'
            },
            options),
        params,
        requiredParams: ['bucket', 'object'],
        pathParams: ['bucket', 'object'],
        context: this.getRoot()
      };
      if (callback) {
        createAPIRequest<Schema$Object>(parameters, callback);
      } else {
        return createAPIRequest<Schema$Object>(parameters);
      }
    }
  }

  export interface Params$Resource$Objects$Delete {
    /**
     * Auth client or API Key for the request
     */
    auth?: string|OAuth2Client|JWT|Compute|UserRefreshClient;

    /**
     * Name of the bucket in which the object resides.
     */
    bucket?: string;
    /**
     * Name of the object.
     */
    object?: string;
  }
  export interface Params$Resource$Objects$Get {
    /**
     * Auth client or API Key for the request
     */
    auth?: string|OAuth2Client|JWT|Compute|UserRefreshClient;

    /**
     * Name of the bucket in which the object resides.
     */
    bucket?: string;
    /**
     * Name of the object.
     */
    object?: string;
    /**
     * Set of properties to return. Defaults to no_acl.
     */
    projection?: string;
  }
  export interface Params$Resource$Objects$Insert {
    /**
     * Auth client or API Key for the request
     */
    auth?: string|OAuth2Client|JWT|Compute|UserRefreshClient;

    /**
     * Name of the bucket in which to store the new object. Overrides the
     * provided object metadata's bucket value, if any.
     */
    bucket?: string;
    /**
     * Name of the object. Required when the object metadata is not otherwise
     * provided. Overrides the object metadata's name value, if any.
     */
    name?: string;
    /**
     * Set of properties to return. Defaults to no_acl, unless the object
     * resource specifies the acl property, when it defaults to full.
     */
    projection?: string;

    /**
     * Request body metadata
     */
    requestBody?: Schema$Object;

    /**
     * Media metadata
     */
    media?: {
      /**
       * Media mime-type
       */
      mediaType?: string;

      /**
       * Media body contents
       */
      body?: any;
    };
  }
  export interface Params$Resource$Objects$List {
    /**
     * Auth client or API Key for the request
     */
    auth?: string|OAuth2Client|JWT|Compute|UserRefreshClient;

    /**
     * Name of the bucket in which to look for objects.
     */
    bucket?: string;
    /**
     * Returns results in a directory-like mode. items will contain only objects
     * whose names, aside from the prefix, do not contain delimiter. Objects
     * whose names, aside from the prefix, contain delimiter will have their
     * name, truncated after the delimiter, returned in prefixes. Duplicate
     * prefixes are omitted.
     */
    delimiter?: string;
    /**
     * Maximum number of items plus prefixes to return. As duplicate prefixes
     * are omitted, fewer total results may be returned than requested.
     */
    'max-results'?: number;
    /**
     * A previously-returned page token representing part of the larger set of
     * results to view.
     */
    pageToken?: string;
    /**
     * Filter results to objects whose names begin with this prefix.
     */
    prefix?: string;
    /**
     * Set of properties to return. Defaults to no_acl.
     */
    projection?: string;
  }
  export interface Params$Resource$Objects$Patch {
    /**
     * Auth client or API Key for the request
     */
    auth?: string|OAuth2Client|JWT|Compute|UserRefreshClient;

    /**
     * Name of the bucket in which the object resides.
     */
    bucket?: string;
    /**
     * Name of the object.
     */
    object?: string;
    /**
     * Set of properties to return. Defaults to full.
     */
    projection?: string;

    /**
     * Request body metadata
     */
    requestBody?: Schema$Object;
  }
  export interface Params$Resource$Objects$Update {
    /**
     * Auth client or API Key for the request
     */
    auth?: string|OAuth2Client|JWT|Compute|UserRefreshClient;

    /**
     * Name of the bucket in which the object resides.
     */
    bucket?: string;
    /**
     * Name of the object.
     */
    object?: string;
    /**
     * Set of properties to return. Defaults to full.
     */
    projection?: string;

    /**
     * Request body metadata
     */
    requestBody?: Schema$Object;
  }
}

redpajama_set_name: RedPajamaGithub


text:
Rejon wietecki (biał. Ве́ткаўскі раён, Wietkauski rajon, ros. Ве́тковский райо́н, Wietkowskij rajon) – rejon w południowo-wschodniej Białorusi, w obwodzie homelskim. Leży na terenie dawnego powiatu homelskiego.

Geografia
Rejon wietecki ma powierzchnię 1558,62 km². Lasy zajmują powierzchnię 759,25 km², bagna 125,50 km², obiekty wodne 24,09 km².

Przypisy

Wietkowski

wietecki

redpajama_set_name: RedPajamaWikipedia


text:
require 'rails_helper'

describe DateNotInFutureValidator do
  let(:test_model) do
    Class.new do
      include ActiveModel::Validations

      attr_accessor :date_attr

      validates :date_attr, date_not_in_future: true
    end
  end

  subject { test_model.new }

  it 'passes when attribute is a valid date' do
    subject.date_attr = Date.current
    expect(subject).to be_valid
  end

  it 'fails when attribute is not a date' do
    subject.date_attr = 'fake_date'
    expect(subject).to_not be_valid
  end

  it 'returns appropriate message when attribute is not a date' do
    subject.date_attr = 'fake_date'
    expect(subject).to_not be_valid
    expect(subject.errors[:date_attr]).to eq ['is not a valid date']
  end

  it 'passes when the date attribute is in the past' do
    subject.date_attr = 4.days.ago
    expect(subject).to be_valid
  end

  it 'fails when the date attribute is in the future' do
    subject.date_attr = 4.days.from_now
    expect(subject).not_to be_valid
  end

  it 'returns appropriate message when date is in future' do
    subject.date_attr = 4.days.from_now
    subject.valid?
    expect(subject.errors[:date_attr]).to eq ['is not valid (cannot be in the future)']
  end
end


text:
Q: Facing difficulties in Cauchy PDF problem from harvard stats 110 book
I have two doubts:

*

*If X and Y are independent then PDF of X/Y is simply PDF of X(by independence) I don't know where am I interpreting wrong, Please correct me.

*How X/Y and X/|Y| are identically distributed by the symmetry of the standard Normal distribution Even if so How could we say that P(X/Y <= t) = P(X/|Y| <= t).
Thank you for your valuable time... :)

A: One way of understanding they are not independent is to take a large value of $X$ say $2$ and a small value of $Y$ say $.1$ this will result in the fatter tails than the original $X$ distribution. There will be quite a few values close to zero, so this situation will be fairly common.
For the second part, you could consider negative and positive $t$ separately. Because of symmetry of each of the two constituent normal distributions there are equal chances of the result being positive or negative. Thus you can just consider whether one of the numerator or denominator is positive or negative, and in the text they have chosen $Y$ which looks slightly more elegant.

redpajama_set_name: RedPajamaStackExchange


text:
NATO to boost presence in Baltics, Black Sea region
The head of the US-led military bloc said supporting Ukraine is in the interest of all member states
NATO Secretary General Jens Stoltenberg said the alliance is set to expand its presence across Eastern Europe, from the Black Sea to the Baltics, hoping to send a "clear message" to Russia as fighting rages on in Ukraine.
A NATO foreign ministers' meeting will kick off in Bucharest on Tuesday, where Stoltenberg said members will "address ways to step up our support for Ukraine." He hailed Romania's "significant military assistance" to Kiev, claiming it is "in our own security interest" to back Ukrainian forces while insisting "We cannot let [Russian President Vladimir] Putin win."
Kiev has received a long list of heavy weaponry from Western allies, with the United States alone approving more than $19 billion in direct military aid since late February, including dozens of long-range High Mobility Artillery Rocket Systems (HIMARS), more than 46,000 anti-armor platforms and nearly 200 artillery pieces. Washington and its partners have vowed to continue such assistance, despite reports that a majority of NATO states have severely depleted their weapons and ammunition stocks after countless arms transfers to Ukraine.
READ MORE: 'Hard times' ahead for Europe - NATO
Album: "China Today" arts week in Australia
© Provided by Xinhua ADELAIDE, Australia, Jan. 31 (Xinhua) -- The "China Today" arts week is being held in Adelaide, ...