0
# Asset Management
1

2
Creative asset management including image, video, and text asset uploading, asset group management, and asset performance optimization. The Google Ads API provides comprehensive asset management capabilities for Performance Max campaigns, responsive ads, and creative optimization.
3

4
## Capabilities
5

6
### Asset Operations
7

8
Core asset management operations for creating, uploading, and managing creative assets including images, videos, text, and other media types used across Google Ads campaigns.
9

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

23
    Args:
24
        request: The request object containing all parameters
25
        customer_id: Required customer ID for the account
26
        operations: List of asset 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
        MutateAssetsResponse with operation results
33
    """
34

35
def get_asset(
36
    self,
37
    request: Optional[GetAssetRequest] = None,
38
    resource_name: Optional[str] = None
39
) -> Asset:
40
    """
41
    Retrieve an asset by resource name.
42

43
    Args:
44
        request: The request object
45
        resource_name: Asset resource name (customers/{customer_id}/assets/{asset_id})
46

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

52
### Asset Group Operations
53

54
Asset group management for organizing and managing collections of assets used in Performance Max campaigns and other automated campaign types.
55

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

69
    Args:
70
        request: The request object
71
        customer_id: Required customer ID
72
        operations: List of asset group 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
        MutateAssetGroupsResponse with results
79
    """
80

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

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

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

98
### Asset Group Asset Operations
99

100
Asset group asset association operations for linking individual assets to asset groups with specific field type assignments and performance tracking.
101

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

115
    Args:
116
        request: The request object
117
        customer_id: Required customer ID
118
        operations: List of asset group asset 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
        MutateAssetGroupAssetsResponse with results
125
    """
126
```
127

128
### Asset Set Operations
129

130
Asset set management for creating and managing collections of related assets that can be shared across multiple campaigns and asset groups.
131

132
```python { .api }
133
def mutate_asset_sets(
134
    self,
135
    request: Optional[MutateAssetSetsRequest] = None,
136
    customer_id: Optional[str] = None,
137
    operations: Optional[Sequence[AssetSetOperation]] = None,
138
    partial_failure: bool = False,
139
    validate_only: bool = False,
140
    response_content_type: Optional[ResponseContentTypeEnum.ResponseContentType] = None
141
) -> MutateAssetSetsResponse:
142
    """
143
    Create, update, or remove asset sets.
144

145
    Args:
146
        request: The request object
147
        customer_id: Required customer ID
148
        operations: List of asset set 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
        MutateAssetSetsResponse with results
155
    """
156

157
def mutate_asset_set_assets(
158
    self,
159
    request: Optional[MutateAssetSetAssetsRequest] = None,
160
    customer_id: Optional[str] = None,
161
    operations: Optional[Sequence[AssetSetAssetOperation]] = None,
162
    partial_failure: bool = False,
163
    validate_only: bool = False,
164
    response_content_type: Optional[ResponseContentTypeEnum.ResponseContentType] = None
165
) -> MutateAssetSetAssetsResponse:
166
    """
167
    Create, update, or remove asset set assets.
168

169
    Args:
170
        request: The request object
171
        customer_id: Required customer ID
172
        operations: List of asset set asset operations
173
        partial_failure: Continue on individual failures
174
        validate_only: Validate without executing
175
        response_content_type: Response content type
176

177
    Returns:
178
        MutateAssetSetAssetsResponse with results
179
    """
180
```
181

182
## Asset Creation Examples
183

184
### Upload Image Asset
185

186
```python
187
import base64
188
from google.ads.googleads.client import GoogleAdsClient
189
from google.ads.googleads.errors import GoogleAdsException
190

191
def upload_image_asset(client, customer_id, image_path, asset_name):
192
    """Upload an image asset from a local file."""
193
    
194
    asset_service = client.get_service("AssetService")
195
    
196
    # Read and encode image file
197
    with open(image_path, 'rb') as image_file:
198
        image_data = image_file.read()
199
    
200
    # Create asset operation
201
    operation = client.get_type("AssetOperation")
202
    asset = operation.create
203
    asset.name = asset_name
204
    asset.type_ = client.enums.AssetTypeEnum.IMAGE
