0
# Ad Management
1

2
Comprehensive ad group and advertisement management including ad group creation, ad creation and modification, ad group targeting, and performance optimization at the ad level. The Google Ads API provides extensive capabilities for managing ads across all ad formats and advertising networks.
3

4
## Capabilities
5

6
### Ad Group Operations
7

8
Core ad group management operations for creating, updating, and managing ad groups within campaigns including targeting and bidding configurations.
9

10
```python { .api }
11
def mutate_ad_groups(
12
    self,
13
    request: Optional[MutateAdGroupsRequest] = None,
14
    customer_id: Optional[str] = None,
15
    operations: Optional[Sequence[AdGroupOperation]] = None,
16
    partial_failure: bool = False,
17
    validate_only: bool = False,
18
    response_content_type: Optional[ResponseContentTypeEnum.ResponseContentType] = None
19
) -> MutateAdGroupsResponse:
20
    """
21
    Create, update, or remove ad groups.
22

23
    Args:
24
        request: The request object containing all parameters
25
        customer_id: Required customer ID for the account
26
        operations: List of ad group operations to perform
27
        partial_failure: Continue processing on individual failures
28
        validate_only: Validate operations without executing
29
        response_content_type: Type of response content to return
30

31
    Returns:
32
        MutateAdGroupsResponse with operation results
33
    """
34

35
def get_ad_group(
36
    self,
37
    request: Optional[GetAdGroupRequest] = None,
38
    resource_name: Optional[str] = None
39
) -> AdGroup:
40
    """
41
    Retrieve a single ad group by resource name.
42

43
    Args:
44
        request: The request object
45
        resource_name: Ad group resource name (customers/{customer_id}/adGroups/{ad_group_id})
46

47
    Returns:
48
        AdGroup resource object
49
    """
50
```
51

52
### Ad Group Ad Operations
53

54
Advertisement management operations for creating and managing ads within ad groups including responsive search ads, expanded text ads, and display ads.
55

56
```python { .api }
57
def mutate_ad_group_ads(
58
    self,
59
    request: Optional[MutateAdGroupAdsRequest] = None,
60
    customer_id: Optional[str] = None,
61
    operations: Optional[Sequence[AdGroupAdOperation]] = None,
62
    partial_failure: bool = False,
63
    validate_only: bool = False,
64
    response_content_type: Optional[ResponseContentTypeEnum.ResponseContentType] = None
65
) -> MutateAdGroupAdsResponse:
66
    """
67
    Create, update, or remove ads in ad groups.
68

69
    Args:
70
        request: The request object
71
        customer_id: Required customer ID
72
        operations: List of ad operations
73
        partial_failure: Continue on individual failures
74
        validate_only: Validate without executing
75
        response_content_type: Response content type
76

77
    Returns:
78
        MutateAdGroupAdsResponse with results
79
    """
80

81
def get_ad_group_ad(
82
    self,
83
    request: Optional[GetAdGroupAdRequest] = None,
84
    resource_name: Optional[str] = None
85
) -> AdGroupAd:
86
    """
87
    Retrieve an ad group ad by resource name.
88

89
    Args:
90
        request: The request object
91
        resource_name: Ad group ad resource name
92

93
    Returns:
94
        AdGroupAd resource object
95
    """
96
```
97

98
### Ad Group Criterion Operations
99

100
Ad group level targeting and keyword management including keyword bidding, negative keywords, and audience targeting at the ad group level.
101

102
```python { .api }
103
def mutate_ad_group_criteria(
104
    self,
105
    request: Optional[MutateAdGroupCriteriaRequest] = None,
106
    customer_id: Optional[str] = None,
107
    operations: Optional[Sequence[AdGroupCriterionOperation]] = None,
108
    partial_failure: bool = False,
109
    validate_only: bool = False,
110
    response_content_type: Optional[ResponseContentTypeEnum.ResponseContentType] = None
111
) -> MutateAdGroupCriteriaResponse:
112
    """
113
    Create, update, or remove ad group criteria.
114

115
    Args:
116
        request: The request object
117
        customer_id: Required customer ID
118
        operations: List of criterion operations
119
        partial_failure: Continue on individual failures
120
        validate_only: Validate without executing
121
        response_content_type: Response content type
122

123
    Returns:
124
        MutateAdGroupCriteriaResponse with results
125
    """
126
```
127

