Authorized Buyers Real-time Bidding Protocol Buffer

View raw content Back to Reference page

// Protocol version: v.331
import "google/protobuf/struct.proto";

// This is the message that Google uses to request bids. A BidRequest
// includes the ad slot from a single impression.
message BidRequest {
  // Unique request id generated by Google. This is 16 bytes long.
  required bytes id = 2;

  // -----------------------------------------------------------
  // This section lists information that we know about the user.
  //
  // The first 3 bytes of the IP address in network byte order for IPv4, or the
  // first 6 bytes for IPv6. Note that the number and position of the bytes
  // included from IPv6 addresses may change later.
  optional bytes ip = 4;

  // Reasons for special treatment of user data (google_user_id,
  // hosted_match_data, IDFA, etc).
  enum UserDataTreatment {
    // The current request should be treated as child-directed for purposes of
    // the Children's Online Privacy Protection Act. See
    // https://support.google.com/admanager/answer/4442399 for more information.
    TAG_FOR_CHILD_DIRECTED_TREATMENT = 0;
  }

  // Deprecated. This will be removed in March 2024.
  // When user_data_treatment is set, the user's cookie/id data is cleared from
  // the request and is not sent in callout.
  // The impacted fields are:
  //  * google_user_id
  //  * hosted_match_data
  //  * mobile.encrypted_advertising_id
  //  * mobile.encrypted_hashed_idfa
  //  * session_id
  repeated UserDataTreatment user_data_treatment = 49 [deprecated = true];

  // The Google ID for the user. This field is the unpadded web-safe base64
  // encoded version of a binary cookie id. See the "Base 64 Encoding with URL
  // and Filename Safe Alphabet" section in RFC 3548 for encoding details. This
  // field may be the same as the Google ID returned by the cookie matching
  // service. Not set if there is one or more user_data_treatment value.
  optional string google_user_id = 21;

  // The version number of the google_user_id. We may sometimes change the
  // mapping from cookie to google_user_id. In this case the version will be
  // incremented.
  optional uint32 cookie_version = 20;

  // The time in seconds since the google_user_id was created.
  // This number may be quantized.
  optional int32 cookie_age_seconds = 31;

  // Match data stored for this google_user_id through the cookie matching
  // service. If a match exists, then this field holds the decoded data that
  // was passed in the google_hm parameter.
  // Not set if there is one or more user_data_treatment value.
  optional bytes hosted_match_data = 37;

  // Represents a short-lived user session on CTV/OTT devices,
  // with a maximum session duration of 6 hours.
  // The use of session_id is never allowed for ads personalization.
  // session_id may only be used for frequency capping, competitive exclusions
  // or related purposes.
  optional string session_id = 65;

  // Time in seconds since the first ad request in a given app or site session.
  // The session is reset after a sufficiently long break in user activity.
  // Currently, the field is only supported for mobile app requests.
  optional int32 session_duration_seconds = 83;

  // A pseudonymized identifier created and controlled by the publisher for use
  // in frequency capping, audience segmentation and targeting, and sequential
  // ad rotation. See https://support.google.com/admanager/answer/2880055.
  optional string publisher_provided_id = 79;

  // Publisher first-party identifier scoped to a single site, app or vendor.
  message PublisherFirstPartyId {
    // Specifies how an ID is scoped and the type of requests it is used with.
    enum IdType {
      // A default value that should not be used.
      UNKNOWN = 0;

      // A site-scoped cookie for requests from web browsers.
      SITE_SCOPED_COOKIE = 1;
    }

    // The type of the ID. This specifies how it is scoped and the type of
    // requests it is used with.
    optional IdType id_type = 1;

    // The value of the ID.
    optional string id = 2;
  }
  optional PublisherFirstPartyId publisher_first_party_id = 85;

  // A string that identifies the browser and type of device that sent the
  // request. Certain data may be redacted or replaced.
  optional string user_agent = 6;

  // Information about privacy treatments that apply to an ad opportunity
  // offered through this request.
  message PrivacyTreatments {
    // Generalization that can be applied to the BidRequest.ip field.
    enum IpGeneralization {
      // The BidRequest.ip field is truncated, /24 for IPv4 and /48 for IPv6.
      // IPv4 addresses are truncated to 3-byte strings, representing the
      // first three octets of an IP address. IPv6 addresses are truncated to
      // 6-byte strings, representing the first 6 octets of an IP address.
      IP_TRUNCATED = 0;

      // The BidRequest.ip field is redacted.
      IP_REDACTED = 2;
    }

    // Generalization for the BidRequest.ip field.
    optional IpGeneralization ip = 1;

    // Generalization that can be applied to the user_agent and user_agent_data
    // fields.
    enum UserAgentGeneralization {
      // The user_agent and user_agent_data fields are both provided in full.
      USER_AGENT_FULL = 0;

      // The user_agent and user_agent_data fields are generalized, which can
      // include limiting browser and OS version information to major versions
      // only and other changes to protect user privacy.
      USER_AGENT_COARSE = 1;
    }

    // Generalization that was applied to the user_agent and user_agent_data
    // fields, if any.
    optional UserAgentGeneralization user_agent = 2;

    // Specifies the reasons that ads returned in response to this request
    // should not be personalized. This signal does not reflect user decisions
    // on surfaces including iOS App Tracking Transparency
    // (https://developer.apple.com/documentation/apptrackingtransparency) or
    // Android advertising ID
    // (https://support.google.com/googleplay/android-developer/answer/6048248).
    // See BidRequest.device.limit_ad_tracking and
    // BidRequest.device.app_tracking_authorization_status fields for more
    // information.
    enum NonPersonalizedAdsReason {
      UNKNOWN = 0;

      // The publisher has declared that this request should serve
      // non-personalized ads independent of other signals.
      // https://support.google.com/admanager/answer/9005435#npa
      PUBLISHER_DECLARED_NPA = 1;

      // The publisher has requested restricted data processing for this
      // request. https://support.google.com/authorizedbuyers/answer/11121285
      RESTRICT_DATA_PROCESSING = 2;

      // The user has opted out of ads personalization.
      USER_OPT_OUT = 3;
    }
    repeated NonPersonalizedAdsReason non_personalized_ads_reason = 6 [packed =
      true];

    // True if publisher grants the permission to allow the bidder to use bid
    // request data to build user profiles for uses such as interest-based ads
    // and remarketing. To use this data to build user profiles, a bidder must
    // also win a given impression.
    // Learn more about data collection controls:
    // https://support.google.com/admanager/answer/11956152
    optional bool allow_user_data_collection = 7;

    // Reasons why on-device storage access could be restricted during the
    // delivery of a winning ad.
    enum DeviceStorageRestrictionReason {
      DEVICE_STORAGE_RESTRICTION_UNKNOWN = 0;

      // This request is subject to user consent requirements to allow for
      // device storage access for advertising use cases such as ads
      // measurement, frequency capping, or profiling, but consent was
      // insufficient or not provided.
      INSUFFICIENT_USER_CONSENT = 1;
    }

    // Indicates the reason why access of local device storage during winning ad
    // rendering and measurement is restricted.
    optional DeviceStorageRestrictionReason device_storage_restriction_reason =
      8;
  }
  optional PrivacyTreatments privacy_treatments = 71;

  // Data segments that describe the content or audience.
  message SegmentData {
    // The Google assigned ID of the data provider. For the list of data
    // providers, see
    // https://storage.googleapis.com/adx-rtb-dictionaries/data_providers.txt.
    optional string id = 5;

    // Exchange-specific name for the signal provider.
    optional string name = 1;

    // Segment objects contain segment IDs that can be used with the taxonomy
    // type to access first party data.
    message Segment {
      // ID of the data segment specific to the signal provider.
      optional string id = 1;
    }
    repeated Segment segment = 2;

    // Identifies the taxonomy that the segment IDs belong to.
    enum TaxonomyType {
      TAXONOMY_TYPE_UNKNOWN = 0;

      // https://github.com/InteractiveAdvertisingBureau/Taxonomies/blob/main/Audience%20Taxonomies/Audience%20Taxonomy%201.1.tsv
      IAB_AUDIENCE_1_1 = 4;

      // https://github.com/InteractiveAdvertisingBureau/Taxonomies/blob/main/Content%20Taxonomies/Content%20Taxonomy%202.2.tsv
      IAB_CONTENT_2_2 = 6;

      // https://github.com/InteractiveAdvertisingBureau/Taxonomies/blob/main/Content%20Taxonomies/Content%20Taxonomy%203.0.tsv
      IAB_CONTENT_3_0 = 7;
    }

    // The taxonomy in use for segment IDs.
    optional TaxonomyType type = 3;
  }

  // Data segments for Publisher Provided Signals:
  // https://support.google.com/admanager/answer/12451124
  repeated SegmentData segment_data = 75;

  // Structured user agent information, which can be used when a client
  // supports User-Agent Client Hints: https://wicg.github.io/ua-client-hints/
  //
  // Note: When available, fields are sourced from Client Hints HTTP headers
  // or equivalent JavaScript accessors from the NavigatorUAData interface.
  // For agents that have no support for User-Agent Client Hints, an exchange
  // can also extract information from the parsed User-Agent header, so this
  // object can always be used as the source of the user agent information.
  message UserAgent {
    // Identifies a device's browser or similar software component, and the
    // user agent's execution platform or operating system.
    message BrandVersion {
      // A brand identifier, for example, "Chrome" or "Windows". The value may
      // be sourced from the User-Agent Client Hints headers, representing
      // either the user agent brand (from the Sec-CH-UA-Full-Version header)
      // or the platform brand (from the Sec-CH-UA-Platform header).
      optional string brand = 1;

      // A sequence of version components, in descending hierarchical order
      // (major, minor, micro, ...).
      repeated string version = 2;
    }

    // Each BrandVersion object identifies a browser or similar software
    // component. Exchanges should send brands and versions derived from
    // the Sec-CH-UA-Full-Version-List header.
    repeated BrandVersion browsers = 8;

    // Identifies the user agent's execution platform / OS. Exchanges should
    // send a brand derived from the Sec-CH-UA-Platform header, and version
    // derived from the Sec-CH-UAPlatform-Version header.
    optional BrandVersion platform = 2;

    // True if the agent prefers a "mobile" version of the content if
    // available, meaning optimized for small screens or touch input. False
    // if the agent prefers the "desktop" or "full" content. Exchanges should
    // derive this value from the Sec-CH-UAMobile header.
    optional bool mobile = 3;

    // Device's major binary architecture, for example, "x86" or "arm".
    // Exchanges should retrieve this value from the Sec-CH-UA-Arch header.
    optional string architecture = 4;

    // Device's bitness, for example, "64" for 64-bit architecture. Exchanges
    // should retrieve this value from the Sec-CH-UA-Bitness header.
    optional string bitness = 9;

    // Device model. Exchanges should retrieve this value from the
    // Sec-CH-UAModel header.
    optional string model = 5;

    // Possible sources for User-Agent data. In the case of Client Hints headers
    // the source also distinguishes between requests that are restricted to
    // the low-entropy headers and requests that don't have that restriction;
    // see wicg.github.io/client-hints-infrastructure/#low-entropy-hint-table.
    enum Source {
      UNKNOWN_SOURCE = 0;

      // User-Agent Client Hints (only low-entropy headers were available).
      CLIENT_HINTS_LOW_ENTROPY = 1;

      // User-Agent Client Hints (with high-entropy headers available).
      CLIENT_HINTS_HIGH_ENTROPY = 2;

      // Parsed from User-Agent header.
      USER_AGENT_STRING = 3;
    }

    // The source of data for the User Agent information.
    optional Source source = 10;
  }

  // Structured user agent information. If both BidRequest.ua and
  // BidRequest.sua are present, BidRequest.sua should be considered the
  // more accurate representation of the device attributes. This is because
  // BidRequest.ua may contain a frozen or reduced user agent string.
  optional UserAgent user_agent_data = 63;

  // The billing address country of the publisher. This may be different from
  // the detected country of the user in geo_criteria_id or the hosting country
  // of the website. For a complete list of country codes, refer to
  // https://developers.google.com/google-ads/api/data/codes-formats#country_codes
  optional string publisher_country = 55;

  // The ID of the host publisher. When populated, indicates that the host
  // publisher participated in revenue sharing, and the ID can be used to
  // authorize ads.txt.
  optional string host_publisher_id = 73;

  // The domain of the partner (of the site/app owner) with ownership
  // of some portion of ad inventory on the site/app. The partner's ads.txt or
  // app-ads.txt file will be hosted here. More detail at
  // http://iabtechlab.com/wp-content/uploads/2021/03/ctv-app-ads-explainer-guide.pdf
  optional string inventory_partner_domain = 72;

  // Location of the end user. Uses a subset of the codes used in the Google
  // Ads API. See the geo-table.csv table in the technical documentation for a
  // list of IDs. The geo_criteria_id field replaces the deprecated country,
  // region, city, and metro fields.
  // It is recommended that BidRequest.geo be used instead of this field.
  // See Geotargeting Guide:
  // https://developers.google.com/authorized-buyers/rtb/geotargeting
  optional int32 geo_criteria_id = 39;

  // The user's approximate geographic location. All location information is
  // IP geolocation-derived. The lat/lon fields may be a reference position
  // (for example, centroid) for the IP geolocation-derived location that's also
  // carried by the other fields (for example, a city), and accuracy will be the
  // radius of a circle with the approximate area of that location. Location and
  // its accuracy will be fuzzified as necessary to protect user privacy. See
  // Geotargeting Guide:
  // https://developers.google.com/authorized-buyers/rtb/geotargeting
  message Geo {
    // Latitude from -90.0 to +90.0, where negative is south.
    optional double lat = 1;

    // Longitude from -180.0 to +180.0, where negative is west.
    optional double lon = 2;

    // Country using ISO-3166-1 Alpha-3.
    optional string country = 3;

    // Region code using ISO-3166-2; 2-letter state code if USA.
    optional string region = 4;

    // Google metro code; similar to but not exactly Nielsen DMAs.
    optional string metro = 6;

    // City using United Nations Code for Trade & Transport Locations.
    // (https://www.unece.org/cefact/locode/service/location.htm).
    optional string city = 7;

    // Zip/postal code.
    optional string zip = 8;

    // Estimated location accuracy in meters.
    optional int32 accuracy = 11;

    // Local time as the number +/- of minutes from UTC.
    optional int32 utcoffset = 10;
  }
  optional Geo geo = 62;

  // Deprecated. This field will be removed in Q3 2023. It is recommended that
  // BidRequest.geo.zip be used instead. See Geotargeting Guide:
  // https://developers.google.com/authorized-buyers/rtb/geotargeting
  // Detected postal code of the appropriate type for the country of the end
  // user (for example, zip code if the country is "US"). The postal_code_prefix
  // field is set when accuracy is too low to imply a full code, otherwise the
  // postal_code field is set.
  optional string postal_code = 33 [deprecated = true];

  // Deprecated. This field will be removed in Q3 2023. It is recommended that
  // BidRequest.geo.zip be used instead. See Geotargeting Guide:
  // https://developers.google.com/authorized-buyers/rtb/geotargeting
  optional string postal_code_prefix = 34 [deprecated = true];

  // Deprecated. This field will be removed in Q3 2023. It is recommended that
  // BidRequest.geo is used instead. See Geotargeting Guide:
  // https://developers.google.com/authorized-buyers/rtb/geotargeting
  // Encrypted hyperlocal targeting signals.
  optional bytes encrypted_hyperlocal_set = 40 [deprecated = true];

  // Coarse geolocation information approximated based on the IP address of the
  // device the ad request originated from.
  message Hyperlocal {
    // A location on the Earth's surface.
    message Point {
      optional float latitude = 1;
      optional float longitude = 2;
    }

    // The device can be at any point inside the geofence polygon defined by a
    // list of corners. Currently, the polygon is always a parallelogram with 4
    // corners.
    repeated Point corners = 1;
  }

  message HyperlocalSet {
    // This field currently contains at most one hyperlocal polygon.
    repeated Hyperlocal hyperlocal = 1;

    // The approximate geometric center of a geofence area. It is calculated
    // exclusively based on the geometric shape of the geofence area and in no
    // way indicates the mobile device's actual location within the geofence
    // area. If multiple hyperlocal polygons are specified above then
    // center_point is the geometric center of all hyperlocal polygons.
    optional Hyperlocal.Point center_point = 2;
  }

  // Deprecated. This field will be removed in Q3 2023. It is recommended that
  // BidRequest.geo is used instead. See Geotargeting Guide:
  // https://developers.google.com/authorized-buyers/rtb/geotargeting
  // Unencrypted version of encrypted_hyperlocal_set. This field is only set
  // when using an SSL connection.
  optional HyperlocalSet hyperlocal_set = 53 [deprecated = true];

  // Deprecated. This field will be removed in Q3 2023. It is recommended that
  // BidRequest.geo is used instead. See Geotargeting Guide:
  // https://developers.google.com/authorized-buyers/rtb/geotargeting
  // The offset of the user's time from GMT in minutes. For example, GMT+10 is
  // timezone_offset = 600.
  optional int32 timezone_offset = 25 [deprecated = true];

  // This field is not populated by default. We recommend that bidders instead
  // store and look up list ids using either google_user_id or hosted_match_data
  // as keys.
  message UserList {
    // The user list id.
    optional int64 id = 1;

    // The time in seconds since the user was added to the list.
    optional int32 age_seconds = 2;
  }
  repeated UserList user_list = 32;

  // -----------------------------------------------------------
  // This section lists information that we know about the web page or mobile
  // application where the impression originates.
  //
  // The publisher ID as defined by the publisher code suffix of
  // the web property code. For instance, "pub-123" is the publisher code of web
  // property code "ca-pub-123" (ca- is the product specific prefix of the web
  // property).
  optional string publisher_id = 56;

  // Deprecated. This field will be removed in Q2 2024.
  // The seller network id. See seller-network-ids.txt file in the technical
  // documentation for a list of ids. This is only set if the site is not
  // anonymous and the publisher allows site targeting.
  optional int32 seller_network_id = 41 [deprecated = true];

  // Id for the partner that provides this inventory. This is only set when
  // seller_network_id is also set and further partner information beyond the
  // seller_network_id is also available. The value of the partner_id is not
  // meaningful beyond providing a stable identifier.
  optional fixed64 partner_id = 52;

  // The URL of the page with parameters removed. This is only set if the
  // publisher allows site targeting. This always starts with a protocol (either
  // http or https).
  optional string url = 11;

  // Indicates that the request is using semi-transparent branding,
  // which means only a truncated version of the request URL will
  // be provided. This decision is made by the publisher, see
  // https://support.google.com/admanager/answer/4584891#urls for context.
  optional bool is_semi_transparent_request = 67;

  // Detected user languages, based on the language of the web page, the browser
  // settings, and other signals. The order is arbitrary. The codes are 2 or 5
  // characters and are documented at
  // https://developers.google.com/google-ads/api/data/codes-formats#languages
  repeated string detected_language = 12;

  // One or more detected verticals for the page as determined by Google.
  message Vertical {
    // The vertical id. See the publisher-verticals.txt file in the technical
    // documentation for a list of ids.
    required int32 id = 1;

    // Weight for this vertical, in the (0.0, 1.0] range. More relevant
    // verticals have higher weights.
    required float weight = 2;
  }

  // Unordered list of detected content verticals. See the
  // publisher-verticals.txt file in the technical documentation for a list of
  // ids.
  repeated Vertical detected_vertical = 13;

  // List of detected content labels. See content-labels.txt file in the
  // technical documentation for a list of ids.
  repeated int32 detected_content_label = 26 [packed = true];

  // The production quality of the content. See
  // https://github.com/InteractiveAdvertisingBureau/AdCOM/blob/master/AdCOM%20v1.0%20FINAL.md#list--production-qualities-
  // for details.
  enum ProductionQuality {
    QUALITY_UNKNOWN = 0;

    // Content that is usually created or produced by media and entertainment
    // companies using professional-grade equipment, talent, and production
    // crews that hold or maintain the rights for distribution and syndication.
    PROFESSIONAL = 1;

    // Consumer or user-generated content that has professional or industrial
    // qualities (e.g. shot with professional-grade equipment, using
    // professional talent, etc.).
    PROSUMER = 2;

    // Publicly available video content that is created or produced by
    // end users.
    USER_GENERATED = 3;
  }

  // The production quality of the content where an ad can be shown, as
  // determined by the publisher.
  optional ProductionQuality production_quality = 80 [default =
    QUALITY_UNKNOWN];

  // The rating of the content. See
  // https://support.google.com/admanager/answer/12451124#content-rating for
  // details.
  enum ContentRating {
    RATING_UNKNOWN = 0;

    // Content suitable for general audiences.
    GENERAL_AUDIENCES = 1;

    // Content suitable for most audiences with parental guidance.
    PARENTAL_GUIDANCE = 2;

    // Content suitable for teen and older audiences.
    TEEN = 3;

    // Content suitable only for mature audiences.
    MATURE_AUDIENCES = 4;
  }

  // The rating of the content where an ad can be shown.
  optional ContentRating content_rating = 84 [default = RATING_UNKNOWN];

  // This represents a unique ID for the overall query. In the event
  // that there are multiple callouts for a query, all callout requests for that
  // query will contain the same google_query_id.
  optional string google_query_id = 59;

  // The type of auction that will be run for this query.
  enum AuctionType {
    UNKNOWN_AUCTION_TYPE = 0;
    FIRST_PRICE = 1;
    SECOND_PRICE = 2;
    FIXED_PRICE = 3;
  }
  optional AuctionType auction_type = 60 [default = SECOND_PRICE];

  // Information about the device.
  message Device {
    // The type of device on which the ad will be shown.
    enum DeviceType {
      UNKNOWN_DEVICE = 0;
      HIGHEND_PHONE = 1;
      TABLET = 2;

      // Desktop or laptop devices.
      PERSONAL_COMPUTER = 3;

      // Both connected TVs (that is, smart TVs) and connected devices
      // (such as Roku and Apple TV).
      CONNECTED_TV = 4;
      GAME_CONSOLE = 5;
      SET_TOP_BOX = 6;
    }
    optional DeviceType device_type = 1 [default = UNKNOWN_DEVICE];

    // The platform of the device. Examples: android, iphone, palm
    optional string platform = 2 [default = ""];

    // The brand of the device (for example, "Apple" or "Samsung").
    optional string brand = 3 [default = ""];

    // Device model (for example, "pixel 7 pro"). For iPhone/iPad, this
    // field contains Apple's model identifier string (such as "iPhone12,1" and
    // "iPad13,8") if available. Otherwise this field contains the generic
    // model (either "iphone" or "ipad").
    optional string model = 4 [default = ""];

    // Contains the OS version of the platform. For instance, for Android 2,
    // major=2, minor=0. For iPhone 3.3.1, major=3 and minor=3.
    message OsVersion {
      optional int32 major = 1 [default = -1];
      optional int32 minor = 2 [default = -1];
      optional int32 micro = 3 [default = -1];
    }

    // The OS version; for example, 2 for Android 2.1, or 3.3 for iOS 3.3.1.
    optional OsVersion os_version = 5;

    // Unique identifier for the mobile carrier if the device is connected to
    // the internet through a carrier (as opposed to through WiFi). To look up
    // carrier name from carrier ID, refer to:
    // https://storage.googleapis.com/adx-rtb-dictionaries/mobile-carriers.csv.
    optional int64 carrier_id = 6 [default = 0];

    // The width of the device screen in pixels.
    optional int32 screen_width = 7 [default = 0];

    // The height of the device screen in pixels.
    optional int32 screen_height = 8 [default = 0];

    // Used for high-density devices (for example, iOS retina displays). A
    // non-default value indicates that the nominal screen size (with pixels as
    // the unit) does not describe the actual number of pixels in the screen.
    // For example, nominal width and height may be 320x640 for a screen that
    // actually has 640x1280 pixels, in which case screen_width=320,
    // screen_height=640, and screen_pixel_ratio_millis=2000, since each axis
    // has twice as many pixels as its dimensions would indicate.
    optional int32 screen_pixel_ratio_millis = 9 [default = 0];
    enum ScreenOrientation {
      UNKNOWN_ORIENTATION = 0;
      PORTRAIT = 1;
      LANDSCAPE = 2;
    }

    // The screen orientation of the device when the ad request is sent.
    optional ScreenOrientation screen_orientation = 10 [default =
      UNKNOWN_ORIENTATION];

    // Hardware version of the device. For iPhone/iPad, this field contains
    // Apple's model identifier string (such as "iPhone12,1" and "iPad13,8") if
    // available.
    optional string hardware_version = 11;

    // "Limit Ad Tracking" is a commercially endorsed signal based on the
    // operating system or device settings, where `false` indicates that
    // tracking is unrestricted and `true` indicates that tracking must be
    // limited per commercial guidelines.
    //
    // This signal reflects user decisions on surfaces including iOS App
    // Tracking Transparency:
    // https://developer.apple.com/documentation/apptrackingtransparency
    // See also lmt and App Tracking Transparency guidance:
    // https://github.com/InteractiveAdvertisingBureau/openrtb/blob/master/extensions/community_extensions/skadnetwork.md#dnt-lmt-and-app-tracking-transparency-guidance
    // and Android advertising ID:
    // https://support.google.com/googleplay/android-developer/answer/6048248
    optional bool limit_ad_tracking = 12;

    // The possible app tracking authorization statuses that could be applicable
    // for bid requests from iOS devices. For more information about iOS's app
    // tracking authorization status, see:
    // https://developer.apple.com/documentation/apptrackingtransparency/attrackingmanager/authorizationstatus
    enum AuthorizationStatus {
      // User has not yet received a request to authorize access to app-related
      // data that can be used for tracking the user or the device.
      NOT_DETERMINED = 0;

      // Authorization to access app-related data that can be used for tracking
      // the user or the device is restricted.
      RESTRICTED = 1;

      // User denies authorization to access app-related data that can be used
      // for tracking the user or the device.
      DENIED = 2;

      // User authorizes access to app-related data that can be used for
      // tracking the user or the device.
      AUTHORIZED = 3;
    }

    // This field is only populated for iOS devices. Indicates the app tracking
    // authorization status. This value is retrieved from ATTrackingManager
    // and provided as is. For more information about iOS's app tracking
    // authorization status, see:
    // https://developer.apple.com/documentation/apptrackingtransparency/attrackingmanager/authorizationstatus
    optional AuthorizationStatus app_tracking_authorization_status = 13;

    // Possible types of the device's network connection.
    enum ConnectionType {
      CONNECTION_UNKNOWN = 0;

      // Ethernet; Wired Connection
      ETHERNET = 1;

      // WiFi
      WIFI = 2;

      // Mobile Network - Unknown Generation
      CELL_UNKNOWN = 3;

      // Mobile Network - 2G
      CELL_2G = 4;

      // Mobile Network - 3G
      CELL_3G = 5;

      // Mobile Network - 4G
      CELL_4G = 6;

      // Mobile Network - 5G
      CELL_5G = 7;
    }

    // The type of network to which the user's device is connected.
    //
    // For 5G connection type, we send CELL_4G instead of CELL_5G.
    optional ConnectionType connection_type = 15 [default = CONNECTION_UNKNOWN];
  }
  optional Device device = 54;

  // Additional key-value attributes. Currently unused.
  message KeyValue {
    optional string key = 1;
    optional string value = 2;
  }
  repeated KeyValue key_value = 38;

  // Information for ad queries coming from mobile devices. A mobile device is
  // either a mobile phone or a tablet. This is present for ad queries both from
  // mobile devices browsing the web and from mobile apps.
  message Mobile {
    // If true, then this request is from a mobile application. For branded
    // requests, app_id will also be filled in. If the request is from a mobile
    // web page contained inside an app, is_app will still be false, but app_id
    // could be filled in with the app identifier. For SDK-less requests (mostly
    // from connected TVs), this will be true if an app ID is provided directly
    // in the request.
    optional bool is_app = 7 [default = false];

    // The identifier of the mobile app when this ad query comes from a mobile
    // app, or from a mobile web page contained inside an app. If the app was
    // downloaded from the Apple iTunes app store, then this is the app-store
    // id, for example, 343200656. For Android devices, this is the fully
    // qualified package name, for example, com.rovio.angrybirds. For Windows
    // devices it's the App ID, for example,
    // f15abcde-f6gh-47i0-j3k8-37l93817mn3o. For SDK-less requests (mostly from
    // connected TVs), the app ID provided by the publisher directly in the
    // request.
    optional string app_id = 6;

    // If true, then this is a mobile full screen ad request.
    optional bool is_interstitial_request = 10 [default = false];

    // This field contains the IDs of categories to which the current mobile app
    // belongs. This field will be empty if is_app is false. The mapping between
    // mobile apps and categories is defined by the Google Play Store for
    // Android apps, or the Apple iTunes Store for iOS apps. To look up category
    // name from category ID, refer to
    // https://developers.google.com/google-ads/api/data/codes-formats#mobile_app_categories
    repeated int32 app_category_ids = 11;

    // For a mobile web request, this field indicates whether the page is
    // optimized for mobile browsers on high-end mobile phones.
    optional bool is_mobile_web_optimized = 17 [default = false];

    // Indicates whether a mobile app bid request is for an app open ad.
    // See App open ad guidance at
    // https://support.google.com/admob/answer/9341964 for more information.
    optional bool is_app_open_ad = 36 [default = false];

    // This field is used for advertising identifiers for
    // 1) iOS devices (This is called Identifier for Advertising, or IDFA, as
    // described at https://support.google.com/authorizedbuyers/answer/3221407),
    // 2) Android devices,
    // 3) Roku devices,
    // 4) Microsoft Xbox devices,
    // 5) Amazon devices (for example, Amazon Fire).
    //
    // When the encrypted_advertising_id is an IDFA, the plaintext after
    // decrypting the ciphertext is the IDFA (16 byte UUID) returned by iOS's
    // [ASIdentifierManager advertisingIdentifier]. For encrypted_hashed_idfa,
    // the plaintext is the 16 byte MD5 hash of the IDFA. Only one of the two
    // fields will be available, depending on the version of the SDK making the
    // request. Later SDKs provide unhashed values. They are not set if there is
    // one or more user_data_treatment value in the BidRequest.
    optional bytes encrypted_advertising_id = 20;

    // Unencrypted version of encrypted_advertising_id. This field is only set
    // when using an SSL connection. This field is a 16 byte UUID (binary form)
    // or a 32 byte alphanumeric id (such as Samsung ID).
    optional bytes advertising_id = 27;
    optional bytes encrypted_hashed_idfa = 21;

    // Unencrypted version of encrypted_hashed_idfa. This field is only set
    // when using an SSL connection. This field is a 16 byte MD5.
    optional bytes hashed_idfa = 28;

    // App names for Android apps are from the Google Play store.
    // App names for iOS apps are provided by App Annie
    // (https://www.appannie.com). App names for SDK-less requests (mostly from
    // connected TVs) are provided by the publisher directly in the request.
    optional string app_name = 24;

    // Average user rating for the app. The range of user rating is between 1.0
    // and 5.0. Currently only available for apps in Google Play store.
    optional float app_rating = 25;

    // Identification of and information about an SDK installed in the
    // publisher's app that the bidder has access to, often because it's the
    // bidder's SDK.
    message InstalledSdk {
      // Identifier for the installed SDK.
      optional string id = 1;

      // Semantic version of the installed SDK and the adapter that communicates
      // between the installed SDK and Google's SDK.
      message Version {
        optional int32 major = 1 [default = -1];
        optional int32 minor = 2 [default = -1];
        optional int32 micro = 3 [default = -1];
      }

      // The version of the installed SDK.
      optional Version sdk_version = 2;

      // The version of the adapter that communicates with the installed SDK.
      optional Version adapter_version = 3;
    }
    repeated InstalledSdk installed_sdk = 32;

    // Publisher's SKAdNetwork information to support app installation
    // attribution for iOS 14 and later. Apple's SKAdNetwork API helps
    // advertisers measure ad-driven app installation by sending a postback
    // to the ad network after a successful install. Publishers will need
    // to configure supported ad networks in their app's property list
    // (Info.plist) to allow an install to be attributed to the ad impression.
    // For more info visit:
    // https://developer.apple.com/documentation/storekit/skadnetwork
    message SKAdNetworkRequest {
      // List of all SKAdNetwork versions supported by the request, depending on
      // the OS version and the SDK version.
      repeated string versions = 4;

      // ID of publisher app in Apple's App Store.
      optional string sourceapp = 2;

      // SKAdNetworkIdentifier entries in the publisher app's Info.plist.
      repeated string skadnetids = 3;

      // List of fidelity types supported, depending on the SKAdNetwork API
      // version supported by the operating system and SDK as well as ad slot
      // properties.
      repeated SKAdNetworkFidelityType supported_fidelity_types = 5 [packed =
        true];

      // Indicates if this request supports SKOverlay for video ads.
      optional bool skoverlay = 6;
    }
    optional SKAdNetworkRequest skadn = 34;
  }
  optional Mobile mobile = 28;

  // Information about the video if this is an in-video ad request.
  message Video {
    // Describes where the video ad will play.
    enum Placement {
      UNKNOWN_PLACEMENT = 0;

      // Instream means the ad plays before, during, or after other video
      // content. This is similar to a traditional TV commercial. The video
      // content the user is watching does not play while the ad is playing.
      INSTREAM = 1;

      // Interstitial means the video ad plays in front of non-video content,
      // (for example, a news article or video game). The ad covers all or
      // nearly all of the space on the screen occupied by the content and the
      // user is not able to proceed to the content until the ad has finished or
      // been skipped.
      INTERSTITIAL = 2;

      // The in-feed video format is a video creative that shows within a feed
      // of content, typically a social app feed, a list of editorial content
      // items, etc, as the user is scrolling. It renders centered and not to
      // the side.
      IN_FEED = 3;

      // Audio is a request for an ad that is an audio stream. It is distinct
      // from INSTREAM above as that is exclusive to video requests.
      AUDIO = 4;

      // The in-article video format is a video creative that loads and plays
      // between paragraphs of editorial content as a standalone video player.
      IN_ARTICLE = 5;
    }

    // Deprecated. This will be removed in January 2025 per the IAB here:
    // https://github.com/InteractiveAdvertisingBureau/AdCOM/blob/main/AdCOM%20v1.0%20FINAL.md#list--placement-subtypes---video-
    optional Placement placement = 16 [deprecated = true, default =
      UNKNOWN_PLACEMENT];

    // Possible video placement types. See:
    // https://github.com/InteractiveAdvertisingBureau/AdCOM/blob/master/AdCOM%20v1.0%20FINAL.md#list--plcmt-subtypes---video-
    enum Plcmt {
      PLCMT_UNKNOWN = 0;

      // Pre-roll, mid-roll, and post-roll ads that are played before, during or
      // after the streaming video content that the consumer has requested.
      // Instream video must be set to “sound on” by default at player start, or
      // have explicitly clear user intent to watch the video content. While
      // there may be other content surrounding the player, the video content
      // must be the focus of the user’s visit. It should remain the primary
      // content on the page and the only video player in-view capable of audio
      // when playing. If the player converts to floating/sticky, subsequent ad
      // calls should accurately convey the updated player size.
      PLCMT_INSTREAM = 1;

      // Pre-roll, mid-roll, and post-roll ads that are played before, during,
      // or after streaming video content. The video player loads and plays
      // before, between, or after paragraphs of text or graphical content, and
      // starts playing only when it enters the viewport. Accompanying content
      // should only start playback upon entering the viewport. It may convert
      // to a floating/sticky player as it scrolls off the page.
      PLCMT_ACCOMPANYING_CONTENT = 2;

      // Video ads that are played without video content. During playback, it
      // must be the primary focus of the page and take up the majority of the
      // viewport and cannot be scrolled out of view. This can be in placements
      // like in-app video or slideshows.
      PLCMT_INTERSTITIAL = 3;

      // Video ads that are played without streaming video content. This can be
      // in placements like slideshows, native feeds, in-content or
      // sticky/floating.
      PLCMT_NO_CONTENT_STANDALONE = 4;
    }

    // Video placement type declared by the publisher for this impression.
    // Equivalent to the Video.plcmt field introduced in OpenRTB 2.6 to reflect
    // updated industry definitions around different types of video ad
    // placements. This field supersedes the Video.placement field. May be unset
    // if the publisher did not declare a video placement type.
    optional Plcmt plcmt = 23 [default = PLCMT_UNKNOWN];

    // Video placement type inferred by Google for this impression. This field
    // is always filled and can be different from BidRequest.video.plcmt (the
    // publisher-declared placement type).
    optional Plcmt inferred_plcmt = 24 [default = PLCMT_UNKNOWN];

    // The URL of the page that the publisher gives Google to describe the video
    // content, with parameters removed.
    optional string description_url = 10;

    // If true, the video is embedded on a page outside the publisher's domain.
    // When this is set, description_url points to a description of the video
    // (as it always does), and the url field in BidRequest is the page in which
    // the video is embedded. For example, a request for an in-stream ad in a
    // Vimeo video shared on Facebook has is_embedded_offsite set. The url field
    // is for a Facebook page and the description_url points to the video on
    // Vimeo.
    optional bool is_embedded_offsite = 11 [default = false];

    // Describes how the video ad will be played. The playback method is
    // determined to be auto-play, click-to-play or mouse-over based on the best
    // measurement available. This includes things like how recently the user
    // interacted with a web page. For auto-play, ads can start playing with the
    // sound on or off. Some ads (for example, in-feed ads) are muted until the
    // user interacts with the ad. Alternatively, if an ad would normally play
    // with the sound on but the device is muted then the value will be set to
    // sound off. For devices where it is not possible to determine if the
    // device is muted (for example, desktop), we assume that sound is on.
    enum VideoPlaybackMethod {
      METHOD_UNKNOWN = 0;
      AUTO_PLAY_SOUND_ON = 1;
      AUTO_PLAY_SOUND_OFF = 2;
      CLICK_TO_PLAY = 3;
      MOUSE_OVER = 4;
      INITIATE_ON_ENTERING_VIEWPORT_SOUND_ON = 5;
      INITIATE_ON_ENTERING_VIEWPORT_SOUND_OFF = 6;
    }
    optional VideoPlaybackMethod playback_method = 14 [default =
      METHOD_UNKNOWN];

    // Whether the inventory allows clicking on the video ad to take the user to
    // an advertiser site. Some platforms, notably connected TVs, do not
    // support clicking on video ads, in which case this field is set to false.
    optional bool is_clickable = 15;

    // The time in milliseconds from the start of the video when the ad will be
    // displayed. 0 means pre-roll and -1 means post-roll. The value is valid
    // only if this param is set. When not set, the display position is unknown.
    optional int32 videoad_start_delay = 1;

    // The maximum duration in milliseconds of the ad that you should return.
    // If this is not set or has value <= 0, any duration is allowed.
    optional int32 max_ad_duration = 2;

    // The minimum duration in milliseconds of the ad that you should return.
    // If this is not set or has value <= 0, there is no minimum duration.
    optional int32 min_ad_duration = 8;

    // The maximum number of ads in an Adx video pod. A non-zero value indicates
    // that the current ad slot is a video pod that can show multiple video
    // ads. Actual number of video ads shown can be less than or equal to this
    // value but cannot exceed it.
    optional int32 max_ads_in_pod = 12;

    // The maximum duration of a pod in seconds.
    optional int32 max_pod_duration_seconds = 20;

    // Does the publisher allow/require/block skippable video ads?
    enum SkippableBidRequestType {
      ALLOW_SKIPPABLE = 0;
      REQUIRE_SKIPPABLE = 1;
      BLOCK_SKIPPABLE = 2;
    }
    optional SkippableBidRequestType video_ad_skippable = 4 [default =
      ALLOW_SKIPPABLE];

    // The maximum duration in milliseconds for the ad you should return, if
    // this ad is skippable (this generally differs from the maximum duration
    // allowed for non-skippable ads). If this is not set or has value <= 0, any
    // duration is allowed.
    optional int32 skippable_max_ad_duration = 5;

    // Supported video protocols.
    enum VideoProtocol {
      UNKNOWN_VIDEO_PROTOCOL = 0;
      VAST_1_0 = 1;
      VAST_2_0 = 2;
      VAST_3_0 = 3;
      VAST_1_0_WRAPPER = 4;
      VAST_2_0_WRAPPER = 5;
      VAST_3_0_WRAPPER = 6;
      VAST_4_0 = 7;
      VAST_4_0_WRAPPER = 8;
      DAAST_1_0 = 9;
      DAAST_1_0_WRAPPER = 10;
    }

    // Array of supported video bid response protocols.
    repeated VideoProtocol protocols = 17 [packed = true];

    // The video file formats that are allowed for this request. The response
    // should support at least one of them.
    enum VideoFormat {
      UNKNOWN_VIDEO_FORMAT = -1;

      // Flash video files are accepted (FLV).
      VIDEO_FLV = 0;
      VIDEO_MP4 = 1;

      // Valid VAST ads with at least one media file hosted on youtube.com.
      YT_HOSTED = 2;

      // Flash VPAID (SWF).
      VPAID_FLASH = 3;

      // JavaScript VPAID.
      VPAID_JS = 4;
      AUDIO_MP3 = 5;
      AUDIO_OGG = 6;

      // Requires both MP3 & OGG as Google does not know
      // which codecs are installed on the player.
      AUDIO_MP3_OGG = 7;
      VIDEO_WEBM = 8;
      VIDEO_MOV = 9;
      VIDEO_3GPP = 10;
      VIDEO_HLS = 11;
      VIDEO_DASH = 12;

      // Audio version of MP4.
      AUDIO_MP4A = 13;
    }
    repeated VideoFormat allowed_video_formats = 6;

    // Information about the companion ad slots that can be shown with the
    // video. While this is a repeated field there will only be one value in
    // most cases. If there are no companion ads available this field will not
    // be set.
    message CompanionSlot {
      // These fields represent the available heights and widths in this slot.
      // There will always be the same number heights and widths fields.
      repeated int32 height = 1 [packed = true];
      repeated int32 width = 2 [packed = true];

      // These are the formats of the creatives allowed in this companion ad
      // slot.
      enum CreativeFormat {
        UNKNOWN_CREATIVE_FORMAT = -1;
        IMAGE_CREATIVE = 0;
        FLASH_CREATIVE = 1;
        HTML_CREATIVE = 2;
      }
      repeated CreativeFormat creative_format = 3;
    }
    repeated CompanionSlot companion_slot = 7;

    // End cap support. When enabled, the companion ad can be picked to be
    // rendered as an end cap (info card) in the video slot after the video
    // ad finishes playing. If multiple companion ads are returned, IMA SDK
    // chooses one which best matches the device screen size. End cap is
    // supported only on mobile video interstitial inventory.
    enum EndCapSupport {
      // Companion ad won't be rendered as end cap.
      END_CAP_NOT_ENABLED = 0;

      // End cap will be rendered if response contains
      // eligible companion banner, but companion
      // banner is not required.
      END_CAP_OPTIONAL = 1;

      // Not used at this time.
      // Response with companion ad is filtered.
      END_CAP_FORBIDDEN = 2;

      // Not used at this time.
      // Response without companion ad is filtered.
      END_CAP_REQUIRED = 3;
    }
    optional EndCapSupport end_cap_support = 13 [default = END_CAP_NOT_ENABLED];

    // Attributes of the video that the user is viewing, not the video ad.
    // These fields are based on the availability of the video metadata from the
    // video publisher and may not always be populated.
    message ContentAttributes {
      // The duration of the video, in seconds.
      optional int32 duration_seconds = 2;
    }
    optional ContentAttributes content_attributes = 9;

    // Identify whether or not the ad request is being served from a live video
    // stream (0 = is not live, 1 = is live).
    optional bool is_livestream = 18 [default = false];

    // The event that causes playback to end. This will only be filled
    // for non-instream video formats.
    enum PlaybackCessationMode {
      PLAYBACK_CESSATION_MODE_UNKNOWN = 0;

      // On video completion or when terminated by user
      COMPLETION_OR_USER = 1;

      // On leaving viewport or when terminated by user
      LEAVING_OR_USER = 2;

      // On leaving viewport continues as a floating/slider unit until
      // video completion or when terminated by user
      LEAVING_CONTINUES_OR_USER = 3;
    }
    optional PlaybackCessationMode playback_cessation_mode = 19 [default =
      PLAYBACK_CESSATION_MODE_UNKNOWN];

    // Types of feed for audio content. See
    // https://github.com/InteractiveAdvertisingBureau/AdCOM/blob/master/AdCOM%20v1.0%20FINAL.md#list--feed-types-
    // for details.
    enum FeedType {
      FEED_TYPE_UNKNOWN = 0;

      // Music streaming service.
      MUSIC_SERVICE = 1;

      // Live content broadcast over the air but also available through online
      // streaming.
      FM_AM_BROADCAST = 2;

      // Original, pre-recorded content distributed as episodes in a series.
      PODCAST = 3;
    }

    // Type of audio content feed where an audio ad can be played.
    optional FeedType feed_type = 21 [default = FEED_TYPE_UNKNOWN];

    // Options for delivery of audio or video content. See
    // https://github.com/InteractiveAdvertisingBureau/AdCOM/blob/master/AdCOM%20v1.0%20FINAL.md#list_deliverymethods
    // for details.
    enum ContentDeliveryMethod {
      CONTENT_DELIVERY_METHOD_UNKNOWN = 0;

      // Content is transferred continuously by the network; clients receive
      // real-time content for playback while connected. Example: broadcast TV.
      STREAMING = 1;

      // Content is transferred incrementally as client's playback requires.
      // Example: on-demand movies, podcasts, or music.
      PROGRESSIVE = 2;

      // Content should be transferred completely prior to use/playback.
      // Example: content downloaded to the user's device for offline
      // consumption.
      DOWNLOAD = 3;
    }

    // Supported delivery methods for the video or audio content where an ad can
    // be shown.
    repeated ContentDeliveryMethod delivery_method = 22 [packed = true];
  }
  optional Video video = 29;

  // The publisher settings list id that applies to this page.
  // See the RTB Publisher Settings guide at
  // https://developers.google.com/authorized-buyers/rtb/pub-settings-guide
  // for details.
  optional fixed64 publisher_settings_list_id = 42;

  // Publisher type of the inventory where the ad will be shown. For a given
  // request, publisher inventory can be either owned and operated (O&O),
  // represented by the publisher, or of unknown status.
  enum PublisherType {
    UNKNOWN_PUBLISHER_TYPE = 0;
    PUBLISHER_OWNED_AND_OPERATED = 1;
    PUBLISHER_REPRESENTED = 2;
  }
  optional PublisherType publisher_type = 51 [default = UNKNOWN_PUBLISHER_TYPE];
  enum VisibilityState {
    VISIBILITY_STATE_UNKNOWN = 0;

    // The page is at least partially visible. For example, in the foreground
    // tab of a non-minimized window.
    VISIBILITY_STATE_VISIBLE = 1;

    // The page is not visible to users. For example, when the page is in a
    // background browser tab, or in a minimized window.
    VISIBILITY_STATE_HIDDEN = 2;
  }

  // The visibility state of the web page containing the ad slots.
  // See https://www.w3.org/TR/page-visibility/.
  optional VisibilityState page_visibility = 66 [default =
    VISIBILITY_STATE_UNKNOWN];

  // Information about a browser window's user activation state. See
  // https://html.spec.whatwg.org/multipage/interaction.html#the-useractivation-interface
  message UserActivation {
    // Indicates whether a user has completed an interaction since page load.
    optional bool has_been_active = 1;

    // Indicates whether a user is currently interacting with the page.
    optional bool is_active = 2;
  }

  // User activation information from the browser for the current request, if
  // the request is for a web page.
  optional UserActivation user_activation = 76;

  // The set of possible web navigation types that predicate a page load. Each
  // of these types may have different performance characteristics. For example,
  // users going back and forth might experience a faster site than users
  // performing navigation for the first time or submitting forms. See
  // https://w3c.github.io/navigation-timing/#dom-performancenavigationtiming-type.
  enum NavigationType {
    NAVIGATION_TYPE_UNKNOWN = 0;

    // Navigation started by clicking a link, entering the URL in the browser's
    // address bar, form submission, or initializing through a script operation
    // other than reload and back_forward.
    NAVIGATION_TYPE_NAVIGATE = 1;

    // Navigation is through the browser's reload operation, location.reload(),
    // or a Refresh pragma directive like
    // <meta http-equiv="refresh" content="300">.
    NAVIGATION_TYPE_RELOAD = 2;

    // Navigation is through the browser's history traversal operation.
    NAVIGATION_TYPE_BACK_FORWARD = 3;

    // Navigation is initiated by a prerender hint (deprecated). See
    // https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/rel/prerender.
    NAVIGATION_TYPE_PRERENDER = 4;
  }

  // The type of browser navigation that led to the current page. Unset for
  // non-web ad requests.
  optional NavigationType navigation_type = 77;

  // -----------------------------------------------------------
  // Information about the adslots on the page.
  message AdSlot {
    // An arbitrarily assigned slot id that is unique on a given page and
    // usually starts counting from 1. You use this to identify which slot to
    // bid on in the BidResponse.
    required int32 id = 1;

    // A stable identifier for the combination of publisher, ad slot, and page.
    optional uint64 ad_block_key = 14;

    // The width and height in pixels of the allowed ad sizes. Most requests
    // allow only a single size, but some allow more than one. Widths and
    // heights are at the same index. For example, if the width values are
    // [728, 300, 468] and the height values are [90, 250, 60], then the allowed
    // formats are 728x90, 300x250, and 468x60.
    //
    // For VAST video ad requests a single width/height pair specifies the
    // Google-detected video player size. If Google cannot detect the player
    // size the publisher-provided player size, if available, is used. For
    // VAST video ads, this size is informational; there is no restriction on
    // the size of the video ad that you can return.
    //
    // For mobile interstitial ads (including ones where video ads are eligible)
    // the first width height pair is the slot size (this is also the video
    // player size for VAST video ads). For many interstitials, this is the
    // screen size. Subsequent pairs are recommended interstitial ad sizes that
    // also meet the requirements for this interstitial.
    repeated int32 width = 2;
    repeated int32 height = 3;

    message FlexibleAdSlotSettings {
      optional int32 max_width = 1;
      optional int32 max_height = 2;
      optional int32 min_width = 3;
      optional int32 min_height = 4;
    }

    // If the adslot is flexible, this contains settings on how the slot
    // may be resized.
    optional FlexibleAdSlotSettings flexible_adslot_settings = 50;

    // The disallowed attribute ids for the ads that can show in this slot. See
    // the publisher-excludable-creative-attributes.txt file in the technical
    // documentation for a list of ids.
    repeated int32 excluded_attribute = 4 [packed = true];

    // The allowed vendor types. See the vendors.txt file in the technical
    // documentation for a list of ids. This field does not apply to deals with
    // block overrides (see
    // https://support.google.com/authorizedbuyers/answer/6114194).
    repeated int32 allowed_vendor_type = 6 [packed = true];

    message ConsentedProvidersSettings {
      // Set of IDs corresponding to ad tech providers (ATPs) for whom the
      // publisher has specified to Google that its EEA users have given legally
      // valid consent to: 1) the use of cookies or other local storage where
      // legally required; and 2) the collection, sharing, and use of personal
      // data for personalization of ads by an ATP in accordance with Google's
      // EU User Consent Policy.
      //
      // If a publisher is using the IAB Transparency and Consent Framework
      // (TCF) v2 to manage user consent, this is the set of ATPs consented
      // through the Additional Consent string (see
      // https://support.google.com/admanager/answer/9681920 for details about
      // Google's Additional Consent mode). ATPs consented through the TCF v2
      // consent string are represented in the
      // ConsentedProvidersSettings.tcf_consent_string field.
      //
      // A mapping of ATP ID to ATP name is posted at providers.csv.
      repeated int64 consented_providers = 2 [packed = true];

      // The web-safe base64-encoded IAB Transparency and Consent Framework
      // (TCF) v2 consent string fetched from the publisher's IAB Consent
      // Management Platform (CMP). The structure of the string is defined by
      // the IAB TCF v2. This field will be populated if the publisher has
      // integrated with a CMP for TCF v2 and that CMP indicates that GDPR
      // applies to this ad request and provides a valid consent string. See
      // https://support.google.com/authorizedbuyers/answer/9789378 for
      // additional information about the Google TCF v2 integration.
      //
      // See the IAB Global Vendor List at
      // https://vendor-list.consensu.org/v2/vendor-list.json for details about
      // the vendors listed in the consent string.
      optional string tcf_consent_string = 3;

      // The raw Additional Consent string, which contains a list of certain
      // Google Ad Tech Providers (ATPs). These ATPs are not registered with IAB
      // TCF v2, but publishers or their Consent Management Providers (CMPs)
      // have ensured that certain disclosures are given to, and consents are
      // obtained from, end users, as required by Google's EU User Consent
      // Policy. This field is only populated with the use of CMPs that are
      // integrated with IAB TCF v2. Such CMPs use the raw Additional Consent
      // string to indicate vendors that are not registered with IAB, and
      // communicate end users' CMP choices to those vendors. The
      // consented_providers field contains the set of vendors that mirrors the
      // one represented by the additional_consent_string field, which is in the
      // raw form. Vendors or any other third-party service providers must not
      // create AC strings themselves.
      //
      // See https://support.google.com/admanager/answer/9681920 for more
      // details about this field.
      optional string additional_consent_string = 4;
    }

    // Information about the ad tech providers for whom the publisher has
    // specified to Google that its EEA user has consented to the use of their
    // personal data for ads personalization in accordance with Google's EU User
    // Consent Policy. This field will only be populated when regs_gdpr is true.
    optional ConsentedProvidersSettings consented_providers_settings = 42;

    // This field will be set to true in either of the two following cases:
    //   1. Google receives a valid IAB Transparency and Consent Framework (TCF)
    //      v2 consent string and the Consent Management Platform indicates that
    //      GDPR applies to this ad request.
    //   2. Google does not receive an IAB TCF v2 consent string and, based on
    //      information available to Google, this impression will serve to an
    //      EEA user.
    // It does not constitute legal guidance on GDPR. This field is equivalent
    // to Regs.ext.gdpr in Google OpenRTB.
    optional bool regs_gdpr = 43;

    // This field will be set to true when, based on information available to
    // Google, this impression will serve to a user in Brazil. See
    // https://storage.googleapis.com/adx-rtb-dictionaries/lgpd-providers.csv
    // for the list of ad tech providers that are allowed to
    // serve on LGPD-enforced requests.
    //
    // See https://support.google.com/authorizedbuyers/answer/9928204 for more
    // information on LGPD.
    optional bool regs_lgpd = 54;

    // Contains the Global Privacy Platform's consent string. See the Global
    // Privacy Platform specification for more details:
    // https://github.com/InteractiveAdvertisingBureau/Global-Privacy-Platform
    optional string gpp_consent_string = 81;

    // Array of the section(s) of the GPP string which should be applied for
    // this transaction. Generally will contain one and only one value, but
    // there are edge cases (e.g. a CMP cannot determine a single section ID)
    // where more than one may apply. GPP Section 3 (Header) and 4 (Signal
    // Integrity) do not need to be included. See IAB-GPP spec for details:
    // https://github.com/InteractiveAdvertisingBureau/Global-Privacy-Platform/blob/main/Sections/Section%20Information.md#section-ids
    repeated int32 gpp_section_ids = 82 [packed = true];

    // The disallowed sensitive ad categories. See the
    // ad-sensitive-categories.txt file in the technical documentation for a
    // list of ids. You should enforce these exclusions if you have the ability
    // to classify ads into the listed categories. This field does not apply to
    // deals with block overrides (see
    // https://support.google.com/authorizedbuyers/answer/6114194).
    repeated int32 excluded_sensitive_category = 7 [packed = true];

    // The allowed restricted ad categories for private and open auctions. See
    // the ad-restricted-categories.txt file in the technical documentation for
    // a list of ids. These only apply for private and open auction bids. See
    // the allowed_restricted_category_for_deals field for preferred deals or
    // programmatic guarantees. If you bid with an ad in a restricted category,
    // you MUST ALWAYS declare the category in the bid response regardless of
    // the values in this field.
    repeated int32 allowed_restricted_category = 16 [packed = true];

    // The allowed restricted ad categories for preferred deals or programmatic
    // guarantees. See the ad-restricted-categories.txt file in the technical
    // documentation for a list of ids. These only apply for preferred deals or
    // programmatic guarantees. See the allowed_restricted_category field for
    // private and open auctions. In some cases, restricted categories are only
    // allowed on preferred deals or programmatic guarantees, so this field
    // lists all categories in allowed_restricted_category, and additionally,
    // restricted categories that are only allowed for preferred deals or
    // programmatic guarantees. If you bid with an ad in a restricted category,
    // you MUST ALWAYS declare the category in the bid response regardless of
    // the values in this field.
    repeated int32 allowed_restricted_category_for_deals = 22 [packed = true];

    // List of creative languages allowed by the publisher. The order is
    // arbitrary. The codes are 2 or 5 characters and are documented at
    // https://developers.google.com/google-ads/api/data/codes-formats#languages.
    // When not set, all languages are allowed.
    repeated string allowed_languages = 27;

    // The disallowed ad product categories. See the ad-product-categories.txt
    // file in the technical documentation for a list of ids. You should enforce
    // these exclusions if you have the ability to classify ads into the listed
    // categories. This field does not apply to deals with block overrides (see
    // https://support.google.com/authorizedbuyers/answer/6114194).
    repeated int32 excluded_product_category = 13 [packed = true];

    // Block list of applications by their platform-specific exchange
    // independent application identifiers. On Android, these should
    // be bundle or package names (for example, com.foo.mygame).
    // On iOS, these are numeric IDs.
    // Bids with ads that advertise any app from this list will be filtered
    // out before the auction.
    repeated string excluded_app_ids = 66;

    // A creative that is disallowed to bid on this impression due to Ad
    // Exchange policies or creative disapproval, excluded creative attributes,
    // excluded product or sensitive categories, allowed vendor types,
    // restricted categories or languages applicable to the bid request.
    message ExcludedCreative {
      // Buyer creative ID of the disallowed creative.
      optional string buyer_creative_id = 1;
    }

    // Creatives that are disallowed for the impression. Submitting a bid with
    // one of the creatives in this list will result in such bid being filtered
    // before the auction. Contact your account manager if you would like
    // to enable this feature.
    repeated ExcludedCreative excluded_creatives = 18;

    // Whether the adslot is only eligible for deals bids. Bids for the open
    // auction will be filtered when this field is set to true. Bidders can bid
    // on the open auction or deals when this field is set to false.
    optional bool only_deal_bids_accepted = 49;

    // Information about the pre-targeting configs that matched.
    message MatchingAdData {
      // The billing ids corresponding to the pretargeting configs that matched.
      repeated int64 billing_id = 2 [packed = false];

      // The minimum CPM value that you can bid to not be filtered before the
      // auction. This may be a global minimum, or it may be a minimum set by
      // the publisher. The value is in micros of the bidding currency.
      // The bidding currency is determined by:
      // 1. The bidder-level currency, if configured.
      // 2. Otherwise, the currency of the buyer accounts indicated by the
      // billing IDs in the billing_id field.
      optional int64 minimum_cpm_micros = 5;

      // Information about any deals that matched for this inventory.
      message DirectDeal {
        // An id identifying the deal.
        optional int64 direct_deal_id = 1;

        // For deal_type=PREFERRED_DEAL or deal_type=PROGRAMMATIC_GUARANTEED,
        // you must bid at least fixed_cpm_micros (in micros of the bidding
        // currency) in order to participate in the deal. If you win, you will
        // be charged fixed_cpm_micros. For deal_type=PRIVATE_AUCTION or
        // deal_type=AUCTION_PACKAGE or deal_type=MARKETPLACE_PACKAGE, you must
        // bid at least fixed_cpm_micros. Bidding higher CPM than
        // fixed_cpm_micros will increase your chance to win when
        // deal_type=PRIVATE_AUCTION or deal_type=AUCTION_PACKAGE or
        // deal_type=MARKETPLACE_PACKAGE, however it will not increase your
        // chance to win for other types of deals. The bidding currency is
        // determined by:
        // 1. The bidder-level currency, if configured.
        // 2. Otherwise, the currency of the buyer accounts indicated by the
        // billing IDs in the billing_id field.
        optional int64 fixed_cpm_micros = 2;

        // The type of the deal. Note that Authorized Buyers policy overrides
        // apply to all Programmatic Guaranteed and Preferred Deal bids, and do
        // not apply to bids for other deal types.
        enum DealType {
          UNKNOWN_DEAL_TYPE = 0;

          // Bids are fixed-price and evaluated before the Open Auction. Bidders
          // are not required to bid with Preferred Deals when they are present
          // on the bid request. See
          // https://support.google.com/authorizedbuyers/answer/2604595 for more
          // information.
          PREFERRED_DEAL = 1;

          // Bids participate in a Private Auction against a select list of
          // buyers with specific floors. See
          // https://support.google.com/authorizedbuyers/answer/2839853 for more
          // information.
          PRIVATE_AUCTION = 2;

          // Bids are fixed-price and evaluated before the Open Auction. Bidders
          // are expected to bid with Programmatic Guaranteed deals whenever
          // they are present on a bid request in order to ensure that the
          // number of impressions agreed upon for a given deal are served. See
          // https://support.google.com/authorizedbuyers/answer/7174589 for more
          // information.
          PROGRAMMATIC_GUARANTEED = 3;

          // The deal ID is an identifier for a collection of Open Auction
          // inventory matching a given set of targeting criteria. See
          // https://support.google.com/authorizedbuyers/answer/7516884 for more
          // information.
          AUCTION_PACKAGE = 4;

          // Package of inventory that a publisher makes available to either all
          // buyers or selected bidders. Bids participate in auction in the same
          // way as private auction candidates. See
          // https://support.google.com/authorizedbuyers/answer/12817370 for
          // more information.
          MARKETPLACE_PACKAGE = 5;
        }
        optional DealType deal_type = 3 [default = UNKNOWN_DEAL_TYPE];

        // Whether the publisher has exempted this deal from configured blocks.
        // This setting does not override AdX policies or Ad Review Center
        // decisions.
        optional bool publisher_blocks_overridden = 4 [default = false];

        // Experimental field; subject to change.
        // An enum declaring the host of the creative, which will only be
        // populated for Programmatic Guaranteed deals.
        // Currently, this field should only ever be set to
        // CREATIVE_SOURCE_ADVERTISER.
        enum CreativeSourceType {
          CREATIVE_SOURCE_UNKNOWN = 0;

          // The creative is hosted by the advertiser, which means the bidder
          // is required to provide a creative in the bid response.
          CREATIVE_SOURCE_ADVERTISER = 1;

          // The creative is hosted by the publisher, which means the bidder
          // does not need to include a creative in the bid response.
          // For more information on publisher-hosted creatives, see
          // https://support.google.com/admanager/answer/9243220.
          // This feature isn't currently supported for RTB bidders.
          CREATIVE_SOURCE_PUBLISHER = 2;
        }
        optional CreativeSourceType creative_source = 16 [default =
          CREATIVE_SOURCE_ADVERTISER];

        // This field is only applicable to Programmatic Guaranteed deals. The
        // buyer is allowed to skip bidding on the impression if this field is
        // false. When it is true, the buyer is required to bid on this deal for
        // this impression opportunity.
        optional bool must_bid = 9 [default = true];

        // Constraints for creatives that can apply when bidding on a deal.
        message CreativeConstraints {
          // The allowed ad types of the deal. If empty, there are no
          // deal-specific allowed ad type restrictions for the deal. In that
          // case, bidders should refer to the BidRequest-level creative types
          // in adslot.allowed_ad_types.
          repeated AllowedAdType allowed_ad_types = 1 [packed = true];

          // Whether skippable creatives are allowed. For
          // PROGRAMMATIC_GUARANTEED or PREFERRED_DEAL deals that specifically
          // allow video or audio ad types, it is always set. For the
          // skippability setting of other deal types or open auction bidding,
          // refer to the corresponding BidRequest-level field
          // video.video_ad_skippable.
          optional Video.SkippableBidRequestType video_ad_skippable = 2 [default
            = ALLOW_SKIPPABLE];

          // The maximum allowed duration in milliseconds for the ad. For
          // PROGRAMMATIC_GUARANTEED or PREFERRED_DEAL deals that specifically
          // allow video or audio ad types, it is always set. For the allowed
          // max duration of other deal types or open auction bidding, refer to
          // the corresponding BidRequest-level field video.max_ad_duration.
          optional int32 max_ad_duration_ms = 3;
        }

        // Creative constraints for this deal. If this is not set, bidders
        // should refer to the BidRequest-level setting of each field.
        optional CreativeConstraints creative_constraints = 17;

        // If non-empty, this field contains a list of seat IDs in the bidder's
        // namespace set by media planners that are allowed by the publisher to
        // bid on this deal. All seat IDs not included in this list are blocked
        // from bidding on this deal. Bids on this deal on behalf of other
        // seats, as indicated by the BidResponse.ad.adslot.seat_id field, and
        // bids with no seat ID will be filtered before the auction. If this
        // field is empty, there are no restrictions on the seat IDs that can
        // bid on this deal.
        repeated string allowed_seat_ids = 18;
      }
      repeated DirectDeal direct_deal = 6;
    }
    repeated MatchingAdData matching_ad_data = 9;

    // If non-empty, this field contains a list of seat IDs in the bidder's
    // namespace set by media planners that are blocked by the publisher. Any
    // bids on behalf of a blocked seat, as indicated by the
    // BidResponse.ad.adslot.seat_id field, will be filtered before the auction.
    // If this field is non-empty, allowed_seat_ids will be empty. If this field
    // and allowed_seat_ids are both empty, there are no seat ID restrictions
    // for this request.
    repeated string blocked_seat_ids = 67;

    // If non-empty, this field contains a list of seat IDs in the bidder's
    // namespace set by media planners that are allowed by the publisher. All
    // seat IDs not included in this list are blocked. Bids on behalf of other
    // seats, as indicated by the BidResponse.ad.adslot.seat_id field, and bids
    // with no seat ID will be filtered before the auction. If this field is
    // non-empty, blocked_seat_ids will be empty. If this field and
    // blocked_seat_ids are both empty, there are no seat ID restrictions for
    // this request.
    repeated string allowed_seat_ids = 68;

    // The publisher settings list ids that apply to this slot. See the RTB
    // Publisher Settings guide at
    // https://developers.google.com/authorized-buyers/rtb/pub-settings-guide
    // for details.
    repeated fixed64 publisher_settings_list_id = 15;

    // Parameters related to exchange bidding (third party exchanges doing
    // real-time bidding on DFP). This is never populated in calls to AdX
    // real-time bidders.
    message ExchangeBidding {
      // Repeated KeyValue pairs to be sent from the publisher to the
      // exchange bidder.
      repeated KeyValue key_value = 3;
    }
    optional ExchangeBidding exchange_bidding = 28;

    // Parameters related to Open Bidding.
    message OpenBidding {
      // This field is set to true if the publisher set up a yield group or a
      // mediation group that targets this adslot and this bidder. See
      // https://support.google.com/admanager/answer/7128453 for information on
      // Open Bidding and its effects on the bidding process.
      optional bool is_open_bidding = 2;
    }
    optional OpenBidding open_bidding = 53;

    // AdUnitMapping is used to identify publisher inventory units in the
    // bidder's namespace. The mappings are only populated when
    // the bidder works directly with a publisher, and provides the mapping
    // from Google's ad unit namespace to the bidder's inventory namespace.
    // The ad unit mapping is only applicable for requests that use a custom
    // SDK. https://support.google.com/admanager/answer/9601810.
    message AdUnitMapping {
      // Key-value pair used to specify the inventory unit in the bidder's
      // namespace.
      message Keyval {
        // The key is the name of the bidder's inventory unit identifier for the
        // SDK.
        optional string key = 1;

        // The value of the bidder's inventory unit identifier for the given
        // format.
        optional string value = 2;
      }

      // Multiple key-value pairs can be specified in order to support
      // bidders whose inventory unit space is hierarchical and has multiple
      // identifiers. The key-value pairs for the chosen AdUnitMapping should be
      // sent back in the bid response as
      // BidResponse.ad.sdk_rendered_ad.sdk_params. This is passed to the
      // bidder's SDK.
      repeated Keyval keyvals = 1;

      // Possible ad unit formats that can be used for the mapping. Corresponds
      // to the adapter that will be used on the SDK.
      enum FormatType {
        FORMAT_UNKNOWN = 0;

        // Display banner ads for web or mobile apps. For example, a 320x50
        // leaderboard slot. This includes out-stream video.
        FORMAT_BANNER = 1;

        // A full-screen ad to be displayed inside a mobile app.
        FORMAT_INTERSTITIAL = 2;

        // Custom display or video ads for web or mobile apps that match the
        // user experience of the site or app in which they’re placed.
        FORMAT_NATIVE = 3;

        // Video ads that appear before, during, or after video content
        // streams.
        FORMAT_VIDEO_VAST = 4;

        // Video ads for mobile apps that allow users to voluntarily watch an
        // ad in exchange for an in-app reward.
        FORMAT_REWARDED = 5;

        // Interstitial ads that allow users to watch an ad in exchange for
        // an in-app reward. Does not require opt-in.
        // https://support.google.com/admanager/answer/7386053
        FORMAT_REWARDED_INTERSTITIAL = 6;

        // App open ads shows at app load screens. App open ads can be closed
        // at any time, and are designed to be shown when the users bring the
        // app to the foreground.
        FORMAT_APP_OPEN = 7;
      }

      // The mappings are targeted through a format, which is expressed in the
      // Google-defined taxonomy. Format is populated in the bid request since
      // Google supports targeting multiple formats with a single ad
      // unit, and Google's definition of the format may not match the bidder's
      // definition. In order for the bidder to differentiate which format
      // matched, it is sent in the bid request.
      optional FormatType format = 2;
    }

    // Ad unit mappings that match the given adslot.
    repeated AdUnitMapping ad_unit_mapping = 64;

    // Indicates the creative policy and publisher blocks that applies to this
    // request.
    message CreativeEnforcementSettings {
      // Creative policy enforcement level that applies to this request.
      // Creatives that don't adhere to the specified policy will be filtered
      // before the auction. The status of the creatives with their respective
      // policies can be retrieved through Creative API.
      // https://developers.google.com/authorized-buyers/apis/guides/rtb-api/creatives
      // Bids on deals may override the policy enforcement applicable to the
      // request.
      enum PolicyEnforcement {
        POLICY_ENFORCEMENT_UNKNOWN = 0;

        // Baseline policy for all ads serving through any of Google's ads
        // platform products. Learn more at:
        // https://support.google.com/platformspolicy/answer/3013851.
        POLICY_ENFORCEMENT_PLATFORM_POLICY = 1;

        // Policy for ads serving through Google's ad network. This includes the
        // baseline policy for all ads serving through any of Google's ads
        // platform products. Learn more at:
        // https://support.google.com/authorizedbuyers/answer/1325008.
        POLICY_ENFORCEMENT_NETWORK_AND_PLATFORM_POLICY = 2;
      }
      optional PolicyEnforcement policy_enforcement = 1;

      // Creative publisher blocks enforcement level that applies to this
      // request. Publisher blocks allow publishers to control which creatives
      // can be shown on their properties.
      // Deals may also override publisher blocks. Refer to adslot.
      // matching_ad_data.direct_deal.publisher_blocks_overridden field.
      enum PublisherBlocksEnforcement {
        PUBLISHER_BLOCKS_ENFORCEMENT_UNKNOWN = 0;

        // The publisher's blocking controls are enforced on creatives
        // submitted. Publisher blocks enforcement settings are provided in the
        // following fields:
        // - publisher_settings_list_id
        // - excluded_sensitive_category
        // - allowed_restricted_category
        // - excluded_product_category
        // - allowed_vendor_type
        // - excluded_attribute
        PUBLISHER_BLOCKS_ENFORCEMENT_APPLIES = 1;

        // The publisher's blocking controls are not enforced on creatives
        // submitted.
        PUBLISHER_BLOCKS_ENFORCEMENT_OVERRIDDEN = 2;
      }
      optional PublisherBlocksEnforcement publisher_blocks_enforcement = 3;
    }
    optional CreativeEnforcementSettings creative_enforcement_settings = 58;

    // The ad unit code (https://support.google.com/admanager/topic/4426071)
    // This is currently only set for exchange bidding requests.
    optional string dfp_ad_unit_code = 33;

    // Visibility information for the slot.
    enum SlotVisibility {
      NO_DETECTION = 0;
      ABOVE_THE_FOLD = 1;
      BELOW_THE_FOLD = 2;
    }
    optional SlotVisibility slot_visibility = 12 [default = NO_DETECTION];

    // Viewability percentage for the ad slot. This is an estimate of the
    // likelihood that this slot will be viewable by the end user based on
    // historical and environment data. It is expressed as a percentage in the
    // range of [0, 100]. The default value -1 indicates that viewability could
    // not be estimated.
    optional int32 viewability = 21 [default = -1];

    // Historical click-through rate for ads served in the ad slot. This is
    // expressed as a fraction in the range [0.0, 1.0]. The default value of
    // -1.0 indicates that historical click-through rate data is not available.
    // This figure does not include data aggregated from Google Ads. The
    // click-through rate can vary for a given ad slot throughout the day.
    optional float click_through_rate = 25 [default = -1];

    // Historical completion rate for video ads served in the ad slot. This is
    // expressed as a fraction in the range [0.0, 1.0]. The default value of
    // -1.0 indicates that historical completion rate data is not available.
    // This field is only applicable to video inventory, and does not include
    // data aggregated from Google Ads.
    optional float video_completion_rate = 30 [default = -1];

    // iFraming state of the ad slot on the webpage where it is present.
    enum IFramingState {
      UNKNOWN_IFRAME_STATE = 0;
      NO_IFRAME = 1;
      SAME_DOMAIN_IFRAME = 2;
      CROSS_DOMAIN_IFRAME = 3;
    }
    optional IFramingState iframing_state = 19 [default = UNKNOWN_IFRAME_STATE];

    // iFrame depth of the ad slot on the webpage where it is present.
    // Currently only set for video ad requests.
    enum IFramingDepth {
      UNKNOWN_IFRAME_DEPTH = 0;
      NOT_IN_IFRAME = 1;
      ONE_IFRAME = 2;
      MULTIPLE_IFRAME = 3;
    }
    optional IFramingDepth iframing_depth = 20 [default = UNKNOWN_IFRAME_DEPTH];

    // A native ad consists of pieces that are rendered by the publisher. A
    // publisher may support multiple distinct native ad templates. If the
    // request also allows banners or videos, you can respond with other types
    // of ads by setting html_snippet or video_url instead. If only native
    // templates exist, you must set the native_ad field in any response you
    // send.
    message NativeAdTemplate {
      // Bitfield describing which fields are required by the publisher. Bid
      // responses with no value for these fields will be rejected. Click and
      // view tracking urls are always implicitly required.
      optional int64 required_fields = 1;

      // Bitfield describing which fields are recommended by the publisher. All
      // recommended fields are supported, but not all recommended fields are
      // required.
      optional int64 recommended_fields = 2;

      // max_safe_length indicates the maximum number of Unicode characters that
      // are guaranteed to be shown without truncation. Longer strings may be
      // truncated and ellipsized by Ad Exchange or the publisher during
      // rendering.
      optional int32 headline_max_safe_length = 3;
      optional int32 body_max_safe_length = 4;
      optional int32 call_to_action_max_safe_length = 5;
      optional int32 advertiser_max_safe_length = 6;
      optional int32 price_max_safe_length = 15;

      // The width and height from which to calculate the required aspect ratio.
      // You can provide a larger image in the response. Images that have aspect
      // ratios substantially different than those implied by the height and
      // width may be filtered.
      optional int32 image_width = 7;
      optional int32 image_height = 8;
      optional int32 logo_width = 9;
      optional int32 logo_height = 10;
      optional int32 app_icon_width = 11;
      optional int32 app_icon_height = 12;

      // Globally distinct id for the specific style, HTML, and CSS with which
      // the native ad is rendered.
      optional int32 style_id = 16;

      // Type of style layout for each native ad template.
      enum LayoutType {
        PIXEL = 0;
        FLUID = 1;
      }
      optional LayoutType style_layout_type = 17 [default = PIXEL];

      // If the style_layout_type is Pixel, width and height of the
      // entire native ad after rendering. If the style_layout_type is
      // Fluid, the style_height and style_width may optionally
      // not be populated.
      optional int32 style_height = 18;
      optional int32 style_width = 19;

      // Defines the bits used in required_fields and recommended_fields. There
      // is one bit for each of the fields in BidResponse.Ad.NativeAd
      enum Fields {
        NO_FIELDS = 0;
        HEADLINE = 1;
        BODY = 2;
        CALL_TO_ACTION = 4;
        ADVERTISER = 8;
        IMAGE = 16;
        LOGO = 32;
        APP_ICON = 64;
        STAR_RATING = 128;
        PRICE = 256;
        DEPRECATED_STORE = 512;
        VIDEO = 1024;
      }
    }
    repeated NativeAdTemplate native_ad_template = 51;

    // NativePlacementType describes placement of native ad slot with respect to
    // surrounding context.
    enum NativePlacementType {
      PLACEMENT_UNKNOWN = 0;

      // In the feed of content - for example as an item inside the organic
      // feed/grid/listing/carousel.
      PLACEMENT_IN_FEED = 1;

      // In the atomic unit of the content - for example, in the article page or
      // single image page.
      PLACEMENT_ATOMIC_UNIT = 2;

      // Outside the core content - for example in the ads section on the right
      // rail, as a banner-style placement near the content, or another
      // placement type.
      PLACEMENT_OUTSIDE = 3;

      // Recommendation widget, most commonly presented below the article
      // content.
      PLACEMENT_RECOMMENDATION = 4;
    }
    optional NativePlacementType native_placement_type = 45 [default =
      PLACEMENT_UNKNOWN];

    // Whether the ad request has been determined to come directly from the
    // publisher.
    enum MediationStatus {
      UNKNOWN = 0;
      DIRECT_REQUEST = 1;
    }
    optional MediationStatus mediation_status = 52 [default = UNKNOWN];

    // Auto refresh settings.
    message AutoRefresh {

      message AutoRefreshSettings {
        enum AutoRefreshType {
          UNKNOWN_AUTO_REFRESH_TYPE = 0;

          // Refresh triggered by user-initiated action such
          // as scrolling.
          USER_ACTION = 1;

          // Event-driven content change. For example, ads refresh
          // when the football game score changes on the page.
          EVENT = 2;

          // Time-based refresh. Ads refresh on a predefined time
          // interval even without user activity.
          TIME = 3;
        }

        // The type of the declared auto refresh.
        optional AutoRefreshType refresh_type = 1 [default =
          UNKNOWN_AUTO_REFRESH_TYPE];

        // The minimum refresh interval. This applies to all refresh types.
        optional int32 min_refresh_interval_seconds = 2;
      }

      // The auto-refresh settings that the publisher has on this
      // inventory. This is repeated because publishers may
      // do multiple types of auto refresh on one piece of inventory.
      repeated AutoRefreshSettings refresh_settings = 1;

      // The number of times this ad slot had been refreshed since last page
      // load.
      optional int32 refresh_count = 2 [default = 0];
    }
    optional AutoRefresh auto_refresh = 23;

    // Stickiness settings declared by the publisher.
    message StickySettings {
      // Specifies the allowable sticky settings values.
      enum Stickiness {
        UNKNOWN_STICKINESS = 0;
        IS_STICKY = 1;
      }

      // Whether the ad slot is a sidebar that sticks on screen when user
      // scrolls.
      optional Stickiness vertical_stickiness = 1 [default =
        UNKNOWN_STICKINESS];

      // Whether the ad slot is a horizontal slot that sticks on the top of the
      // screen when user scrolls.
      optional Stickiness top_horizontal_stickiness = 2 [default =
        UNKNOWN_STICKINESS];

      // Whether the ad slot is a horizontal slot that sticks on the bottom of
      // the screen when user scrolls.
      optional Stickiness bottom_horizontal_stickiness = 3 [default =
        UNKNOWN_STICKINESS];
    }
    optional StickySettings sticky_settings = 31;

    // Sources for non-browser inventory.
    enum NonBrowserSource {
      UNDECLARED_SOURCE = 0;
      DESKTOP_APP = 1;
    }

    // Publisher declaration stating that this ad slot may serve on
    // non-browser inventory, like desktop apps.
    optional NonBrowserSource non_browser_slot_source = 34 [default =
      UNDECLARED_SOURCE];

    // Defines who controls the environment that made the ad request and will
    // render the ad. On platforms where code written by Google will handle
    // the ad this field is set to GOOGLE. When this field is PUBLISHER the
    // publisher has placed their own code on the device to handle playback of
    // the ad. There is no technical difference in how these request are
    // handled. You may use this field to differentiate between different
    // environments for non-technical reasons. This field is only set for
    // requests that allow VAST video ads.
    enum Renderer {
      UNKNOWN_RENDERER = 0;
      GOOGLE = 1;
      PUBLISHER = 2;
    }
    optional Renderer renderer = 26 [default = UNKNOWN_RENDERER];

    // Whether this request is for an Accelerated Mobile Page (AMP). AMP HTML
    // pages load faster, by restricting parts of HTML, CSS and Javascript. For
    // more information on how AMP ads render, refer to the AMP ads README:
    // https://github.com/ampproject/amphtml/blob/master/ads/README.md
    enum AmpAdRequestType {
      // AMP status unknown. Request may or may not be from an AMP page.
      UNKNOWN_AMP = 0;

      // Not an AMP page. Could be regular HTML, VAST video, or other context.
      NON_AMP_PAGE = 1;

      // Late-loading request from an AMP HTML page. Ad will render with a
      // slight delay so it will not negatively impact page render performance.
      AMP_PAGE_LATE_REQUEST = 2;
    }
    optional AmpAdRequestType amp_ad_request_type = 29 [default = NON_AMP_PAGE];

    // Whether this is an AMP page or not.
    enum AmpPage {
      // AMP page status unknown.
      UNKNOWN_AMP_PAGE = 0;

      // This is not an AMP page.
      DIALECT_HTML = 1;

      // This is an Amp page.
      DIALECT_HTML_AMP = 2;
    }
    optional AmpPage is_amp_page = 38;

    // Possible requirement types for AMP ads.
    enum AmpAdRequirementType {
      // AMP ad requirements unknown.
      UNKNOWN_AMP_AD_REQUIREMENT_TYPE = 0;

      // AMP ads are not allowed.
      AMP_AD_NOT_ALLOWED = 1;

      // Either AMP ads or non-AMP ads are allowed;
      // AMP ads are not early rendered.
      AMP_AD_ALLOWED_AND_NOT_EARLY_RENDERED = 2;

      // Either AMP ads or non-AMP ads are allowed;
      // AMP ads are early rendered.
      AMP_AD_ALLOWED_AND_EARLY_RENDERED = 3;

      // AMP ads are required.
      // Ads that are non-AMP may be rejected by the publisher.
      AMP_AD_REQUIRED = 4;
    }
    optional AmpAdRequirementType amp_ad_requirement_type = 39;

    // Whether the user receives a reward for viewing the ad. For video ads,
    // typical implementations allow users to read an additional news article
    // for free, receive an extra life in a game, or get a sponsored ad-free
    // music session. The reward is typically distributed after the video ad is
    // completed.
    optional bool is_rewarded = 32 [default = false];

    // Possible ad types that are allowed in the bid response. allowed_ad_types
    // always contains one or more values. Interstitial slots may also support
    // banner ads. An ad slot with ALLOWED_AD_TYPE_NATIVE may or may not support
    // native video, regardless of whether ALLOWED_AD_TYPE_VIDEO is set.
    // Likewise, an ad slot without ALLOWED_AD_TYPE_NATIVE does not support
    // native video, regardless of whether ALLOWED_AD_TYPE_VIDEO is set.
    enum AllowedAdType {
      UNKNOWN_ALLOWED_AD_TYPE = -1;
      ALLOWED_AD_TYPE_BANNER = 0;
      ALLOWED_AD_TYPE_NATIVE = 1;
      ALLOWED_AD_TYPE_VIDEO = 2;
      ALLOWED_AD_TYPE_AUDIO = 3;
    }
    repeated AllowedAdType allowed_ad_types = 36 [packed = true];

    // Total number of impressions served to this user (within this specific
    // site or app) in this browsing session, plus 1. A session ends after 30
    // minutes inactivity. The default value of -1 indicates that the session
    // depth cannot be estimated.
    optional int32 session_depth = 40 [default = -1];

    // Secure signals passed by the publisher.
    message SecureSignal {
      // The source (provider) of the signal. Identifier for the library or SDK
      // that generated this data.
      optional string source = 4;

      // The secure signal.
      optional string data = 2;
    }
    repeated SecureSignal secure_signals = 41;

    // Possible ad rendering API frameworks that can be supported.
    // If an API is not explicitly listed, it is assumed not to be supported.
    enum APIFramework {
      UNKNOWN_FRAMEWORK = 0;

      // Mobile Rich Media Ad Interface Definitions Version 1.0. See
      // https://www.iab.com/guidelines/mraid/.
      MRAID_1 = 3;

      // Mobile Rich Media Ad Interface Definitions Version 2.0. See
      // https://www.iab.com/guidelines/mraid/.
      MRAID_2 = 5;

      // Mobile Rich Media Ad Interface Definitions Version 3.0. See
      // https://www.iab.com/guidelines/mraid/.
      MRAID_3 = 6;

      // Open Measurement Interface Definition Version 1.0. See
      // https://iabtechlab.com/standards/open-measurement-sdk/.
      OMID_1 = 7;
    }

    // List of supported API frameworks for this impression.
    repeated APIFramework api = 46 [packed = true];

    // Deprecated. This will be removed in Q1 2024. This field has been
    // deprecated in favor of the repeated field
    // `billable_event_rate_bid_adjustment` below.
    // For ads rendered using a custom SDK only: multiplier applied to bid in
    // the auction. The adjustment reflects the likelihood that your bid would
    // generate a billable event (meaning the ad renders successfully) if
    // it won the auction, relative to the probability that other bids generate
    // a billable event if they won the auction. This adjustment can be larger
    // or smaller than 1. This affects the final ranking in the auction only; in
    // particular, this multiplier does not affect the payment.
    optional double billable_event_rate_adjustment = 59 [deprecated = true,
      default = 1];

    // The billable event rate bid adjustment of an ad and the dependent
    // features of the ad the adjustment applies to, such as the format or the
    // SDK used to render the ad. Each feature combination may have a unique
    // adjustment, each adjustment therefore specifies which SDK or creative
    // format it applies to.
    message BillableEventRateBidAdjustment {
      // A multiplier to your bid to adjust for the likelihood that your bid
      // would result in a billable event (namely, the ad renders successfully)
      // if it won the auction, relative to the average probability that bids
      // from other buyers would result in a billable event if they won the
      // auction. This adjustment can be larger or smaller than 1. This affects
      // the final ranking in the auction only; in particular, this multiplier
      // does not affect the payment or whether the bid clears any floor price.
      optional float bid_adjustment = 1 [default = 1];

      // The types of creative the bid adjustments can apply to.
      enum CreativeType {
        CREATIVE_TYPE_UNKNOWN = 0;

        // Banner ads
        HTML_SNIPPET = 1;

        // VAST video or audio ads
        VIDEO_VAST = 2;

        // Native ads
        NATIVE = 3;

        // SDK rendered ad
        SDK_RENDERED = 4;
      }

      // The type of ads to which the above bid adjustment applies to. Each type
      // corresponds to different ways of how the ad's creative is specified, as
      // described in
      // https://developers.google.com/authorized-buyers/rtb/response-guide#specify-creative.
      // If the ad is SDK-rendered, this will be set to SDK_RENDERED regardless
      // of the actual creative type.
      optional CreativeType creative_type = 2 [default = CREATIVE_TYPE_UNKNOWN];

      // The SDK used to render the ad with. The SDK ID will match the one sent
      // in BidRequest.mobile.installed_sdk.id. This field is not set for Google
      // SDK.
      optional Mobile.InstalledSdk sdk = 3;
    }

    // A list of billable event rate bid adjustments applicable to the request
    // and the ad features associated to the adjustment. Bid adjustments are
    // listed here only if they are not equal to 1.0, which is equivalent to
    // having no adjustment. This field replaces the deprecated field
    // billable_event_rate_adjustment.
    repeated BillableEventRateBidAdjustment billable_event_rate_bid_adjustment =
      65;

    // Identifier of the OM SDK integration. For more info, see the OpenRTB
    // Advisory for Open Measurement SDK:
    // https://github.com/InteractiveAdvertisingBureau/AdCOM/blob/master/OpenRTB%20support%20for%20OMSDK.md#openrtb-and-adcom.
    optional string omidpn = 56;

    // Version of the OM SDK integration. For more info, see the OpenRTB
    // Advisory for Open Measurement SDK:
    // https://github.com/InteractiveAdvertisingBureau/AdCOM/blob/master/OpenRTB%20support%20for%20OMSDK.md#openrtb-and-adcom.
    optional string omidpv = 57;

    // Describes the environment where the ad auction is run.
    enum AuctionEnvironment {
      // The auction determining the winning ad is held server-side.
      SERVER_SIDE_AUCTION = 0;

      // The contextual auction that determines a winning contextual bid is held
      // server-side, and bidding functions are run on the device to determine
      // interest group bids. Both the winning contextual bid and interest
      // group bids are entered into a final auction held on the device to
      // select the winning ad. For more information regarding the Protected
      // Audience API, see:
      // https://github.com/WICG/turtledove and
      // https://github.com/WICG/turtledove/blob/main/FLEDGE.md
      ON_DEVICE_INTEREST_GROUP_AUCTION = 1;
    }

    // Specifies where the ad auction runs.
    // Deprecated. This will be removed in November, 2023. Use
    // supported_auction_environment instead.
    optional AuctionEnvironment auction_environment = 61 [deprecated = true,
      default = SERVER_SIDE_AUCTION];

    // The supported auction environment for this impression. For inventory
    // which does not support interest group bidding, this will always be set to
    // SERVER_SIDE_AUCTION. For inventory which does support interest group
    // bidding, this will be set to ON_DEVICE_INTEREST_GROUP_AUCTION. Note that
    // this only indicates that the interest group auction is supported, not
    // that it is guaranteed to execute. If no buyer chooses to participate in
    // the interest group auction, then the interest group auction will be
    // skipped and the winner of the contextual auction, if any, will be
    // served instead.
    optional AuctionEnvironment supported_auction_environment = 69 [default =
      SERVER_SIDE_AUCTION];

    // The expected time period when an impression can occur in seconds
    // following a winning bid. The impression may be billable only if it serves
    // within this time. To learn more about impression expiration, see the
    // following guide:
    // https://developers.google.com/authorized-buyers/rtb/billing-event-guide
    optional int32 impression_expiration_seconds = 63;

    // The name of the rendering environment, such as a mobile ads or video
    // SDK, or a publisher ad tag type. This field describes a Google SDK while
    // the installed_sdk field describes third party SDKs.
    optional string display_manager = 71;

    // Version of the rendering environment specified by the display_manager
    // field. This field describes a Google SDK while the installed_sdk field
    // describes third party SDKs.
    optional string display_manager_version = 72;
  }
  repeated AdSlot adslot = 14;

  // Feedback on bids submitted in previous responses. This is only set if
  // real-time feedback is enabled for your bidder. Contact your account
  // manager if you want to enable real-time feedback.
  message BidResponseFeedback {
    // The unique id from BidRequest.id
    optional bytes request_id = 1;

    // The index of the BidResponse_Ad if there was more than one. The index
    // starts at zero for the first creative.
    optional int32 creative_index = 2;

    // The status code for the ad. See creative-status-codes.txt in the
    // technical documentation for a list of ids.
    optional int32 creative_status_code = 3;

    // If the bid won the auction, this is the price paid in your account
    // currency. If the bid participated in the auction but was out-bid, this
    // is the CPM that should have been exceeded in order to win. This is not
    // set if the bid was filtered prior to the auction, if the publisher or
    // winning bidder has opted out of price feedback or if your account has
    // opted out of sharing winning prices with other bidders. For first-price
    // auctions, minimum_bid_to_win is populated instead of this field.
    optional int64 cpm_micros = 4;

    // The minimum bid value necessary to have won the auction, in micros of
    // your account currency. If your bid won the auction, this is the second
    // highest bid that was not filtered (including the floor price). If your
    // bid did not win the auction, this is the winning candidate's bid. This
    // field will only be populated if your bid participated in a first-price
    // auction, and will not be populated if your bid was filtered prior to the
    // auction.
    optional int64 minimum_bid_to_win = 7;

    // The minimum bid value necessary to have won the server-side component of
    // the overall auction given that there was also an interest group bidding
    // component to the overall auction which ran using the Protected Audience
    // API. The value is expressed in CPM micros of the buyer account currency.
    // The minimum bid to win for the overall auction, including bids from the
    // server-side and the on-device interest group components, is populated in
    // the minimum_bid_to_win field of the same BidResponseFeedback object.
    optional int64 server_side_component_minimum_bid_to_win = 16;

    // Billable event rate multiplier that was applied to this bid during
    // ranking. The adjustment reflects the likelihood that your bid would
    // generate a billable event (namely, the ad renders successfully) if it won
    // the auction, relative to the probability that other bids generate a
    // billable event if they won the auction. This adjustment can be larger or
    // smaller than 1. This affects the final ranking in the auction only; in
    // particular, this multiplier does not affect the payment or whether the
    // bid clears any floor price.
    optional float billable_event_rate_bid_adjustment = 15 [default = 1];

    // When a publisher uses an RTB auction and waterfall-based SDK mediation on
    // the same query, the winner of the real-time auction must also compete in
    // a mediation waterfall (which is ordered by price) to win the impression.
    // If the bid participated in the auction and there was no waterfall, the
    // value of this field is 0. If the bid participated in the auction and
    // there was a waterfall, the value of this field is a price representing a
    // sample bid from the eligible mediation networks that were higher than the
    // auction winner, weighted by expected fill rate. This field can be used
    // in conjunction with minimum_bid_to_win to train bidding models. The CPM
    // is in micros of your account currency.
    optional int64 sampled_mediation_cpm_ahead_of_auction_winner = 10;

    // Event notification token that was included in the bid response.
    optional bytes event_notification_token = 5;

    // Buyer creative ID that was included in the bid response.
    optional string buyer_creative_id = 6;

    // Possible types of bid response feedback objects.
    enum FeedbackType {
      FEEDBACK_TYPE_UNSPECIFIED = 0;

      // Feedback for a bid that was submitted on a bid response.
      BID_FEEDBACK = 1;

      // Feedback for an interest group buyer submitted on a bid response to
      // particpate in an interest group bidding component of the auction run
      // using the Protected Audience API.
      INTEREST_GROUP_BUYER_FEEDBACK = 2;
    }

    // The type of the BidResponseFeedback message. Google will send separate
    // BidResponseFeedback objects for:
    // a) Each bid submitted on a bid response
    // b) Each buyer submitted on a bid response to particpate in an interest
    // group bidding component of the auction run using the Protected Audience
    // API.
    optional FeedbackType feedback_type = 17;

    // Origin of an interest group buyer that was included in the bid response.
    // This field is populated only for feedback where a bidder opted in an
    // interest group buyer to participate in the interest group bidding
    // component of the overall auction run using the Protected Audience API.
    // To learn more about origins, see https://www.rfc-editor.org/rfc/rfc6454.
    // To learn more about interest group bidding and the Protected Audience
    // API, see
    // https://developers.google.com/authorized-buyers/rtb/fledge-origin-trial.
    optional string buyer_origin = 18;

    // The status code for the submitted interest group buyer. This field is
    // only populated in the feedback for an interest group buyer that a bidder
    // requested to enter into the interest group auction through the bid
    // response. Individual creative status codes of bids submitted by the buyer
    // in the on-device interest group auction are not available. See
    // https://storage.googleapis.com/adx-rtb-dictionaries/interest-group-buyer-status-codes.txt
    // for a list of interest group buyer status codes.
    optional int32 interest_group_buyer_status_code = 19;
  }
  repeated BidResponseFeedback bid_response_feedback = 44;

  // How many milliseconds Google will wait for a response before ignoring it.
  optional int32 response_deadline_ms = 57;

  // -----------------------------------------------------------
  // Testing options.
  //
  // If true, then this is a test request. Results will not be displayed to
  // users and you will not be billed for a response even if it wins the
  // auction. You should still do regular processing since the request may be
  // used to evaluate latencies or for other testing. During your initial
  // testing with Google traffic any response that you make will be filtered
  // out of the auction whether this option has a value of true or false.
  optional bool is_test = 15 [default = false];

  // If true, then this request is intended to measure network latency.
  // Return an empty BidResponse with only processing_time_ms set as quickly as
  // possible without executing any bidding logic.
  optional bool is_ping = 17 [default = false];

  // If true, then the callout model predicted that you will not bid
  // on this request. We send a sampled percentage of such requests so that we
  // can automatically update the model when bidding patterns change.
  optional bool is_predicted_to_be_ignored = 45 [default = false];

  // SupplyChain object. For more information, see
  // https://github.com/InteractiveAdvertisingBureau/openrtb/blob/master/supplychainobject.md.
  message SupplyChain {
    // Indicates whether the chain contains all nodes involved in the
    // transaction leading back to the owner of the site, app or other medium of
    // the inventory.
    optional bool complete = 1;

    message SupplyChainNode {
      // The canonical domain name of the SSP, Exchange, Header Wrapper, etc
      // system that bidders connect to. This may be the operational domain of
      // the system, if that is different than the parent corporate domain, to
      // facilitate WHOIS and reverse IP lookups to establish clear ownership of
      // the delegate system. This should be the same value as used to identify
      // sellers in an ads.txt file if one exists.
      optional string advertising_system_identifier = 1;

      // The identifier associated with the seller or reseller account within
      // the advertising system. This must contain the same value used in
      // transactions, specifically the publisher_id field in the Google
      // protocol. Should be limited to 64 characters in length.
      optional string seller_identifier = 2;

      // Indicates whether this node will be involved in the flow of payment for
      // the inventory. When set to true, the advertising system in the
      // advertising_system_identifier field pays the seller in the
      // seller_identifier field, who is responsible for paying the previous
      // node in the chain. When set to false, this node is not involved in the
      // flow of payment for the inventory.
      optional bool handles_payment = 6;
    }

    // Array of SupplyChainNode objects in the order of the chain. In a complete
    // supply chain, the first node represents the initial advertising system
    // and seller ID involved in the transaction, for example, the owner of the
    // site, app, or other medium. In an incomplete supply chain, it represents
    // the first known node. The last node represents the entity sending this
    // bid request.
    repeated SupplyChainNode nodes = 2;

    // Version of the supply chain specification in use, in the format of
    // "major.minor". For example, for version 1.0 of the spec, use the string
    // "1.0".
    optional string version = 3;
  }
  optional SupplyChain supply_chain = 69;

  // Experimental feature; may be subject to change. See
  // https://support.google.com/authorizedbuyers/answer/10890762 for more
  // information.
  //
  // Describes the scope of frequency cap enforcement available for this
  // request. Frequency caps to be enforced for a bid can be specified in the
  // BidResponse.ad.adslot.frequency_cap field.
  enum FrequencyCappingScope {
    // Default value which should not be used, or which can indicate that
    // frequency cap scope could not be reliably determined.
    FREQUENCY_CAPPING_SCOPE_UNKNOWN = 0;

    // Frequency capping based on bid response specifications is not available
    // for this request. A frequency-capped bid for a bid request with no
    // frequency cap availability will be filtered prior to the auction.
    FREQUENCY_CAPPING_SCOPE_NONE = 1;

    // Frequency capping enforcement is available across multiple sites within
    // the same browser.
    FREQUENCY_CAPPING_SCOPE_BROWSER = 2;

    // Frequency capping enforcement is available across multiple apps on the
    // device, excluding browsers.
    FREQUENCY_CAPPING_SCOPE_DEVICE = 3;

    // Frequency capping enforcement is available within a single app.
    FREQUENCY_CAPPING_SCOPE_APP = 4;

    // Frequency capping enforcement is available within a single site.
    FREQUENCY_CAPPING_SCOPE_SITE = 5;
  }
  optional FrequencyCappingScope frequency_capping_scope = 70;

  // Contains labels indicating the experiment or control groups that are
  // active for this request. Work with your account manager to opt in to an
  // experiment. The exact set of experiments available, their meaning, and
  // whether there is any action required from the bidder varies from experiment
  // to experiment and will be communicated separately.
  //
  // If empty, then this request is not part of any experiment or control group,
  // or your bidder is not participating in any experiments.
  repeated string experiment_ids = 78;

  // The Digital Services Act (DSA) transparency requirements. See
  // https://support.google.com/admanager/answer/14335032.
  message Dsa {
    // Values indicating whether DSA declarations should be included in the bid
    // response and, if so, whether or not the publisher is an Online Platform
    // (OP) or Very Large Online Platform (VLOP), as defined by the DSA.
    enum DsaSupport {
      DSA_SUPPORT_UNKNOWN = 0;

      // DSA declarations are not required in the bid response.
      NOT_REQUIRED = 1;

      // DSA declarations are supported, but not required in the bid response.
      SUPPORTED = 2;

      // DSA declarations are required in the bid response.
      REQUIRED = 3;

      // DSA declarations are required in the bid response and the publisher is
      // an OP or VLOP.
      REQUIRED_BY_ONLINE_PLATFORM = 4;
    }

    // Indicates if DSA declarations should be included in the bid response.
    // Bids where DSA declarations are required but not included will not be
    // accepted.
    optional DsaSupport dsa_support = 1;

    // Options describing a publisher's ability to render DSA transparency
    // declarations.
    enum PublisherRenderingSupport {
      PUBLISHER_RENDERING_SUPPORT_UNKNOWN = 0;

      // Publisher can't render.
      PUBLISHER_UNABLE_TO_RENDER = 1;

      // Publisher could render depending on the buyer's rendering capability as
      // described in the BidResponse.ad.dsa_transparency.buyer_render field.
      PUBLISHER_CAN_RENDER = 2;

      // Publisher will render regardless of the buyer's rendering capability as
      // described in the BidResponse.ad.dsa_transparency.buyer_render field.
      PUBLISHER_WILL_RENDER = 3;
    }

    // Indicates if the publisher will render the DSA Transparency info. This
    // will signal if the publisher is able to and intends to render the icon
    // or other appropriate user-facing symbol and display the DSA transparency
    // info to the end user.
    optional PublisherRenderingSupport publisher_rendering_support = 2;

    // Options describing if a publisher requires DSA transparency declarations.
    enum DataToPublisher {
      DATA_TO_PUBLISHER_UNKNOWN = 0;

      // Do not send transparency data.
      DO_NOT_SEND = 1;

      // Optional to send transparency data.
      OPTIONAL = 2;

      // Send transparency data.
      SEND = 3;
    }

    // Indicates whether the bidder should provide DSA transparency declarations
    // in the bid response. A publisher may need this information for audit or
    // other purposes, even if they will not render the transparency
    // declarations themselves.
    optional DataToPublisher data_to_publisher = 3;
  }

  // The Digital Services Act (DSA) transparency information requirements.
  optional Dsa dsa = 86;
}