205
    
206
    # Set image asset details
207
    image_asset = asset.image_asset
208
    image_asset.data = image_data
209
    image_asset.mime_type = client.enums.MimeTypeEnum.IMAGE_JPEG  # or IMAGE_PNG
210
    
211
    try:
212
        response = asset_service.mutate_assets(
213
            customer_id=customer_id,
214
            operations=[operation]
215
        )
216
        
217
        asset_resource_name = response.results[0].resource_name
218
        print(f"Uploaded image asset: {asset_resource_name}")
219
        return asset_resource_name
220
        
221
    except GoogleAdsException as ex:
222
        print(f"Request failed with status {ex.error.code().name}")
223
        for error in ex.failure.errors:
224
            print(f"Error: {error.message}")
225
        return None
226
```
227

228
### Upload Video Asset
229

230
```python
231
def upload_video_asset(client, customer_id, youtube_video_id, asset_name):
232
    """Create a video asset from a YouTube video."""
233
    
234
    asset_service = client.get_service("AssetService")
235
    
236
    operation = client.get_type("AssetOperation")
237
    asset = operation.create
238
    asset.name = asset_name
239
    asset.type_ = client.enums.AssetTypeEnum.YOUTUBE_VIDEO
240
    
241
    # Set YouTube video asset details
242
    youtube_video_asset = asset.youtube_video_asset
243
    youtube_video_asset.youtube_video_id = youtube_video_id
244
    youtube_video_asset.youtube_video_title = asset_name
245
    
246
    try:
247
        response = asset_service.mutate_assets(
248
            customer_id=customer_id,
249
            operations=[operation]
250
        )
251
        
252
        return response.results[0].resource_name
253
        
254
    except GoogleAdsException as ex:
255
        print(f"Video asset creation failed: {ex.error.code().name}")
256
        for error in ex.failure.errors:
257
            print(f"Error: {error.message}")
258
        return None
259
```
260

261
### Create Text Asset
262

263
```python
264
def create_text_asset(client, customer_id, text_content, asset_name):
265
    """Create a text asset for headlines, descriptions, etc."""
266
    
267
    asset_service = client.get_service("AssetService")
268
    
269
    operation = client.get_type("AssetOperation")
270
    asset = operation.create
271
    asset.name = asset_name
272
    asset.type_ = client.enums.AssetTypeEnum.TEXT
273
    
274
    # Set text asset details
275
    text_asset = asset.text_asset
276
    text_asset.text = text_content
277
    
278
    response = asset_service.mutate_assets(
279
        customer_id=customer_id,
280
        operations=[operation]
281
    )
282
    
283
    return response.results[0].resource_name
284

285
# Example usage
286
text_assets = [
287
    "Premium Quality Products",
288
    "Free Shipping Worldwide",
289
    "Shop Now and Save Big",
290
    "Discover amazing deals on our latest collection of premium products"
291
]
292

293
headline_assets = []
294
for i, text in enumerate(text_assets[:3]):  # First 3 for headlines
295
    asset_resource = create_text_asset(
296
        client, 
297
        customer_id, 
298
        text, 
299
        f"Headline {i+1}"
300
    )
301
    headline_assets.append(asset_resource)
302

303
description_asset = create_text_asset(
304
    client,
305
    customer_id,
306
    text_assets[3],  # Last one for description
307
    "Description 1"
308
)
309
```
310

311
### Create Logo Asset
312

313
```python
314
def upload_logo_asset(client, customer_id, logo_path, asset_name):
315
    """Upload a logo asset for display campaigns."""
316
    
317
    asset_service = client.get_service("AssetService")
318
    
319
    with open(logo_path, 'rb') as logo_file:
320
        logo_data = logo_file.read()
321
    
322
    operation = client.get_type("AssetOperation")
323
    asset = operation.create
324
    asset.name = asset_name
325
    asset.type_ = client.enums.AssetTypeEnum.IMAGE
326
    
327
    # Set image asset with logo specifications
328
    image_asset = asset.image_asset
329
    image_asset.data = logo_data