128
### Ad Group Bid Modifier Operations
129

130
Bid modifier management for adjusting bids based on targeting criteria like device, location, and audience at the ad group level.
131

132
```python { .api }
133
def mutate_ad_group_bid_modifiers(
134
    self,
135
    request: Optional[MutateAdGroupBidModifiersRequest] = None,
136
    customer_id: Optional[str] = None,
137
    operations: Optional[Sequence[AdGroupBidModifierOperation]] = None,
138
    partial_failure: bool = False,
139
    validate_only: bool = False,
140
    response_content_type: Optional[ResponseContentTypeEnum.ResponseContentType] = None
141
) -> MutateAdGroupBidModifiersResponse:
142
    """
143
    Create, update, or remove ad group bid modifiers.
144

145
    Args:
146
        request: The request object
147
        customer_id: Required customer ID
148
        operations: List of bid modifier operations
149
        partial_failure: Continue on individual failures
150
        validate_only: Validate without executing
151
        response_content_type: Response content type
152

153
    Returns:
154
        MutateAdGroupBidModifiersResponse with results
155
    """
156
```
157

158
## Ad Group Creation Examples
159

160
### Basic Search Ad Group
161

162
```python
163
from google.ads.googleads.client import GoogleAdsClient
164
from google.ads.googleads.errors import GoogleAdsException
165

166
def create_search_ad_group(client, customer_id, campaign_resource_name, ad_group_name, cpc_bid_micros):
167
    """Create a search ad group with manual CPC bidding."""
168
    
169
    ad_group_service = client.get_service("AdGroupService")
170
    
171
    # Create ad group operation
172
    operation = client.get_type("AdGroupOperation")
173
    ad_group = operation.create
174
    ad_group.name = ad_group_name
175
    ad_group.campaign = campaign_resource_name
176
    ad_group.status = client.enums.AdGroupStatusEnum.ENABLED
177
    ad_group.type_ = client.enums.AdGroupTypeEnum.SEARCH_STANDARD
178
    ad_group.cpc_bid_micros = cpc_bid_micros
179
    
180
    try:
181
        response = ad_group_service.mutate_ad_groups(
182
            customer_id=customer_id,
183
            operations=[operation]
184
        )
185
        
186
        ad_group_resource_name = response.results[0].resource_name
187
        print(f"Created ad group: {ad_group_resource_name}")
188
        return ad_group_resource_name
189
        
190
    except GoogleAdsException as ex:
191
        print(f"Request failed with status {ex.error.code().name}")
192
        for error in ex.failure.errors:
193
            print(f"Error: {error.message}")
194
        return None
195
```
196

197
### Shopping Ad Group
198

199
```python
200
def create_shopping_ad_group(client, customer_id, campaign_resource_name, ad_group_name):
201
    """Create a shopping ad group for product listing ads."""
202
    
203
    ad_group_service = client.get_service("AdGroupService")
204
    
205
    operation = client.get_type("AdGroupOperation")
206
    ad_group = operation.create
207
    ad_group.name = ad_group_name
208
    ad_group.campaign = campaign_resource_name
209
    ad_group.status = client.enums.AdGroupStatusEnum.ENABLED
210
    ad_group.type_ = client.enums.AdGroupTypeEnum.SHOPPING_PRODUCT_ADS
211
    
212
    # Shopping ad groups use campaign-level bidding
213
    # No CPC bid set at ad group level
214
    
215
    response = ad_group_service.mutate_ad_groups(
216
        customer_id=customer_id,
217
        operations=[operation]
218
    )
219
    
220
    return response.results[0].resource_name
221
```
222