// This is the message that you return in response to a BidRequest. You may
// specify zero or more ads. For each ad, you should provide an ad slot on
// which the ad can run. An ad slot is identified by the AdSlot.id from the
// BidRequest. If you do not want to bid, submit a response with no ads and
// with only the processing_time_ms set.
message BidResponse {

  message Ad {
    // The event notification token is sent to AdX by bidders for
    // troubleshooting. AdX will include the token in real-time feedback for the
    // bid. The content of the token will not be logged by AdX. AdX will ignore
    // any token longer than 128 bytes.
    optional bytes event_notification_token = 25;

    // A unique identifier chosen by you for the creative in this response.
    // This must always be set, must be limited to at most 64 bytes, and must be
    // a valid UTF8 string. Every buyer_creative_id you use must always be
    // associated with the same creative. This field is used to communicate
    // approval statuses when issues are found. Do not specify the same id for
    // different creatives, or all creatives will be disapproved if a problem
    // with a single creative is found. Do not specify different ids for the
    // same creative in different responses or no creatives will be served since
    // approval status is assigned on a per-id basis.
    optional string buyer_creative_id = 10;

    // Only one of the following should be set:
    // 1) html_snippet, 2) video_url, 3) native_ad, or 4) sdk_rendered_ad.
    //
    // The HTML snippet that will be placed on the web page to display the ad.
    // Use BidResponse.Ad.AdSlot.billing_id to indicate which billing id
    // this snippet is attributed to.
    optional string html_snippet = 1;

    // The URL to fetch a video ad. The URL should return an XML response that
    // conforms to the VAST 2.0 or 3.0 standard. Use
    // BidResponse.Ad.AdSlot.billing_id to indicate which billing id to
    // attribute this ad to. Only one of the following should be set:
    // html_snippet, video_url. Only set this field if the BidRequest is for an
    // in-video ad (BidRequest.video is present).
    optional string video_url = 9;

    // The VAST document to be returned. This document should conform to the
    // VAST 2.0 or 3.0 standard. Use BidResponse.Ad.AdSlot.billing_id to
    // indicate which billing ID to attribute this ad to.
    // Only set this field if the BidRequest is for an in-video ad and the
    // response is VAST XML.
    optional string video_vast_xml = 24;

    // The URL to fetch an AMPHTML ad. Only one of the following should be set:
    // html_snippet, video_url, amp_ad_url, native_ad.
    optional string amp_ad_url = 23;

    // The content of a native ad. Native ads consist of multiple building
    // blocks, which are rendered by the publisher. Only one of the following
    // should be set: html_snippet, video_url, or native_ad.
    // Only set this field if the BidRequest is for a native ad
    // (BidRequest.adslot.native is present).
    message NativeAd {
      // A video in the form of either a URL for a VAST tag, or an in-line VAST
      // tag. Only set this field if VIDEO is required or recommended in the
      // BidRequest's NativeAdTemplate.
      oneof video {
        // The URL to fetch a video ad. The URL should return an XML response
        // that conforms to VAST standards.
        string video_url = 13;

        // The VAST document to be returned. Max size is 100kB.
        string video_vast_xml = 16;
      }

      // A short title for the ad.
      optional string headline = 1;

      // A long description of the ad.
      optional string body = 2;

      // A label for the button that the user is supposed to click
      optional string call_to_action = 3;

      // The name of the advertiser or sponsor, to be displayed in the ad
      // creative.
      optional string advertiser = 4;

      message Image {
        optional string url = 1;

        // Image width and height are specified in pixels. You may provide a
        // larger image than was requested, so long as the aspect ratio is
        // preserved.
        optional int32 width = 2;
        optional int32 height = 3;
      }

      // A large image.
      optional Image image = 5;

      // A smaller image, for the advertiser's logo.
      optional Image logo = 6;

      // The app icon, for app download ads.
      optional Image app_icon = 7;

      // The app rating in the app store. Must be in the range [0-5].
      optional double star_rating = 8;

      // The URL that the browser/SDK will load when the user clicks the ad.
      // This can be the landing page directly, or the first step of a redirect
      // chain that eventually leads to it. For backward compatibility, if this
      // is not set, the first Ad.click_through_url is used.
      optional string click_link_url = 14;

      // This field is deprecated in favor of the repeated click_tracking_urls
      // field at the BidResponse.Ad level. It will be removed at the end of
      // Q2 2022.
      // The URL to use for click tracking. The SDK pings click tracking url on
      // a background thread. When resolving the url, HTTP 30x redirects are
      // followed. The SDK ignores the contents of the response; this URL
      // has no effect on the landing page for the user.
      optional string DEPRECATED_click_tracking_url = 11 [deprecated = true];

      // This field is deprecated in favor of the click_tracking_urls
      // field at the BidResponse.Ad level. It will be removed at the end of
      // Q2 2022.
      // The URLs to use for click tracking. This will be used throughout the
      // serving stack and will incorporate any URL in click_tracking_url.
      repeated string DEPRECATED_click_tracking_urls = 15 [deprecated = true];

      // The price of the promoted app including the currency info.
      optional string price = 10;
    }
    optional NativeAd native_ad = 18;

    // The set of destination URLs for the snippet. This includes the URLs that
    // the user will go to if they click on the displayed ad, and any URLs that
    // are visible in the rendered ad. Do not include intermediate calls to the
    // adserver that are unrelated to the inal landing page. A BidResponse that
    // returns a snippet or video ad but declares no click_through_url will be
    // discarded. Only set this field if html_snippet or video_url or native_ad
    // are set. This data is used as a destination URL declaration, for example
    // for post-filtering of publisher-blocked URLs or ad categorization.
    //
    // For non-native ads, it is not used for click tracking or any
    // other ad functionality; it is only used as a destination URL
    // declaration.
    //
    // For native ads, if NativeAd.click_link_url is not set, the first
    // value of click_through_url is used to direct the user to the landing
    // page. In addition, all values are used as destination
    // URL declarations (similar to the non-native case).
    repeated string click_through_url = 4;

    // All vendor types for the ads that may be shown from this snippet. You
    // should only declare vendor ids listed in the vendors.txt file in the
    // technical documentation. We will check to ensure that the vendors you
    // declare are in the allowed_vendor_type list sent in the BidRequest for
    // AdX publishers.
    repeated int32 vendor_type = 5;

    // All attributes for the ads that may be shown from this snippet. See
    // buyer-declarable-creative-attributes.txt in the technical documentation
    // for a list of ids. We will check to ensure none of these attributes are
    // in the excluded_attribute list in the BidRequest.
    repeated int32 attribute = 6;

    // All sensitive categories for the ads that may be shown from this snippet.
    // See ad-sensitive-categories.txt in the technical documentation for a list
    // of ids. We will check to ensure none of these categories were in the
    // excluded_sensitive_category list in the BidRequest.
    repeated int32 category = 7;

    // All restricted categories for the ads that may be shown from this
    // snippet. See ad-restricted-categories.txt in the technical documentation
    // for a list of ids. We will check to ensure these categories were listed
    // in the allowed_restricted_category list in the BidRequest. If you are
    // bidding with ads in restricted categories you MUST ALWAYS declare them
    // here.
    repeated int32 restricted_category = 17;

    // All names of the ad's advertisers.
    repeated string advertiser_name = 11;

    // The width and the height in pixels of the ad. Setting these is optional.
    // However, these must be set if the bid BidRequest.AdSlot has more than one
    // width and height or if BidRequest.Mobile.is_interstitial_request is true.
    optional int32 width = 14;
    optional int32 height = 15;

    message AdSlot {
      // The slot id from the BidRequest that the ad may appear in.
      required int32 id = 1;

      // The maximum CPM you want to be charged if you win the auction for this
      // ad slot, expressed in micros of the specified currency or default
      // bidding currency. For example, to bid a CPM of 1.29 USD, set
      // max_cpm_micros = 1290000. Winning bids are rounded up to billable
      // units. For example, in USD, bids are rounded up to the next multiple
      // of 10,000 micros (one cent).
      required int64 max_cpm_micros = 2;

      // The minimum CPM you want to be charged if you win the auction for this
      // ad slot, expressed in micros of the specified currency or default
      // bidding currency. This may represent a second price if you choose
      // max_cpm_micros as the highest of several bids, or some form of reserve
      // price if you want to override the reserve price set by the publisher.
      // The bid must be less than or equal to max_cpm_micros or it will be
      // ignored. This field is optional and does not need to be set. This
      // field is not applicable when responding to bid requests with
      // auction_type set to FIRST_PRICE.
      optional int64 min_cpm_micros = 3;

      // The currency used by max_cpm_micros and min_cpm_micros, using ISO-4217
      // alpha codes. If this field is populated, the specified currency will
      // be used to interpret the bid. Otherwise, the default bidding currency
      // will be used, which is determined in the following priority:
      // 1. The bidder-level currency, if configured in RTB account settings.
      // 2. The buyer-level currency. The buyer will be determined by the
      // billing ID specified in the billing_id field of the bid response if it
      // is populated, otherwise it will be based on the sole billing ID sent
      // in the bid request.
      //
      // The currency of a buyer account is set on account creation and can be
      // checked by contacting a Technical Account Manager.
      optional string currency = 15;

      // Billing id to attribute this impression to. The value must be in the
      // set of billing ids for this slot that were sent in the
      // BidRequest.AdSlot.matching_ad_data.billing_id. This must always be set
      // if the BidRequest has more than one
      // BidRequest.AdSlot.matching_ad_data.billing_id or if the bidder has
      // active child seats.
      optional int64 billing_id = 4;

      // The deal id that you want this bid to participate in. Leave unset
      // or set it to "1" if a deal is available but you want to
      // ignore the deal and participate in the open auction.
      optional int64 deal_id = 5 [default = 0];

      // For exchange bidders (third party exchanges doing real-time bidding on
      // DFP), the deal id from the exchange's namespace that is associated with
      // this bid and reported to publishers. Leave unset if there is no
      // associated deal. This is arbitrary UTF8 text and must be at most 64
      // bytes.
      optional string exchange_deal_id = 6;

      // When exchange_deal_id is set, the type of deal. This is reported to
      // publishers and affects how the deal is treated in the auction.
      enum ExchangeDealType {
        OPEN_AUCTION = 0;
        PRIVATE_AUCTION = 1;
        PREFERRED_DEAL = 2;
        EXCHANGE_AUCTION_PACKAGE = 3;
      }
      optional ExchangeDealType exchange_deal_type = 7 [default = OPEN_AUCTION];

      // The seat ID in the bidder's namespace representing the seat on whose
      // behalf this bid was made.
      optional string seat_id = 25;

      // Buyer declared ID which will be used to break down cost transparency
      // metrics in Reporting. Note that IDs with fewer than 1000 impressions
      // will not be used to break down metrics. IDs longer than 64 bytes will
      // be ignored.
      optional string buyer_reporting_id = 8;

      // Token used to identify end third party buyer information if an
      // exchange as an open bidder is an intermediary. This is obtained from
      // the third party buyer and must be passed to Google unaltered in the bid
      // response.
      optional string third_party_buyer_token = 12;

      // Experimental feature; may be subject to change. See
      // https://support.google.com/authorizedbuyers/answer/10890762 for more
      // information.
      //
      // Specifies frequency capping to be applied to the bid. Impressions for
      // each user are capped at the level specified by frequency_cap_id. A bid
      // will not participate in the auction if an additional impression for the
      // user would violate any of the specified caps. Multiple frequency caps
      // can be specified for the same frequency_cap_id.
      //
      // A bid is filtered before the auction if the frequency cap is malformed.
      // Instances where the cap is malformed include:
      //  - frequency_cap_id is empty or is very long
      //  - max_mpressions or time_range are non-positive
      //  - there are a large number of frequency caps for a single bid
      //  - time_unit is not specified
      //
      // Note that if a subsequent bid with the same frequency_cap_id uses a
      // different duration (represented by time_unit and time_range) then
      // impressions counted against the old frequency cap will not count
      // against the new one, and the impressions counted against the new
      // frequency cap with a different time_unit and time_range will not count
      // against the old frequency cap..
      message FrequencyCap {
        // An ID that can represent a bidder's use-case for frequency capping.
        // For example, it could represent their campaign, ad, line item, or
        // some other entity. It should not contain any user-specific
        // information or identifiers and should not be longer than 64
        // characters.
        optional string frequency_cap_id = 1;

        // The time units for which frequency caps can be enforced.
        enum TimeUnit {
          UNKNOWN_TIME_UNIT = 0;
          MINUTE = 1;
          DAY = 2;
          WEEK = 3;
          MONTH = 4;

          // When INDEFINITE is used, time_range will be ignored. INDEFINITE
          // means the frequency cap will be applied for a long period of time,
          // (longer than a month) but not necessarily forever.
          INDEFINITE = 5;
        }

        // The unit of time used to specify the time window for which a
        // frequency cap applies.
        optional TimeUnit time_unit = 2;

        // The length of the time window, in units specified by time_unit, for
        // which the frequency cap applies. For instance, if time_unit=WEEK and
        // time_range=3, then capping is applied for a three week period. If the
        // time_unit=INDEFINITE, this will be ignored.
        optional int32 time_range = 3 [default = 1];

        // The maximum number of impressions allowed to be shown to a user for
        // the provided frequency_cap_id within the time window described by
        // time_unit and time_range.
        optional int32 max_impressions = 4;
      }
      repeated FrequencyCap frequency_cap = 16;

      // Position within the pod.
      enum PodPosition {
        // Any position in the pod.
        POD_POSITION_ANY = 0;

        // Last position in the pod.
        POD_POSITION_LAST = 1;

        // First position in the pod.
        POD_POSITION_FIRST = 2;

        // First or last position in the pod.
        POD_POSITION_FIRST_OR_LAST = 3;
      }

      // Indicates that the bid is only eligible
      // for a specific position within the pod.
      optional PodPosition position_in_pod = 22;

      // All bids with the same bid_group_id will be won or lost as a group.
      // Bids must have a non-empty bid_group_id to allow an ad to be played
      // as part of a pod.
      // This field is currently only supported for rewarded video pods
      // requests. If an ad is submitted on multiple positional bids
      // represented by AdSlot messages, each bid (AdSlot message)
      // must have a different bid_group_id.
      // For example, if a bidder wants to bid ad_1 for first position
      // and last position in the pod and ad_2 for any position and
      // want to ensure either both win at the same time or neither of those
      // wins, bidder needs to submit:
      // ad {
      //   buyer_creative_id: "ad_1",
      //   adslot {
      //     position_in_pod: POD_POSITION_FIRST,
      //     bid_group_id: "group1"
      //   },
      //   adslot {
      //     position_in_pod: POD_POSITION_LAST,
      //     bid_group_id: "group2"
      //   }
      // },
      // ad {
      //   buyer_creative_id: "ad_2",
      //   adslot {
      //     position_in_pod: POD_POSITION_ANY,
      //     bid_group_id: "group1"
      //   },
      //   adslot {
      //     position_in_pod: POD_POSITION_ANY,
      //     bid_group_id: "group2"
      //   }
      // }
      optional string bid_group_id = 23;
    }
    repeated AdSlot adslot = 3;

    // The URLs to call when the impression is rendered. This is supported for
    // all inventory types and all formats.
    repeated string impression_tracking_url = 19;

    // The URLs to call when the user clicks on the ad. Currently supported only
    // for native ads and Programmatic Guaranteed deals with publisher-
    // managed creatives. In the publisher managed case, these click trackers
    // will be sent to the bidder server to server. In all other cases, these
    // will be sent from the user's device. For more information on
    // publisher-managed creatives, see
    // https://support.google.com/admanager/answer/9243220.
    repeated string click_tracking_urls = 30;

    // Link to ad preferences page. This is only supported for native ads.
    // If present, a standard AdChoices icon is added to the native creative and
    // linked to this URL.
    optional string ad_choices_destination_url = 21;

    message ImpressionTrackingResource {
      // The URL of a Javascript resource. The URLs should not contain script
      // tags. For example: "https://mycdn.com/tracker.js".
      optional string script_url = 1;

      // Additional context provided for rendering.
      enum Context {
        UNKNOWN_CONTEXT = 0;

        // Currently not supported.
        OMID = 1;
      }
      repeated Context context = 2;

      // Parameters associated with the resource that will be passed to the
      // resource when it is loaded. The format of the parameters is dependent
      // on the script vendor.
      optional string verification_parameters = 3;

      // Used to uniquely identify the verification script provider.
      optional string vendor_key = 4;
    }

    // Resources to invoke when the impression is rendered. This is supported
    // for native and banner formats only and explicitly allowed scripts
    // only.
    repeated ImpressionTrackingResource impression_tracking_resource = 26;

    // An ad that will be rendered by an SDK known to the buyer. This can only
    // be used when the BidRequest included a mobile.installed_sdk submessage.
    message SdkRenderedAd {
      // The identifier for the SDK that will render the ad. Must match a
      // mobile.installed_sdk.id sent in the corresponding bid request.
      optional string id = 1;

      // Data to pass to the SDK in order to render the ad. This data is opaque
      // to the publisher and to Google.
      optional string rendering_data = 2;

      // Declared ad assets to support creative scanning, classification, and
      // enforcement of ad policy and publisher blocks for ads rendered with a
      // custom SDK.
      message DeclaredAd {
        // Ad content used by SDK to render an ad.
        oneof content {
          // The HTML snippet representative of the SDK-rendered ad.
          string html_snippet = 1;

          // The URL to the VAST asset used in the SDK-rendered ad.
          string video_url = 2;

          // The VAST document used to render custom SDK-rendered ad. This
          // document should conform to the VAST 2.0 or 3.0 standard.
          string video_vast_xml = 5;

          // The content of a native ad. Native ads consist of multiple building
          // blocks (such as image and text), which are rendered by the buyer
          // SDK.
          NativeAd native_ad = 6;
        }

        // The final landing pages of the SDK-rendered ad.
        repeated string click_through_url = 4;
      }
      optional DeclaredAd declared_ad = 6;
    }
    optional SdkRenderedAd sdk_rendered_ad = 27;

    // Advertiser's SKAdNetwork information to support app installation
    // attribution for iOS 14 and later. Apple's SKAdNetwork API helps
    // advertisers measure ad-driven app installation by sending a postback
    // to the ad network after a successful install. Ad networks will need
    // to send their network ID and signed advertiser information to allow
    // an install to be attributed to the ad impression.
    // For more info visit:
    // https://developer.apple.com/documentation/storekit/skadnetwork
    message SKAdNetworkResponse {
      // Version of SKAdNetwork supported by the advertiser. Also used to
      // specify how the signature was generated by the advertiser. This
      // should match the version from BidRequest.mobile.skad.version.
      optional string version = 1;

      // Ad network identifier used in signature. This should match one of the
      // items in BidRequest.mobile.skad.skadnetids.
      optional string network = 2;

      // Campaign ID compatible with Apple's spec. Used in SKAdNetwork 3.0 and
      // below. Replaced by Source Identifier (`source_identifier` field) in
      // SKAdNetwork 4.0 and above.
      optional int64 campaign = 3;

      // A four-digit integer that ad networks define to represent the ad
      // campaign. Used in SKAdNetwork 4.0+ and replaces the `campaign` field.
      optional int64 source_identifier = 11;

      // ID of advertiser's app in Apple's app store.
      optional string itunesitem = 4;

      // ID of custom product page to display (for iOS 15 or later).
      // If not specified, default product page will be displayed.
      // See https://developer.apple.com/app-store/custom-product-pages/
      // for more details about custom product pages.
      optional string product_page_id = 12;

      // SKAdNetwork API starting from version 2.2 supports multiple ad
      // presentation options specified by the `fidelity-type` parameter of the
      // SKAdNetwork signature. This holds parameters used to generate the
      // signature that would be different for each fidelity type supported.
      // For more info visit:
      // https://developer.apple.com/documentation/storekit/skadnetwork/signing_and_providing_ads
      message Fidelity {
        // The fidelity type of the attribution to track.
        optional SKAdNetworkFidelityType fidelity_type = 1 [default =
          STOREKIT_RENDERED_ADS];

        // A unique all-lowercase UUID generated by the advertiser to use for
        // generating the signature.
        optional string nonce = 2;

        // Unix time in millis used at the time of signature generation.
        optional int64 timestamp = 3;

        // SKAdNetwork signature as specified by Apple.
        optional string signature = 4;
      }
      repeated Fidelity fidelities = 9;

      // A unique all-lowercase UUID generated by the advertiser to use for
      // generating the signature.
      // Note:  This field will be deprecated in favor of the
      // BidResponse.ad.skadn.fidelities.nonce field to support multiple
      // fidelity types.
      optional string nonce = 5;

      // ID of publisher's app in Apple's app store. This should match the ID
      // from BidRequest.mobile.skad.sourceapp.
      optional string sourceapp = 6;

      // Unix time in millis used at the time of signature generation.
      // Note:  This field will be deprecated in favor of the
      // BidResponse.ad.skadn.fidelities.timestamp field to support multiple
      // fidelity types.
      optional int64 timestamp = 7;

      // SKAdNetwork signature as specified by Apple.
      // Note:  This field will be deprecated in favor of the
      // BidResponse.ad.skadn.fidelities.signature field to support multiple
      // fidelity types.
      optional string signature = 8;

      // These options indicate how to present SKOverlay recommending the
      // advertised app.
      // Supported by iOS 14 and later.
      //
      // For more info visit:
      // https://developer.apple.com/documentation/storekit/skoverlay
      message SKOverlay {
        // Delay in seconds after the ad begins before presenting the overlay.
        // If this field is set to 0, the overlay will be shown immediately
        // after the ad begins. If this field is unset, the overlay will not
        // be shown for the ad.
        optional int32 delay_seconds = 1;

        // Delay in seconds after the endcard shows before presenting the
        // overlay. (This field only applies to rewarded or interstitial video
        // creatives.) If this field is set to 0, the overlay will be shown
        // immediately after the endcard shows. If this field is unset,
        // the overlay will not be shown for the endcard.
        // If both `delay_seconds` and `endcard_delay_seconds` are set,
        // the overlay will be automatically dismissed when the ad ends,
        // and shown again after the endcard shows.
        optional int32 endcard_delay_seconds = 2;

        // Whether this overlay can be dismissed by the user.
        optional bool dismissible = 3 [default = true];
      }
      optional SKOverlay skoverlay = 13;

      // Google Mobile Ads SDK options for SKAdNetwork handling.
      message SKAdNetworkOptions {
        // By default, SKAdNetwork attribution will only be initiated if the
        // click-through URL lands on the app store, either as a direct link to
        // the app store or as the final destination of a server-side redirect
        // chain. Enables GMA SDK to always initiate SKAdNetwork
        // attribution on-click regardless of the detected click's final
        // destination URL. Note that enabling this will launch the app store
        // even for clicks that are not meant to open the app store, for example
        // clicks on Ad Choices icon. For more info, see:
        // https://developers.google.com/authorized-buyers/rtb/skadnetwork
        optional bool always_open_appstore = 1 [default = false];
      }
      optional SKAdNetworkOptions skadn_options = 10;
    }
    optional SKAdNetworkResponse skadn = 29;

    // ID of the advertised app (only for app promotion).
    // On Android, this should be a bundle or package name such as
    // com.foo.mygame. On iOS, it is a numeric ID.
    //
    // In addition to this field, set the app_promotion_type field below to take
    // advantage of features specific to app promotion types.
    optional string advertised_app_id = 32;

    // Possible types of app promotion.
    enum AppPromotionType {
      UNKNOWN_APP_PROMOTION_TYPE = 0;

      // For encouraging new users to download and install the advertised app.
      // Clicking this ad will show the app store listing as an overlay (for
      // supported formats), without leaving the publisher app.
      // Click through URL for this ad points to the app store listing.
      INSTALLS = 1;

      // Other types of app promotion that do not fall into the categories
      // above. No features specific to app promotion types will apply.
      OTHER = 3;
    }

    // Type of the app promotion corresponding to the advertised app specified
    // in the advertised_app_id field above.
    // If the advertised app is not specified, this field will be ignored.
    //
    // Setting advertised_app_id field without this field will be treated as if
    // this field were set to OTHER.
    optional AppPromotionType app_promotion_type = 33;

    // DSA Ad Transparency declarations. See
    // https://support.google.com/admanager/answer/14335032.
    message DsaTransparency {
      // Free text string describing the name of the advertiser on whose behalf
      // the ad is shown. Bids will not be accepted if this value is longer
      // than 100 characters.
      optional string displayed_on_behalf = 1;

      // Free text string describing the advertiser who paid for the ad. Must
      // always be included even if it's the same as what is listed in the
      // displayed_on_behalf attribute. Bids will not be accepted if this value
      // is longer than 100 characters.
      optional string paying_entity = 2;

      // Indicates that the buyer will render their own DSA transparency
      // information inside the creative.
      optional bool buyer_render = 3;
    }

    // DSA Ad Transparency information provided by the buyer.
    optional DsaTransparency dsa_transparency = 39;
  }
  repeated Ad ad = 2;

  // If is_test was set in the BidRequest, then you may return debug information
  // as plain text in this field. Don't set this field under normal
  // conditions, or set it to values longer than 100 characters. You should only
  // use this field when asked to do so as part of troubleshooting particular
  // problems.
  optional string debug_string = 5;

  // Set this to the processing time in milliseconds from when you
  // received the request to when you returned the response.
  optional int32 processing_time_ms = 4;

  // An optional, bidder-specified reason for not submitting a bid. This field
  // is equivalent to BidResponse.nbr in the OpenRTB protocol and uses the same
  // namespace of no-bid reason codes. See
  // https://developers.google.com/authorized-buyers/rtb/downloads/no-bid-reasons.txt
  // for the full set of no-bid reason codes.
  optional int32 no_bid_reason = 6;
}

// SKAdNetwork API starting from version 2.2 supports multiple ad
// presentation options specified by the `fidelity-type` parameter of the
// SKAdNetwork signature. The following are the fidelity types supported by
// Apple. For more info visit:
// https://developer.apple.com/documentation/storekit/skadnetwork/signing_and_providing_ads
enum SKAdNetworkFidelityType {
  // Attribution for app installs within 24 hours of viewing an ad for at least
  // 3 seconds. Supported for SKAdnetwork version 2.2 and up. For more info see:
  // https://developer.apple.com/documentation/storekit/skadnetwork/generating_the_signature_to_validate_view-through_ads
  VIEW_THROUGH_ADS = 0;

  // Attribution for app installs initiated from the StoreKit-rendered App Store
  // product page driven by ad clicks. Supported for all SKAdNetwork versions.
  // For more info see:
  // https://developer.apple.com/documentation/storekit/skadnetwork/generating_the_signature_to_validate_storekit-rendered_ads
  STOREKIT_RENDERED_ADS = 1;
}