330
    image_asset.mime_type = client.enums.MimeTypeEnum.IMAGE_PNG
331
    
332
    response = asset_service.mutate_assets(
333
        customer_id=customer_id,
334
        operations=[operation]
335
    )
336
    
337
    return response.results[0].resource_name
338
```
339

340
## Asset Group Examples
341

342
### Create Asset Group for Performance Max
343

344
```python
345
def create_performance_max_asset_group(client, customer_id, campaign_resource_name, asset_group_name, final_urls):
346
    """Create an asset group for Performance Max campaign."""
347
    
348
    asset_group_service = client.get_service("AssetGroupService")
349
    
350
    operation = client.get_type("AssetGroupOperation")
351
    asset_group = operation.create
352
    asset_group.name = asset_group_name
353
    asset_group.campaign = campaign_resource_name
354
    asset_group.final_urls.extend(final_urls)
355
    asset_group.final_mobile_urls.extend(final_urls)
356
    asset_group.status = client.enums.AssetGroupStatusEnum.ENABLED
357
    
358
    # Set path fields for display URLs
359
    asset_group.path1 = "shop"
360
    asset_group.path2 = "deals"
361
    
362
    try:
363
        response = asset_group_service.mutate_asset_groups(
364
            customer_id=customer_id,
365
            operations=[operation]
366
        )
367
        
368
        asset_group_resource_name = response.results[0].resource_name
369
        print(f"Created asset group: {asset_group_resource_name}")
370
        return asset_group_resource_name
371
        
372
    except GoogleAdsException as ex:
373
        print(f"Asset group creation failed: {ex.error.code().name}")
374
        for error in ex.failure.errors:
375
            print(f"Error: {error.message}")
376
        return None
377
```
378

379
### Add Assets to Asset Group
380

381
```python
382
def add_assets_to_asset_group(client, customer_id, asset_group_resource_name, asset_assignments):
383
    """Add assets to an asset group with field type assignments."""
384
    
385
    asset_group_asset_service = client.get_service("AssetGroupAssetService")
386
    
387
    operations = []
388
    
389
    for assignment in asset_assignments:
390
        operation = client.get_type("AssetGroupAssetOperation")
391
        asset_group_asset = operation.create
392
        asset_group_asset.asset_group = asset_group_resource_name
393
        asset_group_asset.asset = assignment['asset_resource_name']
394
        asset_group_asset.field_type = assignment['field_type']
395
        
396
        operations.append(operation)
397
    
398
    try:
399
        response = asset_group_asset_service.mutate_asset_group_assets(
400
            customer_id=customer_id,
401
            operations=operations
402
        )
403
        
404
        print(f"Added {len(response.results)} assets to asset group")
405
        return [result.resource_name for result in response.results]
406
        
407
    except GoogleAdsException as ex:
408
        print(f"Asset assignment failed: {ex.error.code().name}")
409
        for error in ex.failure.errors:
410
            print(f"Error: {error.message}")
411
        return []
412

413
# Example usage - Complete asset group setup
414
def setup_complete_asset_group(client, customer_id, campaign_resource_name):
415
    """Set up a complete asset group with all required assets."""
416
    
417
    # Create assets first
418
    headline_assets = []
419
    for i in range(5):  # Need 3-15 headlines
420
        headline_asset = create_text_asset(
421
            client, customer_id, f"Headline {i+1}", f"Headline {i+1}"
422
        )
423
        headline_assets.append(headline_asset)
424
    
425
    description_assets = []
426
    for i in range(3):  # Need 2-5 descriptions
427
        description_asset = create_text_asset(
428
            client, customer_id, f"Description {i+1}", f"Description {i+1}"
429
        )
430
        description_assets.append(description_asset)
431
    
432
    # Upload required images (would need actual image files)
433
    # logo_asset = upload_logo_asset(client, customer_id, "logo.png", "Company Logo")
434
    # marketing_image = upload_image_asset(client, customer_id, "marketing.jpg", "Marketing Image")
435
    # square_marketing_image = upload_image_asset(client, customer_id, "square.jpg", "Square Image")
436
    
437
    # Create asset group
438
    asset_group_name = "Performance Max Asset Group"