223
### Display Ad Group
224

225
```python
226
def create_display_ad_group(client, customer_id, campaign_resource_name, ad_group_name, cpm_bid_micros):
227
    """Create a display ad group with CPM bidding."""
228
    
229
    ad_group_service = client.get_service("AdGroupService")
230
    
231
    operation = client.get_type("AdGroupOperation")
232
    ad_group = operation.create
233
    ad_group.name = ad_group_name
234
    ad_group.campaign = campaign_resource_name
235
    ad_group.status = client.enums.AdGroupStatusEnum.ENABLED
236
    ad_group.type_ = client.enums.AdGroupTypeEnum.DISPLAY_STANDARD
237
    ad_group.cpm_bid_micros = cpm_bid_micros
238
    
239
    # Display settings
240
    ad_group.display_custom_bid_dimension = client.enums.TargetingDimensionEnum.AUDIENCE
241
    
242
    response = ad_group_service.mutate_ad_groups(
243
        customer_id=customer_id,
244
        operations=[operation]
245
    )
246
    
247
    return response.results[0].resource_name
248
```
249

250
## Ad Creation Examples
251

252
### Responsive Search Ad
253

254
```python
255
def create_responsive_search_ad(client, customer_id, ad_group_resource_name, headlines, descriptions, final_urls):
256
    """Create a responsive search ad with multiple headlines and descriptions."""
257
    
258
    ad_group_ad_service = client.get_service("AdGroupAdService")
259
    
260
    # Create ad operation
261
    operation = client.get_type("AdGroupAdOperation")
262
    ad_group_ad = operation.create
263
    ad_group_ad.ad_group = ad_group_resource_name
264
    ad_group_ad.status = client.enums.AdGroupAdStatusEnum.ENABLED
265
    
266
    # Configure responsive search ad
267
    ad = ad_group_ad.ad
268
    ad.type_ = client.enums.AdTypeEnum.RESPONSIVE_SEARCH_AD
269
    ad.final_urls.extend(final_urls)
270
    
271
    # Add headlines (3-15 required)
272
    for i, headline_text in enumerate(headlines):
273
        headline = client.get_type("AdTextAsset")
274
        headline.text = headline_text
275
        if i < 3:  # Pin first 3 headlines to position 1
276
            headline.pinned_field = client.enums.ServedAssetFieldTypeEnum.HEADLINE_1
277
        ad.responsive_search_ad.headlines.append(headline)
278
    
279
    # Add descriptions (2-4 required)
280
    for description_text in descriptions:
281
        description = client.get_type("AdTextAsset")
282
        description.text = description_text
283
        ad.responsive_search_ad.descriptions.append(description)
284
    
285
    # Add path fields for display
286
    ad.responsive_search_ad.path1 = "shop"
287
    ad.responsive_search_ad.path2 = "deals"
288
    
289
    try:
290
        response = ad_group_ad_service.mutate_ad_group_ads(
291
            customer_id=customer_id,
292
            operations=[operation]
293
        )
294
        
295
        ad_resource_name = response.results[0].resource_name
296
        print(f"Created responsive search ad: {ad_resource_name}")
297
        return ad_resource_name
298
        
299
    except GoogleAdsException as ex:
300
        print(f"Request failed with status {ex.error.code().name}")
301
        for error in ex.failure.errors:
302
            print(f"Error: {error.message}")
303
        return None
304

305
# Example usage
306
headlines = [
307
    "High Quality Products",
308
    "Best Deals Online", 
309
    "Free Shipping Available",
310
    "Shop Now and Save",
311
    "Premium Quality Guaranteed"
312
]
313

314
descriptions = [
315
    "Discover amazing deals on high-quality products with fast, free shipping.",
316
    "Shop our wide selection of premium products at unbeatable prices."
317
]
318

319
final_urls = ["https://www.example.com"]
320

321
create_responsive_search_ad(client, customer_id, ad_group_resource_name, headlines, descriptions, final_urls)
322
```
323

