0
# Models and Types Reference
1
2
This document provides a comprehensive reference for all model classes and enumerations in the `azure-mgmt-appconfiguration` package. These types represent the data structures used throughout the Azure App Configuration Management API.
3
4
## Base Resource Models
5
6
### Resource
7
8
```python { .api }
9
class Resource:
10
"""
11
Base class for all Azure resources.
12
13
Attributes:
14
id (str): Fully qualified resource ID (read-only).
15
name (str): Resource name (read-only).
16
type (str): Resource type (read-only).
17
"""
18
```
19
20
### TrackedResource
21
22
```python { .api }
23
class TrackedResource(Resource):
24
"""
25
Base class for tracked Azure resources that have location and tags.
26
27
Attributes:
28
location (str): The geographic location of the resource.
29
tags (Dict[str, str]): Resource tags as key-value pairs.
30
"""
31
32
def __init__(
33
self,
34
*,
35
location: str,
36
tags: Optional[Dict[str, str]] = None,
37
**kwargs: Any
38
) -> None:
39
"""
40
Initialize a TrackedResource.
41
42
Args:
43
location: Azure region where the resource is located.
44
tags: Optional dictionary of tags to apply to the resource.
45
"""
46
```
47
48
## Configuration Store Models
49
50
### ConfigurationStore
51
52
```python { .api }
53
class ConfigurationStore(TrackedResource):
54
"""
55
Represents an Azure App Configuration store resource.
56
57
Attributes:
58
identity (ResourceIdentity): Managed identity configuration.
59
sku (Sku): SKU of the configuration store.
60
provisioning_state (ProvisioningState): Current provisioning state (read-only).
61
creation_date (datetime): When the store was created (read-only).
62
endpoint (str): DNS endpoint for the configuration store (read-only).
63
encryption (EncryptionProperties): Encryption configuration.
64
private_endpoint_connections (List[PrivateEndpointConnectionReference]):
65
Private endpoint connections (read-only).
66
public_network_access (PublicNetworkAccess): Public network access setting.
67
disable_local_auth (bool): Whether local authentication is disabled.
68
soft_delete_retention_in_days (int): Soft delete retention period (1-7 days).
69
enable_purge_protection (bool): Whether purge protection is enabled.
70
create_mode (CreateMode): Store creation mode.
71
data_plane_proxy (DataPlaneProxyProperties): Data plane proxy configuration.
72
system_data (SystemData): System metadata (read-only).
73
"""
74
75
def __init__(
76
self,
77
*,
78
location: str,
79
sku: Sku,
80
tags: Optional[Dict[str, str]] = None,
81
identity: Optional[ResourceIdentity] = None,
82
encryption: Optional[EncryptionProperties] = None,
83
public_network_access: Optional[PublicNetworkAccess] = None,
84
disable_local_auth: Optional[bool] = None,
85
soft_delete_retention_in_days: Optional[int] = None,
86
enable_purge_protection: Optional[bool] = None,
87
create_mode: Optional[CreateMode] = None,
88
data_plane_proxy: Optional[DataPlaneProxyProperties] = None,
89
**kwargs: Any
90
) -> None:
91
"""
92
Initialize a ConfigurationStore.
93
94
Args:
95
location: Azure region for the store.
96
sku: SKU configuration (Free or Standard).
97
tags: Optional resource tags.
98
identity: Managed identity configuration.
99
encryption: Customer-managed encryption settings.
100
public_network_access: Public network access policy.
101
disable_local_auth: Disable connection string authentication.
102
soft_delete_retention_in_days: Days to retain deleted store (1-7).
103
enable_purge_protection: Prevent permanent deletion.
104
create_mode: Creation mode (Default or Recover).
105
data_plane_proxy: Data plane proxy configuration.
106
"""
107
```
108
109
### ConfigurationStoreUpdateParameters
110
111
```python { .api }
112
class ConfigurationStoreUpdateParameters:
113
"""
114
Parameters for updating an existing configuration store.
115
116
Attributes:
117
identity (ResourceIdentity): Updated managed identity configuration.
118
sku (Sku): Updated SKU configuration.
119
tags (Dict[str, str]): Updated resource tags.
120
encryption (EncryptionProperties): Updated encryption settings.
121
disable_local_auth (bool): Updated local auth setting.
122
public_network_access (PublicNetworkAccess): Updated public access setting.
123
enable_purge_protection (bool): Updated purge protection setting.
124
data_plane_proxy (DataPlaneProxyProperties): Updated proxy configuration.
125
"""
126
```
127
128
### DeletedConfigurationStore
129
130
```python { .api }
131
class DeletedConfigurationStore:
132
"""
133
Represents a soft-deleted configuration store.
134
135
Attributes:
136
id (str): Resource ID of the deleted store (read-only).
137
name (str): Name of the deleted store (read-only).
138
type (str): Resource type (read-only).
139
location (str): Location where the store was deleted.
140
deletion_date (datetime): When the store was deleted (read-only).
141
scheduled_purge_date (datetime): When the store will be purged (read-only).
142
tags (Dict[str, str]): Tags from the original store (read-only).
143
purge_protection_enabled (bool): Whether purge protection was enabled (read-only).
144
"""
145
```
146
147
## SKU and Pricing Models
148
149
### Sku
150
151
```python { .api }
152
class Sku:
153
"""
154
Represents the pricing tier and capacity of a configuration store.
155
156
Attributes:
157
name (str): SKU name - "Free" or "Standard".
158
"""
159
160
def __init__(self, *, name: str, **kwargs: Any) -> None:
161
"""
162
Initialize a SKU.
163
164
Args:
165
name: SKU tier name ("Free" or "Standard").
166
"""
167
```
168
169
## Identity and Security Models
170
171
### ResourceIdentity
172
173
```python { .api }
174
class ResourceIdentity:
175
"""
176
Managed identity configuration for a configuration store.
177
178
Attributes:
179
type (IdentityType): Type of managed identity.
180
user_assigned_identities (Dict[str, UserIdentity]): User-assigned identities.
181
principal_id (str): Service principal ID (read-only).
182
tenant_id (str): Tenant ID (read-only).
183
"""
184
185
def __init__(
186
self,
187
*,
188
type: Optional[IdentityType] = None,
189
user_assigned_identities: Optional[Dict[str, UserIdentity]] = None,
190
**kwargs: Any
191
) -> None:
192
"""
193
Initialize ResourceIdentity.
194
195
Args:
196
type: Identity type (None, SystemAssigned, UserAssigned, or both).
197
user_assigned_identities: Dictionary of user-assigned identities.
198
"""
199
```
200
201
### UserIdentity
202
203
```python { .api }
204
class UserIdentity:
205
"""
206
User-assigned managed identity details.
207
208
Attributes:
209
principal_id (str): Principal ID of the identity (read-only).
210
client_id (str): Client ID of the identity (read-only).
211
"""
212
```
213
214
### EncryptionProperties
215
216
```python { .api }
217
class EncryptionProperties:
218
"""
219
Customer-managed encryption configuration.
220
221
Attributes:
222
key_vault_properties (KeyVaultProperties): Key Vault settings for encryption.
223
"""
224
225
def __init__(
226
self,
227
*,
228
key_vault_properties: Optional[KeyVaultProperties] = None,
229
**kwargs: Any
230
) -> None:
231
"""
232
Initialize EncryptionProperties.
233
234
Args:
235
key_vault_properties: Key Vault configuration for customer-managed keys.
236
"""
237
```
238
239
### KeyVaultProperties
240
241
```python { .api }
242
class KeyVaultProperties:
243
"""
244
Key Vault configuration for customer-managed encryption.
245
246
Attributes:
247
key_identifier (str): URI of the Key Vault key for encryption.
248
identity_client_id (str): Client ID of the managed identity for Key Vault access.
249
"""
250
251
def __init__(
252
self,
253
*,
254
key_identifier: Optional[str] = None,
255
identity_client_id: Optional[str] = None,
256
**kwargs: Any
257
) -> None:
258
"""
259
Initialize KeyVaultProperties.
260
261
Args:
262
key_identifier: Full URI to the Key Vault key.
263
identity_client_id: Client ID of user-assigned identity for Key Vault access.
264
"""
265
```
266
267
## API Key Models
268
269
### ApiKey
270
271
```python { .api }
272
class ApiKey:
273
"""
274
Represents an access key for a configuration store.
275
276
Attributes:
277
id (str): Key identifier (read-only).
278
name (str): Key name (read-only).
279
value (str): Key value (read-only).
280
connection_string (str): Connection string using this key (read-only).
281
last_modified (datetime): When the key was last regenerated (read-only).
282
read_only (bool): Whether the key is read-only (read-only).
283
"""
284
```
285
286
### RegenerateKeyParameters
287
288
```python { .api }
289
class RegenerateKeyParameters:
290
"""
291
Parameters for regenerating an access key.
292
293
Attributes:
294
id (str): ID of the key to regenerate.
295
"""
296
297
def __init__(self, *, id: str, **kwargs: Any) -> None:
298
"""
299
Initialize RegenerateKeyParameters.
300
301
Args:
302
id: Identifier of the access key to regenerate.
303
"""
304
```
305
306
## Key-Value Models
307
308
### KeyValue
309
310
```python { .api }
311
class KeyValue:
312
"""
313
Represents a configuration key-value pair.
314
315
Attributes:
316
id (str): Resource ID of the key-value (read-only).
317
name (str): Name of the key-value (read-only).
318
type (str): Resource type (read-only).
319
key (str): The configuration key (read-only).
320
label (str): The configuration label (read-only).
321
value (str): The configuration value.
322
content_type (str): Content type of the value.
323
etag (str): ETag for concurrency control (read-only).
324
last_modified (datetime): Last modification time (read-only).
325
locked (bool): Whether the key-value is locked (read-only).
326
tags (Dict[str, str]): Tags associated with the key-value.
327
"""
328
329
def __init__(
330
self,
331
*,
332
value: Optional[str] = None,
333
content_type: Optional[str] = None,
334
tags: Optional[Dict[str, str]] = None,
335
**kwargs: Any
336
) -> None:
337
"""
338
Initialize a KeyValue.
339
340
Args:
341
value: The configuration value.
342
content_type: MIME type of the value content.
343
tags: Optional tags for the key-value pair.
344
"""
345
```
346
347
### KeyValueFilter
348
349
```python { .api }
350
class KeyValueFilter:
351
"""
352
Filter for selecting key-value pairs in snapshots.
353
354
Attributes:
355
key (str): Key pattern to match (supports wildcards).
356
label (str): Label to match (optional).
357
"""
358
359
def __init__(
360
self,
361
*,
362
key: str,
363
label: Optional[str] = None,
364
**kwargs: Any
365
) -> None:
366
"""
367
Initialize a KeyValueFilter.
368
369
Args:
370
key: Key pattern with wildcard support (e.g., "MyApp:*").
371
label: Specific label to match (empty string matches unlabeled keys).
372
"""
373
```
374
375
## Private Networking Models
376
377
### PrivateEndpointConnection
378
379
```python { .api }
380
class PrivateEndpointConnection:
381
"""
382
Represents a private endpoint connection to a configuration store.
383
384
Attributes:
385
id (str): Resource ID of the connection (read-only).
386
name (str): Name of the connection (read-only).
387
type (str): Resource type (read-only).
388
private_endpoint (PrivateEndpoint): Private endpoint details.
389
private_link_service_connection_state (PrivateLinkServiceConnectionState):
390
Connection state information.
391
provisioning_state (str): ARM provisioning state (read-only).
392
"""
393
394
def __init__(
395
self,
396
*,
397
private_link_service_connection_state: Optional[PrivateLinkServiceConnectionState] = None,
398
**kwargs: Any
399
) -> None:
400
"""
401
Initialize a PrivateEndpointConnection.
402
403
Args:
404
private_link_service_connection_state: Connection state configuration.
405
"""
406
```
407
408
### PrivateEndpoint
409
410
```python { .api }
411
class PrivateEndpoint:
412
"""
413
Represents a private endpoint resource reference.
414
415
Attributes:
416
id (str): Resource ID of the private endpoint (read-only).
417
"""
418
```
419
420
### PrivateLinkServiceConnectionState
421
422
```python { .api }
423
class PrivateLinkServiceConnectionState:
424
"""
425
State information for a private link service connection.
426
427
Attributes:
428
status (ConnectionStatus): Connection approval status.
429
description (str): Description of the connection state.
430
actions_required (ActionsRequired): Required actions for the connection.
431
"""
432
433
def __init__(
434
self,
435
*,
436
status: Optional[ConnectionStatus] = None,
437
description: Optional[str] = None,
438
actions_required: Optional[ActionsRequired] = None,
439
**kwargs: Any
440
) -> None:
441
"""
442
Initialize PrivateLinkServiceConnectionState.
443
444
Args:
445
status: Connection status (Pending, Approved, Rejected, Disconnected).
446
description: Human-readable state description.
447
actions_required: Actions needed beyond normal workflow.
448
"""
449
```
450
451
### PrivateLinkResource
452
453
```python { .api }
454
class PrivateLinkResource:
455
"""
456
Represents a private link resource for a configuration store.
457
458
Attributes:
459
id (str): Resource ID (read-only).
460
name (str): Resource name (read-only).
461
type (str): Resource type (read-only).
462
group_id (str): Private link resource group ID.
463
required_members (List[str]): Required member names.
464
required_zone_names (List[str]): Required private DNS zone names.
465
"""
466
```
467
468
## Replica Models
469
470
### Replica
471
472
```python { .api }
473
class Replica:
474
"""
475
Represents a configuration store replica in another region.
476
477
Attributes:
478
id (str): Resource ID of the replica (read-only).
479
name (str): Name of the replica (read-only).
480
type (str): Resource type (read-only).
481
location (str): Azure region of the replica.
482
endpoint (str): DNS endpoint of the replica (read-only).
483
provisioning_state (ReplicaProvisioningState): Provisioning state (read-only).
484
system_data (SystemData): System metadata (read-only).
485
"""
486
487
def __init__(self, *, location: str, **kwargs: Any) -> None:
488
"""
489
Initialize a Replica.
490
491
Args:
492
location: Azure region where the replica will be created.
493
"""
494
```
495
496
## Snapshot Models
497
498
### Snapshot
499
500
```python { .api }
501
class Snapshot:
502
"""
503
Represents a configuration snapshot capturing state at a point in time.
504
505
Attributes:
506
id (str): Resource ID of the snapshot (read-only).
507
name (str): Name of the snapshot (read-only).
508
type (str): Resource type (read-only).
509
provisioning_state (str): ARM provisioning state (read-only).
510
status (SnapshotStatus): Snapshot status (read-only).
511
filters (List[KeyValueFilter]): Filters defining included key-values.
512
composition_type (CompositionType): How key-values are composed.
513
created (datetime): Creation timestamp (read-only).
514
expires (datetime): Expiration timestamp (read-only).
515
retention_period (int): Retention period in seconds.
516
size_in_bytes (int): Size of the snapshot in bytes (read-only).
517
items_count (int): Number of key-value pairs (read-only).
518
tags (Dict[str, str]): Tags associated with the snapshot.
519
etag (str): ETag for concurrency control (read-only).
520
"""
521
522
def __init__(
523
self,
524
*,
525
filters: List[KeyValueFilter],
526
composition_type: CompositionType,
527
retention_period: Optional[int] = None,
528
tags: Optional[Dict[str, str]] = None,
529
**kwargs: Any
530
) -> None:
531
"""
532
Initialize a Snapshot.
533
534
Args:
535
filters: List of filters to determine included key-values.
536
composition_type: How to compose key-value pairs (KEY or KEY_LABEL).
537
retention_period: Retention period in seconds (default 30 days).
538
tags: Optional tags for the snapshot.
539
"""
540
```
541
542
## Operations Models
543
544
### OperationDefinition
545
546
```python { .api }
547
class OperationDefinition:
548
"""
549
Represents an available API operation.
550
551
Attributes:
552
name (str): Operation name.
553
is_data_action (bool): Whether this is a data plane operation.
554
display (OperationDefinitionDisplay): Display information for the operation.
555
origin (str): Origin of the operation.
556
properties (OperationProperties): Additional operation properties.
557
"""
558
```
559
560
### OperationDefinitionDisplay
561
562
```python { .api }
563
class OperationDefinitionDisplay:
564
"""
565
Display properties for an operation definition.
566
567
Attributes:
568
provider (str): Resource provider name.
569
resource (str): Resource type name.
570
operation (str): Operation name.
571
description (str): Operation description.
572
"""
573
```
574
575
## Name Availability Models
576
577
### CheckNameAvailabilityParameters
578
579
```python { .api }
580
class CheckNameAvailabilityParameters:
581
"""
582
Parameters for checking configuration store name availability.
583
584
Attributes:
585
name (str): Name to check for availability.
586
type (ConfigurationResourceType): Resource type for the name check.
587
"""
588
589
def __init__(
590
self,
591
*,
592
name: str,
593
type: ConfigurationResourceType,
594
**kwargs: Any
595
) -> None:
596
"""
597
Initialize CheckNameAvailabilityParameters.
598
599
Args:
600
name: Configuration store name to check.
601
type: Resource type (Microsoft.AppConfiguration/configurationStores).
602
"""
603
```
604
605
### NameAvailabilityStatus
606
607
```python { .api }
608
class NameAvailabilityStatus:
609
"""
610
Result of a name availability check.
611
612
Attributes:
613
name_available (bool): Whether the name is available.
614
reason (str): Reason why the name is unavailable (if applicable).
615
message (str): Detailed message about availability.
616
"""
617
```
618
619
## Data Plane Proxy Models
620
621
### DataPlaneProxyProperties
622
623
```python { .api }
624
class DataPlaneProxyProperties:
625
"""
626
Configuration for data plane proxy functionality.
627
628
Attributes:
629
authentication_mode (AuthenticationMode): Authentication mode for proxy.
630
private_link_delegation (PrivateLinkDelegation): Private link delegation setting.
631
"""
632
633
def __init__(
634
self,
635
*,
636
authentication_mode: Optional[AuthenticationMode] = None,
637
private_link_delegation: Optional[PrivateLinkDelegation] = None,
638
**kwargs: Any
639
) -> None:
640
"""
641
Initialize DataPlaneProxyProperties.
642
643
Args:
644
authentication_mode: Authentication mode (Local or Pass-through).
645
private_link_delegation: Private link delegation (Enabled or Disabled).
646
"""
647
```
648
649
## System Metadata Models
650
651
### SystemData
652
653
```python { .api }
654
class SystemData:
655
"""
656
Metadata about resource creation and modification.
657
658
Attributes:
659
created_by (str): Identity that created the resource.
660
created_by_type (CreatedByType): Type of identity that created the resource.
661
created_at (datetime): When the resource was created.
662
last_modified_by (str): Identity that last modified the resource.
663
last_modified_by_type (CreatedByType): Type of identity that last modified.
664
last_modified_at (datetime): When the resource was last modified.
665
"""
666
```
667
668
## Error Models
669
670
### ErrorResponse
671
672
```python { .api }
673
class ErrorResponse:
674
"""
675
Standard error response format.
676
677
Attributes:
678
error (ErrorDetail): Error details.
679
"""
680
```
681
682
### ErrorDetail
683
684
```python { .api }
685
class ErrorDetail:
686
"""
687
Detailed error information.
688
689
Attributes:
690
code (str): Error code.
691
message (str): Error message.
692
target (str): Error target.
693
details (List[ErrorDetail]): Additional error details.
694
additional_info (List[ErrorAdditionalInfo]): Additional error information.
695
"""
696
```
697
698
### ErrorAdditionalInfo
699
700
```python { .api }
701
class ErrorAdditionalInfo:
702
"""
703
Additional error information.
704
705
Attributes:
706
type (str): Additional info type.
707
info (object): Additional info data.
708
"""
709
```
710
711
## Enumerations
712
713
### ActionsRequired
714
715
```python { .api }
716
class ActionsRequired(str, Enum):
717
"""
718
Actions required beyond basic workflow.
719
720
Values:
721
NONE: No additional actions required.
722
RECREATE: Resource needs to be recreated.
723
"""
724
NONE = "None"
725
RECREATE = "Recreate"
726
```
727
728
### AuthenticationMode
729
730
```python { .api }
731
class AuthenticationMode(str, Enum):
732
"""
733
Data plane proxy authentication mode.
734
735
Values:
736
LOCAL: Use local authentication.
737
PASS_THROUGH: Pass authentication through to the target.
738
"""
739
LOCAL = "Local"
740
PASS_THROUGH = "Pass-through"
741
```
742
743
### CompositionType
744
745
```python { .api }
746
class CompositionType(str, Enum):
747
"""
748
Snapshot composition type for key-value pairs.
749
750
Values:
751
KEY: Compose by key only (ignore labels).
752
KEY_LABEL: Compose by both key and label.
753
"""
754
KEY = "Key"
755
KEY_LABEL = "Key_Label"
756
```
757
758
### ConfigurationResourceType
759
760
```python { .api }
761
class ConfigurationResourceType(str, Enum):
762
"""
763
Resource type for configuration store name availability checks.
764
765
Values:
766
MICROSOFT_APP_CONFIGURATION_CONFIGURATION_STORES:
767
App Configuration store resource type.
768
"""
769
MICROSOFT_APP_CONFIGURATION_CONFIGURATION_STORES = "Microsoft.AppConfiguration/configurationStores"
770
```
771
772
### ConnectionStatus
773
774
```python { .api }
775
class ConnectionStatus(str, Enum):
776
"""
777
Private link service connection status.
778
779
Values:
780
PENDING: Connection is pending approval.
781
APPROVED: Connection has been approved.
782
REJECTED: Connection has been rejected.
783
DISCONNECTED: Connection has been disconnected.
784
"""
785
PENDING = "Pending"
786
APPROVED = "Approved"
787
REJECTED = "Rejected"
788
DISCONNECTED = "Disconnected"
789
```
790
791
### CreateMode
792
793
```python { .api }
794
class CreateMode(str, Enum):
795
"""
796
Configuration store creation mode.
797
798
Values:
799
RECOVER: Recover a soft-deleted store.
800
DEFAULT: Create a new store normally.
801
"""
802
RECOVER = "Recover"
803
DEFAULT = "Default"
804
```
805
806
### CreatedByType
807
808
```python { .api }
809
class CreatedByType(str, Enum):
810
"""
811
Type of identity that created or modified a resource.
812
813
Values:
814
USER: Created by a user.
815
APPLICATION: Created by an application.
816
MANAGED_IDENTITY: Created by a managed identity.
817
KEY: Created using a key-based authentication.
818
"""
819
USER = "User"
820
APPLICATION = "Application"
821
MANAGED_IDENTITY = "ManagedIdentity"
822
KEY = "Key"
823
```
824
825
### IdentityType
826
827
```python { .api }
828
class IdentityType(str, Enum):
829
"""
830
Type of managed identity for a resource.
831
832
Values:
833
NONE: No managed identity.
834
SYSTEM_ASSIGNED: System-assigned managed identity.
835
USER_ASSIGNED: User-assigned managed identity.
836
SYSTEM_ASSIGNED_USER_ASSIGNED: Both system and user-assigned identities.
837
"""
838
NONE = "None"
839
SYSTEM_ASSIGNED = "SystemAssigned"
840
USER_ASSIGNED = "UserAssigned"
841
SYSTEM_ASSIGNED_USER_ASSIGNED = "SystemAssigned, UserAssigned"
842
```
843
844
### PrivateLinkDelegation
845
846
```python { .api }
847
class PrivateLinkDelegation(str, Enum):
848
"""
849
Data plane proxy private link delegation setting.
850
851
Values:
852
ENABLED: Private link delegation is enabled.
853
DISABLED: Private link delegation is disabled.
854
"""
855
ENABLED = "Enabled"
856
DISABLED = "Disabled"
857
```
858
859
### ProvisioningState
860
861
```python { .api }
862
class ProvisioningState(str, Enum):
863
"""
864
Azure Resource Manager provisioning state.
865
866
Values:
867
CREATING: Resource is being created.
868
UPDATING: Resource is being updated.
869
DELETING: Resource is being deleted.
870
SUCCEEDED: Operation completed successfully.
871
FAILED: Operation failed.
872
CANCELED: Operation was canceled.
873
"""
874
CREATING = "Creating"
875
UPDATING = "Updating"
876
DELETING = "Deleting"
877
SUCCEEDED = "Succeeded"
878
FAILED = "Failed"
879
CANCELED = "Canceled"
880
```
881
882
### PublicNetworkAccess
883
884
```python { .api }
885
class PublicNetworkAccess(str, Enum):
886
"""
887
Public network access control setting.
888
889
Values:
890
ENABLED: Public network access is allowed.
891
DISABLED: Public network access is blocked.
892
"""
893
ENABLED = "Enabled"
894
DISABLED = "Disabled"
895
```
896
897
### ReplicaProvisioningState
898
899
```python { .api }
900
class ReplicaProvisioningState(str, Enum):
901
"""
902
Provisioning state specific to replicas.
903
904
Values:
905
CREATING: Replica is being created.
906
SUCCEEDED: Replica creation completed successfully.
907
DELETING: Replica is being deleted.
908
FAILED: Replica operation failed.
909
CANCELED: Replica operation was canceled.
910
"""
911
CREATING = "Creating"
912
SUCCEEDED = "Succeeded"
913
DELETING = "Deleting"
914
FAILED = "Failed"
915
CANCELED = "Canceled"
916
```
917
918
### SnapshotStatus
919
920
```python { .api }
921
class SnapshotStatus(str, Enum):
922
"""
923
Status of a configuration snapshot.
924
925
Values:
926
PROVISIONING: Snapshot is being created.
927
READY: Snapshot is ready for use.
928
ARCHIVED: Snapshot has been archived.
929
FAILED: Snapshot creation failed.
930
"""
931
PROVISIONING = "Provisioning"
932
READY = "Ready"
933
ARCHIVED = "Archived"
934
FAILED = "Failed"
935
```
936
937
## List Result Models
938
939
### ConfigurationStoreListResult
940
941
```python { .api }
942
class ConfigurationStoreListResult:
943
"""
944
List of configuration stores with pagination support.
945
946
Attributes:
947
value (List[ConfigurationStore]): List of configuration stores.
948
next_link (str): URL for the next page of results.
949
"""
950
```
951
952
### DeletedConfigurationStoreListResult
953
954
```python { .api }
955
class DeletedConfigurationStoreListResult:
956
"""
957
List of deleted configuration stores.
958
959
Attributes:
960
value (List[DeletedConfigurationStore]): List of deleted stores.
961
next_link (str): URL for the next page of results.
962
"""
963
```
964
965
### ApiKeyListResult
966
967
```python { .api }
968
class ApiKeyListResult:
969
"""
970
List of API keys for a configuration store.
971
972
Attributes:
973
value (List[ApiKey]): List of API keys.
974
next_link (str): URL for the next page of results.
975
"""
976
```
977
978
### KeyValueListResult
979
980
```python { .api }
981
class KeyValueListResult:
982
"""
983
List of key-value pairs.
984
985
Attributes:
986
value (List[KeyValue]): List of key-value pairs.
987
next_link (str): URL for the next page of results.
988
"""
989
```
990
991
### PrivateEndpointConnectionListResult
992
993
```python { .api }
994
class PrivateEndpointConnectionListResult:
995
"""
996
List of private endpoint connections.
997
998
Attributes:
999
value (List[PrivateEndpointConnection]): List of connections.
1000
next_link (str): URL for the next page of results.
1001
"""
1002
```
1003
1004
### PrivateLinkResourceListResult
1005
1006
```python { .api }
1007
class PrivateLinkResourceListResult:
1008
"""
1009
List of private link resources.
1010
1011
Attributes:
1012
value (List[PrivateLinkResource]): List of private link resources.
1013
next_link (str): URL for the next page of results.
1014
"""
1015
```
1016
1017
### ReplicaListResult
1018
1019
```python { .api }
1020
class ReplicaListResult:
1021
"""
1022
List of configuration store replicas.
1023
1024
Attributes:
1025
value (List[Replica]): List of replicas.
1026
next_link (str): URL for the next page of results.
1027
"""
1028
```
1029
1030
### OperationDefinitionListResult
1031
1032
```python { .api }
1033
class OperationDefinitionListResult:
1034
"""
1035
List of available operations.
1036
1037
Attributes:
1038
value (List[OperationDefinition]): List of operation definitions.
1039
next_link (str): URL for the next page of results.
1040
"""
1041
```
1042
1043
## Service Specification Models
1044
1045
### ServiceSpecification
1046
1047
```python { .api }
1048
class ServiceSpecification:
1049
"""
1050
Specification of the service for monitoring and diagnostics.
1051
1052
Attributes:
1053
log_specifications (List[LogSpecification]): Log specifications.
1054
metric_specifications (List[MetricSpecification]): Metric specifications.
1055
"""
1056
```
1057
1058
### LogSpecification
1059
1060
```python { .api }
1061
class LogSpecification:
1062
"""
1063
Specification for log collection.
1064
1065
Attributes:
1066
name (str): Log category name.
1067
display_name (str): Display name for the log category.
1068
blob_duration (str): Duration for blob storage.
1069
"""
1070
```
1071
1072
### MetricSpecification
1073
1074
```python { .api }
1075
class MetricSpecification:
1076
"""
1077
Specification for metric collection.
1078
1079
Attributes:
1080
name (str): Metric name.
1081
display_name (str): Display name for the metric.
1082
display_description (str): Description of the metric.
1083
unit (str): Unit of measurement.
1084
aggregation_type (str): Aggregation type.
1085
internal_metric_name (str): Internal metric name.
1086
dimensions (List[MetricDimension]): Metric dimensions.
1087
fill_gap_with_zero (bool): Whether to fill gaps with zero.
1088
"""
1089
```
1090
1091
### MetricDimension
1092
1093
```python { .api }
1094
class MetricDimension:
1095
"""
1096
Dimension for metric specification.
1097
1098
Attributes:
1099
name (str): Dimension name.
1100
display_name (str): Display name for the dimension.
1101
internal_name (str): Internal dimension name.
1102
to_be_exported_for_shoebox (bool): Whether to export for Shoebox.
1103
"""
1104
```
1105
1106
## Usage Examples
1107
1108
### Working with Model Validation
1109
1110
```python { .api }
1111
def demonstrate_model_validation():
1112
"""Show how to work with model validation and type checking."""
1113
1114
# Valid SKU creation
1115
try:
1116
free_sku = Sku(name="Free")
1117
standard_sku = Sku(name="Standard")
1118
print("✅ Valid SKUs created")
1119
except ValueError as e:
1120
print(f"❌ SKU validation error: {e}")
1121
1122
# Valid identity configuration
1123
try:
1124
system_identity = ResourceIdentity(type=IdentityType.SYSTEM_ASSIGNED)
1125
1126
user_identity = ResourceIdentity(
1127
type=IdentityType.USER_ASSIGNED,
1128
user_assigned_identities={
1129
"/subscriptions/.../resourceGroups/.../providers/Microsoft.ManagedIdentity/userAssignedIdentities/myIdentity": UserIdentity()
1130
}
1131
)
1132
print("✅ Valid identities created")
1133
except Exception as e:
1134
print(f"❌ Identity validation error: {e}")
1135
1136
# Model composition
1137
try:
1138
store = ConfigurationStore(
1139
location="East US",
1140
sku=standard_sku,
1141
identity=system_identity,
1142
tags={"Environment": "Production"},
1143
public_network_access=PublicNetworkAccess.ENABLED,
1144
disable_local_auth=False
1145
)
1146
print("✅ Configuration store model created")
1147
print(f" Location: {store.location}")
1148
print(f" SKU: {store.sku.name}")
1149
print(f" Identity: {store.identity.type}")
1150
except Exception as e:
1151
print(f"❌ Store creation error: {e}")
1152
1153
demonstrate_model_validation()
1154
```
1155
1156
### Enum Usage Patterns
1157
1158
```python { .api }
1159
def demonstrate_enum_usage():
1160
"""Show common patterns for using enumerations."""
1161
1162
# Connection status checking
1163
def handle_connection_status(status: ConnectionStatus):
1164
if status == ConnectionStatus.PENDING:
1165
print("🟡 Connection is pending approval")
1166
return "waiting"
1167
elif status == ConnectionStatus.APPROVED:
1168
print("✅ Connection is approved and active")
1169
return "active"
1170
elif status == ConnectionStatus.REJECTED:
1171
print("❌ Connection was rejected")
1172
return "rejected"
1173
elif status == ConnectionStatus.DISCONNECTED:
1174
print("🔌 Connection is disconnected")
1175
return "disconnected"
1176
1177
# Test different statuses
1178
for status in ConnectionStatus:
1179
result = handle_connection_status(status)
1180
print(f" Status {status} -> {result}")
1181
1182
# Provisioning state patterns
1183
def is_terminal_state(state: ProvisioningState) -> bool:
1184
"""Check if a provisioning state is terminal (no further changes expected)."""
1185
return state in [
1186
ProvisioningState.SUCCEEDED,
1187
ProvisioningState.FAILED,
1188
ProvisioningState.CANCELED
1189
]
1190
1191
# Test provisioning states
1192
print(f"\nTerminal state checking:")
1193
for state in ProvisioningState:
1194
is_terminal = is_terminal_state(state)
1195
print(f" {state}: {'Terminal' if is_terminal else 'In Progress'}")
1196
1197
# Snapshot composition type usage
1198
def get_snapshot_description(composition: CompositionType) -> str:
1199
descriptions = {
1200
CompositionType.KEY: "Keys only (labels ignored)",
1201
CompositionType.KEY_LABEL: "Keys with labels"
1202
}
1203
return descriptions.get(composition, "Unknown composition type")
1204
1205
print(f"\nSnapshot composition types:")
1206
for comp_type in CompositionType:
1207
desc = get_snapshot_description(comp_type)
1208
print(f" {comp_type}: {desc}")
1209
1210
demonstrate_enum_usage()
1211
```
1212
1213
### Model Serialization
1214
1215
```python { .api }
1216
def demonstrate_model_serialization():
1217
"""Show how models serialize to/from dictionaries and JSON."""
1218
1219
# Create a complex model
1220
store = ConfigurationStore(
1221
location="West US 2",
1222
sku=Sku(name="Standard"),
1223
tags={
1224
"Environment": "Production",
1225
"Team": "Platform",
1226
"CostCenter": "Engineering"
1227
},
1228
identity=ResourceIdentity(type=IdentityType.SYSTEM_ASSIGNED),
1229
public_network_access=PublicNetworkAccess.ENABLED,
1230
disable_local_auth=False,
1231
soft_delete_retention_in_days=7,
1232
enable_purge_protection=True
1233
)
1234
1235
print("Model created with properties:")
1236
print(f" Location: {store.location}")
1237
print(f" SKU: {store.sku.name}")
1238
print(f" Identity: {store.identity.type}")
1239
print(f" Public Access: {store.public_network_access}")
1240
print(f" Local Auth Disabled: {store.disable_local_auth}")
1241
print(f" Soft Delete Retention: {store.soft_delete_retention_in_days} days")
1242
print(f" Purge Protection: {store.enable_purge_protection}")
1243
print(f" Tags: {store.tags}")
1244
1245
# Working with snapshot filters
1246
filters = [
1247
KeyValueFilter(key="MyApp:*", label="Production"),
1248
KeyValueFilter(key="Shared:*", label="Production"),
1249
KeyValueFilter(key="FeatureFlags:*") # No label specified
1250
]
1251
1252
snapshot = Snapshot(
1253
filters=filters,
1254
composition_type=CompositionType.KEY_LABEL,
1255
retention_period=7776000, # 90 days
1256
tags={"Type": "Release", "Version": "2.1.0"}
1257
)
1258
1259
print(f"\nSnapshot configuration:")
1260
print(f" Filters: {len(snapshot.filters)} filter(s)")
1261
for i, filter_obj in enumerate(snapshot.filters):
1262
label_info = f"label='{filter_obj.label}'" if filter_obj.label else "no label"
1263
print(f" {i+1}. key='{filter_obj.key}', {label_info}")
1264
print(f" Composition: {snapshot.composition_type}")
1265
print(f" Retention: {snapshot.retention_period} seconds")
1266
print(f" Tags: {snapshot.tags}")
1267
1268
demonstrate_model_serialization()
1269
```
1270
1271
This comprehensive models and types reference provides complete coverage of all data structures in the `azure-mgmt-appconfiguration` package, enabling developers to understand and work with every aspect of the Azure App Configuration Management API.