439
    final_urls = ["https://www.example.com"]
440
    
441
    asset_group_resource_name = create_performance_max_asset_group(
442
        client, customer_id, campaign_resource_name, asset_group_name, final_urls
443
    )
444
    
445
    # Prepare asset assignments
446
    asset_assignments = []
447
    
448
    # Add headlines
449
    for headline_asset in headline_assets:
450
        asset_assignments.append({
451
            'asset_resource_name': headline_asset,
452
            'field_type': client.enums.AssetFieldTypeEnum.HEADLINE
453
        })
454
    
455
    # Add descriptions
456
    for description_asset in description_assets:
457
        asset_assignments.append({
458
            'asset_resource_name': description_asset,
459
            'field_type': client.enums.AssetFieldTypeEnum.DESCRIPTION
460
        })
461
    
462
    # Add images (commented out as we need actual image files)
463
    # asset_assignments.extend([
464
    #     {
465
    #         'asset_resource_name': logo_asset,
466
    #         'field_type': client.enums.AssetFieldTypeEnum.LOGO
467
    #     },
468
    #     {
469
    #         'asset_resource_name': marketing_image,
470
    #         'field_type': client.enums.AssetFieldTypeEnum.MARKETING_IMAGE
471
    #     },
472
    #     {
473
    #         'asset_resource_name': square_marketing_image,
474
    #         'field_type': client.enums.AssetFieldTypeEnum.SQUARE_MARKETING_IMAGE
475
    #     }
476
    # ])
477
    
478
    # Add assets to asset group
479
    add_assets_to_asset_group(client, customer_id, asset_group_resource_name, asset_assignments)
480
    
481
    return asset_group_resource_name
482
```
483

484
## Asset Set Examples
485

486
### Create Merchant Center Asset Set
487

488
```python
489
def create_merchant_center_asset_set(client, customer_id, asset_set_name, merchant_id, feed_label=None):
490
    """Create an asset set linked to Merchant Center for Shopping campaigns."""
491
    
492
    asset_set_service = client.get_service("AssetSetService")
493
    
494
    operation = client.get_type("AssetSetOperation")
495
    asset_set = operation.create
496
    asset_set.name = asset_set_name
497
    asset_set.type_ = client.enums.AssetSetTypeEnum.MERCHANT_CENTER_FEED
498
    
499
    # Configure Merchant Center settings
500
    merchant_center_feed = asset_set.merchant_center_feed
501
    merchant_center_feed.merchant_id = merchant_id
502
    if feed_label:
503
        merchant_center_feed.feed_label = feed_label
504
    
505
    try:
506
        response = asset_set_service.mutate_asset_sets(
507
            customer_id=customer_id,
508
            operations=[operation]
509
        )
510
        
511
        return response.results[0].resource_name
512
        
513
    except GoogleAdsException as ex:
514
        print(f"Asset set creation failed: {ex.error.code().name}")
515
        for error in ex.failure.errors:
516
            print(f"Error: {error.message}")
517
        return None
518
```
519

520
### Create Dynamic Education Asset Set
521

522
```python
523
def create_dynamic_education_asset_set(client, customer_id, asset_set_name, program_ids):
524
    """Create an asset set for dynamic education ads."""
525
    
526
    asset_set_service = client.get_service("AssetSetService")
527
    
528
    operation = client.get_type("AssetSetOperation")
529
    asset_set = operation.create
530
    asset_set.name = asset_set_name
531
    asset_set.type_ = client.enums.AssetSetTypeEnum.DYNAMIC_EDUCATION
532
    
533
    # Configure dynamic education settings
534
    dynamic_education_feed = asset_set.dynamic_education_feed
535
    dynamic_education_feed.program_ids.extend(program_ids)
536
    dynamic_education_feed.language_code = "en"
537
    
538
    response = asset_set_service.mutate_asset_sets(
539
        customer_id=customer_id,
540
        operations=[operation]
541
    )
542
    
543
    return response.results[0].resource_name
544
```
545

546
### Link Asset Set to Campaign
547

548
```python
549
def link_asset_set_to_campaign(client, customer_id, campaign_resource_name, asset_set_resource_name):
550
    """Link an asset set to a campaign."""