324
### Expanded Text Ad
325

326
```python
327
def create_expanded_text_ad(client, customer_id, ad_group_resource_name, headline1, headline2, description, final_url):
328
    """Create an expanded text ad (legacy ad format)."""
329
    
330
    ad_group_ad_service = client.get_service("AdGroupAdService")
331
    
332
    operation = client.get_type("AdGroupAdOperation")
333
    ad_group_ad = operation.create
334
    ad_group_ad.ad_group = ad_group_resource_name
335
    ad_group_ad.status = client.enums.AdGroupAdStatusEnum.ENABLED
336
    
337
    # Configure expanded text ad
338
    ad = ad_group_ad.ad
339
    ad.type_ = client.enums.AdTypeEnum.EXPANDED_TEXT_AD
340
    ad.final_urls.append(final_url)
341
    
342
    ad.expanded_text_ad.headline_part1 = headline1
343
    ad.expanded_text_ad.headline_part2 = headline2
344
    ad.expanded_text_ad.description = description
345
    ad.expanded_text_ad.path1 = "products"
346
    ad.expanded_text_ad.path2 = "sale"
347
    
348
    response = ad_group_ad_service.mutate_ad_group_ads(
349
        customer_id=customer_id,
350
        operations=[operation]
351
    )
352
    
353
    return response.results[0].resource_name
354
```
355

356
### Display Image Ad
357

358
```python
359
def create_display_image_ad(client, customer_id, ad_group_resource_name, image_asset_resource_name, final_url):
360
    """Create a display image ad using an existing image asset."""
361
    
362
    ad_group_ad_service = client.get_service("AdGroupAdService")
363
    
364
    operation = client.get_type("AdGroupAdOperation")
365
    ad_group_ad = operation.create
366
    ad_group_ad.ad_group = ad_group_resource_name
367
    ad_group_ad.status = client.enums.AdGroupAdStatusEnum.ENABLED
368
    
369
    # Configure image ad
370
    ad = ad_group_ad.ad
371
    ad.type_ = client.enums.AdTypeEnum.IMAGE_AD
372
    ad.final_urls.append(final_url)
373
    
374
    ad.image_ad.image_asset = image_asset_resource_name
375
    ad.image_ad.name = "Display Image Ad"
376
    
377
    response = ad_group_ad_service.mutate_ad_group_ads(
378
        customer_id=customer_id,
379
        operations=[operation]
380
    )
381
    
382
    return response.results[0].resource_name
383
```
384

385
## Keyword Management Examples
386

387
### Add Keywords to Ad Group
388

389
```python
390
def add_keywords_to_ad_group(client, customer_id, ad_group_resource_name, keywords_data):
391
    """Add keywords to an ad group with different match types and bids."""
392
    
393
    ad_group_criterion_service = client.get_service("AdGroupCriterionService")
394
    
395
    operations = []
396
    
397
    for keyword_data in keywords_data:
398
        operation = client.get_type("AdGroupCriterionOperation")
399
        criterion = operation.create
400
        criterion.ad_group = ad_group_resource_name
401
        criterion.status = client.enums.AdGroupCriterionStatusEnum.ENABLED
402
        criterion.type_ = client.enums.CriterionTypeEnum.KEYWORD
403
        
404
        # Set keyword details
405
        criterion.keyword.text = keyword_data['text']
406
        criterion.keyword.match_type = keyword_data['match_type']
407
        
408
        # Set keyword bid if provided
409
        if 'cpc_bid_micros' in keyword_data:
410
            criterion.cpc_bid_micros = keyword_data['cpc_bid_micros']
411
        
412
        # Set final URL override if provided
413
        if 'final_url' in keyword_data:
414
            criterion.final_urls.append(keyword_data['final_url'])
415
        
416
        operations.append(operation)
417
    
418
    try:
419
        response = ad_group_criterion_service.mutate_ad_group_criteria(
420
            customer_id=customer_id,
421
            operations=operations
422
        )
423
        
424
        print(f"Added {len(response.results)} keywords")
425
        return [result.resource_name for result in response.results]
426
        
427
    except GoogleAdsException as ex:
428
        print(f"Request failed with status {ex.error.code().name}")
429
        for error in ex.failure.errors:
430
            print(f"Error: {error.message}")
431
        return []
432

433
# Example usage
434
keywords_data = [
435
    {
436
        'text': 'running shoes',
437
        'match_type': client.enums.KeywordMatchTypeEnum.EXACT,
438
        'cpc_bid_micros': 2000000,  # $2.00 
439
        'final_url': 'https://www.example.com/running-shoes'
440
    },
441
    {
442
        'text': 'athletic footwear',
443
        'match_type': client.enums.KeywordMatchTypeEnum.PHRASE,
444
        'cpc_bid_micros': 1500000   # $1.50
445
    },
446
    {
447
        'text': 'sports shoes',
448
        'match_type': client.enums.KeywordMatchTypeEnum.BROAD,
449
        'cpc_bid_micros': 1000000   # $1.00
450
    }
451
]
452

453
add_keywords_to_ad_group(client, customer_id, ad_group_resource_name, keywords_data)
454
```
455

456
### Add Negative Keywords
457

458
```python
459
def add_negative_keywords(client, customer_id, ad_group_resource_name, negative_keywords):
460
    """Add negative keywords to an ad group."""
461
    
462
    ad_group_criterion_service = client.get_service("AdGroupCriterionService")
463
    
464
    operations = []
465
    
466
    for keyword_text in negative_keywords:
467
        operation = client.get_type("AdGroupCriterionOperation")
468
        criterion = operation.create
469
        criterion.ad_group = ad_group_resource_name
470
        criterion.negative = True  # Mark as negative
471
        criterion.type_ = client.enums.CriterionTypeEnum.KEYWORD
472
        
473
        criterion.keyword.text = keyword_text
474
        criterion.keyword.match_type = client.enums.KeywordMatchTypeEnum.BROAD
475
        
476
        operations.append(operation)
477
    
478
    response = ad_group_criterion_service.mutate_ad_group_criteria(
479
        customer_id=customer_id,
480
        operations=operations
481
    )
482
    
483
    return response.results
484
```
485

486
## Ad Group Targeting Examples
487

488
### Audience Targeting
489

490
```python
491
def add_audience_targeting(client, customer_id, ad_group_resource_name, audience_resource_names):
492
    """Add audience targeting to an ad group."""
493
    
494
    ad_group_criterion_service = client.get_service("AdGroupCriterionService")
495
    
496
    operations = []
497
    
498
    for audience_resource_name in audience_resource_names:
499
        operation = client.get_type("AdGroupCriterionOperation")
500
        criterion = operation.create
501
        criterion.ad_group = ad_group_resource_name
502
        criterion.status = client.enums.AdGroupCriterionStatusEnum.ENABLED
503
        criterion.type_ = client.enums.CriterionTypeEnum.USER_LIST
504
        
505
        criterion.user_list.user_list = audience_resource_name
506
        
507
        operations.append(operation)
508
    
509
    response = ad_group_criterion_service.mutate_ad_group_criteria(
510
        customer_id=customer_id,
511
        operations=operations
512
    )
513
    
514
    return response.results
515
```
516

517
### Demographics Targeting
518