551
    
552
    campaign_asset_set_service = client.get_service("CampaignAssetSetService")
553
    
554
    operation = client.get_type("CampaignAssetSetOperation")
555
    campaign_asset_set = operation.create
556
    campaign_asset_set.campaign = campaign_resource_name
557
    campaign_asset_set.asset_set = asset_set_resource_name
558
    
559
    response = campaign_asset_set_service.mutate_campaign_asset_sets(
560
        customer_id=customer_id,
561
        operations=[operation]
562
    )
563
    
564
    return response.results[0].resource_name
565
```
566

567
## Asset Performance Analysis
568

569
### Get Asset Performance Metrics
570

571
```python
572
def get_asset_performance(client, customer_id, start_date, end_date):
573
    """Get performance metrics for assets."""
574
    
575
    googleads_service = client.get_service("GoogleAdsService")
576
    
577
    query = f'''
578
        SELECT 
579
            asset.id,
580
            asset.name,
581
            asset.type,
582
            asset.source,
583
            segments.asset_interaction_target.asset,
584
            segments.asset_interaction_target.interaction_on_this_asset,
585
            metrics.impressions,
586
            metrics.clicks,
587
            metrics.ctr,
588
            metrics.conversions,
589
            metrics.cost_micros
590
        FROM asset
591
        WHERE segments.date BETWEEN '{start_date}' AND '{end_date}'
592
            AND metrics.impressions > 0
593
        ORDER BY metrics.impressions DESC
594
    '''
595
    
596
    response = googleads_service.search(
597
        customer_id=customer_id,
598
        query=query
599
    )
600
    
601
    asset_performance = []
602
    for row in response:
603
        asset = row.asset
604
        metrics = row.metrics
605
        
606
        asset_data = {
607
            'asset_id': asset.id,
608
            'asset_name': asset.name,
609
            'asset_type': asset.type_.name,
610
            'source': asset.source.name,
611
            'impressions': metrics.impressions,
612
            'clicks': metrics.clicks,
613
            'ctr': metrics.ctr,
614
            'conversions': metrics.conversions,
615
            'cost': metrics.cost_micros / 1_000_000
616
        }
617
        asset_performance.append(asset_data)
618
    
619
    return asset_performance
620
```
621

622
### Asset Group Performance Report
623

624
```python
625
def get_asset_group_performance(client, customer_id, campaign_resource_name):
626
    """Get performance report for asset groups in a campaign."""
627
    
628
    googleads_service = client.get_service("GoogleAdsService")
629
    
630
    query = f'''
631
        SELECT 
632
            asset_group.id,
633
            asset_group.name,
634
            asset_group.status,
635
            asset_group.path1,
636
            asset_group.path2,
637
            metrics.impressions,
638
            metrics.clicks,
639
            metrics.ctr,
640
            metrics.conversions,
641
            metrics.conversion_rate,
642
            metrics.cost_micros,
643
            metrics.cost_per_conversion
644
        FROM asset_group
645
        WHERE asset_group.campaign = '{campaign_resource_name}'
646
            AND segments.date DURING LAST_30_DAYS
647
        ORDER BY metrics.cost_micros DESC
648
    '''
649
    
650
    response = googleads_service.search(
651
        customer_id=customer_id,
652
        query=query
653
    )
654
    
655
    asset_group_performance = []
656
    for row in response:
657
        asset_group = row.asset_group
658
        metrics = row.metrics
659
        
660
        group_data = {
661
            'asset_group_id': asset_group.id,
662
            'asset_group_name': asset_group.name,
663
            'status': asset_group.status.name,
664
            'path1': asset_group.path1,
665
            'path2': asset_group.path2,
666
            'impressions': metrics.impressions,
667
            'clicks': metrics.clicks,
668
            'ctr': metrics.ctr,
669
            'conversions': metrics.conversions,
670
            'conversion_rate': metrics.conversion_rate,
671
            'cost': metrics.cost_micros / 1_000_000,
672
            'cost_per_conversion': metrics.cost_per_conversion / 1_000_000 if metrics.cost_per_conversion else 0
673
        }