519
```python
520
def add_demographics_targeting(client, customer_id, ad_group_resource_name):
521
    """Add demographic targeting to an ad group."""
522
    
523
    ad_group_criterion_service = client.get_service("AdGroupCriterionService")
524
    
525
    operations = []
526
    
527
    # Add age range targeting
528
    age_operation = client.get_type("AdGroupCriterionOperation")
529
    age_criterion = age_operation.create
530
    age_criterion.ad_group = ad_group_resource_name
531
    age_criterion.status = client.enums.AdGroupCriterionStatusEnum.ENABLED
532
    age_criterion.type_ = client.enums.CriterionTypeEnum.AGE_RANGE
533
    age_criterion.age_range.type_ = client.enums.AgeRangeTypeEnum.AGE_RANGE_25_34
534
    age_criterion.bid_modifier = 1.2  # +20% bid adjustment
535
    operations.append(age_operation)
536
    
537
    # Add gender targeting  
538
    gender_operation = client.get_type("AdGroupCriterionOperation")
539
    gender_criterion = gender_operation.create
540
    gender_criterion.ad_group = ad_group_resource_name
541
    gender_criterion.status = client.enums.AdGroupCriterionStatusEnum.ENABLED
542
    gender_criterion.type_ = client.enums.CriterionTypeEnum.GENDER
543
    gender_criterion.gender.type_ = client.enums.GenderTypeEnum.FEMALE
544
    operations.append(gender_operation)
545
    
546
    response = ad_group_criterion_service.mutate_ad_group_criteria(
547
        customer_id=customer_id,
548
        operations=operations
549
    )
550
    
551
    return response.results
552
```
553

554
## Types
555

556
```python { .api }
557
# Core ad group types
558
class AdGroup:
559
    resource_name: str
560
    id: Optional[int]
561
    name: Optional[str]
562
    status: AdGroupStatusEnum.AdGroupStatus
563
    type_: AdGroupTypeEnum.AdGroupType
564
    ad_rotation_mode: AdGroupAdRotationModeEnum.AdGroupAdRotationMode
565
    tracking_url_template: Optional[str]
566
    url_custom_parameters: List[CustomParameter]
567
    campaign: Optional[str]
568
    cpc_bid_micros: Optional[int]
569
    effective_cpc_bid_micros: Optional[int]
570
    cpm_bid_micros: Optional[int]
571
    target_cpa_micros: Optional[int]
572
    cpv_bid_micros: Optional[int]
573
    target_cpm_micros: Optional[int]
574
    target_roas: Optional[float]
575
    percent_cpc_bid_micros: Optional[int]
576
    explorer_auto_optimizer_setting: ExplorerAutoOptimizerSetting
577
    display_custom_bid_dimension: TargetingDimensionEnum.TargetingDimension
578
    final_url_suffix: Optional[str]
579
    targeting_setting: TargetingSetting
580
    audience_setting: AudienceSetting
581
    effective_target_cpa_micros: Optional[int]
582
    effective_target_roas: Optional[float]
583
    labels: List[str]
584
    excluded_parent_asset_field_types: List[AssetFieldTypeEnum.AssetFieldType]
585
    excluded_parent_asset_set_types: List[AssetSetTypeEnum.AssetSetType]
586

587
class AdGroupAd:
588
    resource_name: str
589
    status: AdGroupAdStatusEnum.AdGroupAdStatus
590
    ad_group: Optional[str]
591
    ad: Ad
592
    policy_summary: PolicySummary
593
    ad_strength: AdStrengthEnum.AdStrength
594
    action_items: List[str]
595
    labels: List[str]
596

597
class Ad:
598
    resource_name: str
599
    id: Optional[int]
600
    final_urls: List[str]
601
    final_app_urls: List[FinalAppUrl]
602
    final_mobile_urls: List[str]
603
    tracking_url_template: Optional[str]
604
    final_url_suffix: Optional[str]
605
    url_custom_parameters: List[CustomParameter]
606
    display_url: Optional[str]
607
    type_: AdTypeEnum.AdType
608
    added_by_google_ads: Optional[bool]
609
    device_preference: DeviceEnum.Device
610
    url_collections: List[UrlCollection]
611
    name: Optional[str]
612
    system_managed_resource_source: SystemManagedResourceSourceEnum.SystemManagedResourceSource
613
    
614
    # Ad types (one of the following)
615
    text_ad: TextAdInfo
616
    expanded_text_ad: ExpandedTextAdInfo
617
    call_ad: CallAdInfo
618
    expanded_dynamic_search_ad: ExpandedDynamicSearchAdInfo
619
    hotel_ad: HotelAdInfo
620
    shopping_smart_ad: ShoppingSmartAdInfo
621
    shopping_product_ad: ShoppingProductAdInfo
622
    image_ad: ImageAdInfo
623
    video_ad: VideoAdInfo
624
    responsive_search_ad: ResponsiveSearchAdInfo
625
    legacy_responsive_display_ad: LegacyResponsiveDisplayAdInfo
626
    app_ad: AppAdInfo
627
    legacy_app_install_ad: LegacyAppInstallAdInfo
628
    responsive_display_ad: ResponsiveDisplayAdInfo
629
    local_ad: LocalAdInfo
630
    display_upload_ad: DisplayUploadAdInfo
631
    app_engagement_ad: AppEngagementAdInfo
632
    shopping_comparison_listing_ad: ShoppingComparisonListingAdInfo
633
    video_responsive_ad: VideoResponsiveAdInfo
634
    video_bumper_ad: VideoBumperAdInfo
635
    video_non_skippable_in_stream_ad: VideoNonSkippableInStreamAdInfo
636
    video_true_view_in_stream_ad: VideoTrueViewInStreamAdInfo
637
    video_true_view_discovery_ad: VideoTrueViewDiscoveryAdInfo
638
    video_outstream_ad: VideoOutstreamAdInfo
639
    video_true_view_for_action_ad: VideoTrueViewForActionAdInfo
640
    smart_campaign_ad: SmartCampaignAdInfo
641
    call_only_ad: CallOnlyAdInfo
642
    discovery_multi_asset_ad: DiscoveryMultiAssetAdInfo
643
    discovery_carousel_ad: DiscoveryCarouselAdInfo
644
    travel_ad: TravelAdInfo
645
    discovery_video_responsive_ad: DiscoveryVideoResponsiveAdInfo
646

647
class AdGroupCriterion:
648
    resource_name: str
649
    criterion_id: Optional[int]
650
    status: AdGroupCriterionStatusEnum.AdGroupCriterionStatus
651
    quality_info: QualityInfo
652
    ad_group: Optional[str]
653
    type_: CriterionTypeEnum.CriterionType
654
    negative: Optional[bool]
655
    system_serving_status: CriterionSystemServingStatusEnum.CriterionSystemServingStatus
656
    approval_status: AdGroupCriterionApprovalStatusEnum.AdGroupCriterionApprovalStatus
657
    disapproval_reasons: List[str]
658
    labels: List[str]
659
    bid_modifier: Optional[float]
660
    cpc_bid_micros: Optional[int]
661
    cpm_bid_micros: Optional[int]
662
    cpv_bid_micros: Optional[int]
663
    percent_cpc_bid_micros: Optional[int]
664
    effective_cpc_bid_micros: Optional[int]
665
    effective_cpm_bid_micros: Optional[int]
666
    effective_cpv_bid_micros: Optional[int]
667
    effective_percent_cpc_bid_micros: Optional[int]
668
    effective_cpc_bid_source: BiddingSourceEnum.BiddingSource
669
    effective_cpm_bid_source: BiddingSourceEnum.BiddingSource
670
    effective_cpv_bid_source: BiddingSourceEnum.BiddingSource
671
    effective_percent_cpc_bid_source: BiddingSourceEnum.BiddingSource
672
    final_urls: List[str]
673
    final_mobile_urls: List[str]
674
    final_url_suffix: Optional[str]
675
    tracking_url_template: Optional[str]
676
    url_custom_parameters: List[CustomParameter]
677
    position_estimates: KeywordPositionEstimates
678
    
679
    # Criterion types (same as CampaignCriterion)
680
    keyword: KeywordInfo
681
    placement: PlacementInfo
682
    mobile_app_category: MobileAppCategoryInfo
683
    mobile_application: MobileApplicationInfo
684
    location: LocationInfo
685
    device: DeviceInfo
686
    ad_schedule: AdScheduleInfo
687
    age_range: AgeRangeInfo
688
    gender: GenderInfo
689
    income_range: IncomeRangeInfo
690
    parental_status: ParentalStatusInfo
691
    user_list: UserListInfo
692
    youtube_video: YouTubeVideoInfo
693
    youtube_channel: YouTubeChannelInfo
694
    topic: TopicInfo
695
    user_interest: UserInterestInfo
696
    webpage: WebpageInfo
697
    app_payment_model: AppPaymentModelInfo
698
    custom_affinity: CustomAffinityInfo
699
    custom_intent: CustomIntentInfo
700
    custom_audience: CustomAudienceInfo
701
    combined_audience: CombinedAudienceInfo
702
    listing_group: ListingGroupInfo
703

704
# Specific ad type info classes
705
class ResponsiveSearchAdInfo:
706
    headlines: List[AdTextAsset]
707
    descriptions: List[AdTextAsset]
708
    path1: Optional[str]
709
    path2: Optional[str]
710

711
class ExpandedTextAdInfo:
712
    headline_part1: Optional[str]
713
    headline_part2: Optional[str]
714
    headline_part3: Optional[str]
715
    description: Optional[str]
716
    description2: Optional[str]
717
    path1: Optional[str]
718
    path2: Optional[str]
719

720
class ImageAdInfo:
721
    pixel_width: Optional[int]
722
    pixel_height: Optional[int]
723
    image_url: Optional[str]
724
    preview_pixel_width: Optional[int]
725
    preview_pixel_height: Optional[int]
726
    preview_image_url: Optional[str]
727
    mime_type: MimeTypeEnum.MimeType
728
    name: Optional[str]
729
    image_asset: Optional[str]
730

731
class AdTextAsset:
732
    text: Optional[str]
733
    pinned_field: ServedAssetFieldTypeEnum.ServedAssetFieldType
734
    asset_performance_label: AssetPerformanceLabelEnum.AssetPerformanceLabel
735

736
# Operation types
737
class AdGroupOperation:
738
    update_mask: FieldMask
739
    create: AdGroup
740
    update: AdGroup
741
    remove: str
742

743
class AdGroupAdOperation:
744
    update_mask: FieldMask
745
    create: AdGroupAd
746
    update: AdGroupAd
747
    remove: str
748

749
class AdGroupCriterionOperation:
750
    update_mask: FieldMask
751
    create: AdGroupCriterion
752
    update: AdGroupCriterion
753
    remove: str
754

755
class AdGroupBidModifierOperation:
756
    update_mask: FieldMask
757
    create: AdGroupBidModifier
758
    update: AdGroupBidModifier
759
    remove: str
760

761
# Response types
762
class MutateAdGroupsResponse:
763
    partial_failure_error: Status
764
    results: List[MutateAdGroupResult]
765

766
class MutateAdGroupResult:
767
    resource_name: str
768
    ad_group: AdGroup
769

770
class MutateAdGroupAdsResponse:
771
    partial_failure_error: Status
772
    results: List[MutateAdGroupAdResult]
773

774
class MutateAdGroupAdResult:
775
    resource_name: str
776
    ad_group_ad: AdGroupAd
777

778
class MutateAdGroupCriteriaResponse:
779
    partial_failure_error: Status
780
    results: List[MutateAdGroupCriterionResult]
781

782
class MutateAdGroupCriterionResult:
783
    resource_name: str
784
    ad_group_criterion: AdGroupCriterion
785
```