674
        asset_group_performance.append(group_data)
675
    
676
    return asset_group_performance
677
```
678

679
## Types
680

681
```python { .api }
682
# Asset types
683
class Asset:
684
    resource_name: str
685
    id: Optional[int]
686
    name: Optional[str]
687
    type_: AssetTypeEnum.AssetType
688
    final_urls: List[str]
689
    final_mobile_urls: List[str]
690
    tracking_url_template: Optional[str]
691
    url_custom_parameters: List[CustomParameter]
692
    final_url_suffix: Optional[str]
693
    source: AssetSourceEnum.AssetSource
694
    policy_summary: AssetPolicySummary
695
    field_type_policy_summaries: List[AssetFieldTypePolicySummary]
696
    
697
    # Asset types (one of the following)
698
    youtube_video_asset: YoutubeVideoAsset
699
    media_bundle_asset: MediaBundleAsset
700
    image_asset: ImageAsset
701
    text_asset: TextAsset
702
    lead_form_asset: LeadFormAsset
703
    book_on_google_asset: BookOnGoogleAsset
704
    promotion_asset: PromotionAsset
705
    callout_asset: CalloutAsset
706
    structured_snippet_asset: StructuredSnippetAsset
707
    sitelink_asset: SitelinkAsset
708
    page_feed_asset: PageFeedAsset
709
    dynamic_education_asset: DynamicEducationAsset
710
    mobile_app_asset: MobileAppAsset
711
    hotel_callout_asset: HotelCalloutAsset
712
    call_asset: CallAsset
713
    price_asset: PriceAsset
714
    call_to_action_asset: CallToActionAsset
715
    dynamic_real_estate_asset: DynamicRealEstateAsset
716
    dynamic_custom_asset: DynamicCustomAsset
717
    dynamic_hotels_and_rentals_asset: DynamicHotelsAndRentalsAsset
718
    dynamic_flights_asset: DynamicFlightsAsset
719
    discovery_carousel_card_asset: DiscoveryCarouselCardAsset
720
    dynamic_travel_asset: DynamicTravelAsset
721
    dynamic_local_asset: DynamicLocalAsset
722
    dynamic_jobs_asset: DynamicJobsAsset
723

724
class ImageAsset:
725
    data: bytes
726
    file_size: Optional[int]
727
    mime_type: MimeTypeEnum.MimeType
728
    full_size: ImageDimension
729

730
class YoutubeVideoAsset:
731
    youtube_video_id: Optional[str]
732
    youtube_video_title: Optional[str]
733

734
class TextAsset:
735
    text: Optional[str]
736

737
class MediaBundleAsset:
738
    data: Optional[bytes]
739

740
# Asset group types
741
class AssetGroup:
742
    resource_name: str
743
    id: Optional[int]
744
    campaign: Optional[str]
745
    name: Optional[str]
746
    final_urls: List[str]
747
    final_mobile_urls: List[str]
748
    status: AssetGroupStatusEnum.AssetGroupStatus
749
    primary_status: AssetGroupPrimaryStatusEnum.AssetGroupPrimaryStatus
750
    primary_status_reasons: List[AssetGroupPrimaryStatusReasonEnum.AssetGroupPrimaryStatusReason]
751
    path1: Optional[str]
752
    path2: Optional[str]
753
    ad_strength: AdStrengthEnum.AdStrength
754

755
class AssetGroupAsset:
756
    resource_name: str
757
    asset_group: Optional[str]
758
    asset: Optional[str]
759
    field_type: AssetFieldTypeEnum.AssetFieldType
760
    status: AssetLinkStatusEnum.AssetLinkStatus
761
    primary_status: AssetLinkPrimaryStatusEnum.AssetLinkPrimaryStatus
762
    primary_status_reasons: List[AssetLinkPrimaryStatusReasonEnum.AssetLinkPrimaryStatusReason]
763
    primary_status_details: List[AssetLinkPrimaryStatusDetails]
764
    performance_label: AssetPerformanceLabelEnum.AssetPerformanceLabel
765
    policy_summary: AssetGroupAssetPolicySummary
766

767
# Asset set types
768
class AssetSet:
769
    resource_name: str
770
    id: Optional[int]
771
    name: Optional[str]
772
    type_: AssetSetTypeEnum.AssetSetType
773
    status: AssetSetStatusEnum.AssetSetStatus
774
    
775
    # Asset set types (one of the following)
776
    merchant_center_feed: MerchantCenterFeed
777
    location_group_parent_asset_set_id: Optional[int]
778
    hotel_property_data: HotelPropertyAsset
779
    dynamic_education_feed: DynamicEducationFeed
780
    dynamic_real_estate_feed: DynamicRealEstateFeed
781
    dynamic_custom_feed: DynamicCustomFeed
782
    dynamic_hotels_and_rentals_feed: DynamicHotelsAndRentalsFeed
783
    dynamic_flights_feed: DynamicFlightsFeed
784
    dynamic_travel_feed: DynamicTravelFeed
785
    dynamic_local_feed: DynamicLocalFeed
786
    dynamic_jobs_feed: DynamicJobsFeed
787

788
class AssetSetAsset:
789
    resource_name: str
790
    asset_set: Optional[str]
791
    asset: Optional[str]
792
    status: AssetSetAssetStatusEnum.AssetSetAssetStatus
793

794
class MerchantCenterFeed:
795
    merchant_id: Optional[int]
796
    feed_label: Optional[str]
797

798
# Campaign asset associations
799
class CampaignAsset:
800
    resource_name: str
801
    campaign: Optional[str]
802
    asset: Optional[str]
803
    field_type: AssetFieldTypeEnum.AssetFieldType
804
    source: AssetSourceEnum.AssetSource
805
    status: AssetLinkStatusEnum.AssetLinkStatus
806
    primary_status: AssetLinkPrimaryStatusEnum.AssetLinkPrimaryStatus
807
    primary_status_details: List[AssetLinkPrimaryStatusDetails]
808
    primary_status_reasons: List[AssetLinkPrimaryStatusReasonEnum.AssetLinkPrimaryStatusReason]
809

810
class CampaignAssetSet:
811
    resource_name: str
812
    campaign: Optional[str]
813
    asset_set: Optional[str]
814
    status: AssetSetLinkStatusEnum.AssetSetLinkStatus
815

816
# Operation types
817
class AssetOperation:
818
    update_mask: FieldMask
819
    create: Asset
820
    update: Asset
821
    remove: str
822

823
class AssetGroupOperation:
824
    update_mask: FieldMask
825
    create: AssetGroup
826
    update: AssetGroup
827
    remove: str
828

829
class AssetGroupAssetOperation:
830
    update_mask: FieldMask
831
    create: AssetGroupAsset
832
    update: AssetGroupAsset
833
    remove: str
834

835
class AssetSetOperation:
836
    update_mask: FieldMask
837
    create: AssetSet
838
    update: AssetSet
839
    remove: str
840

841
class AssetSetAssetOperation:
842
    update_mask: FieldMask
843
    create: AssetSetAsset
844
    update: AssetSetAsset
845
    remove: str
846

847
# Response types
848
class MutateAssetsResponse:
849
    partial_failure_error: Status
850
    results: List[MutateAssetResult]
851

852
class MutateAssetResult:
853
    resource_name: str
854
    asset: Asset
855

856
class MutateAssetGroupsResponse:
857
    partial_failure_error: Status
858
    results: List[MutateAssetGroupResult]
859

860
class MutateAssetGroupResult:
861
    resource_name: str
862
    asset_group: AssetGroup
863

864
class MutateAssetGroupAssetsResponse:
865
    partial_failure_error: Status
866
    results: List[MutateAssetGroupAssetResult]
867

868
class MutateAssetGroupAssetResult:
869
    resource_name: str
870
    asset_group_asset: AssetGroupAsset
871

872
class MutateAssetSetsResponse:
873
    partial_failure_error: Status
874
    results: List[MutateAssetSetResult]
875

876
class MutateAssetSetResult:
877
    resource_name: str
878
    asset_set: AssetSet
879
```