0
# Certificates and Domains Management
1

2
Comprehensive SSL/TLS certificate and custom domain management including certificate provisioning, renewals, bindings, domain registration, and DNS configuration for Azure web services.
3

4
## Capabilities
5

6
### SSL/TLS Certificate Management
7

8
Manage SSL/TLS certificates for securing web applications with HTTPS endpoints.
9

10
```python { .api }
11
def create_or_update(
12
    resource_group_name: str,
13
    name: str,
14
    certificate_envelope: Certificate,
15
    **kwargs
16
) -> Certificate:
17
    """
18
    Creates or updates an SSL certificate.
19
    
20
    Parameters:
21
    - resource_group_name (str): Name of the resource group
22
    - name (str): Name of the certificate
23
    - certificate_envelope (Certificate): Certificate configuration and properties
24
    
25
    Returns:
26
    Certificate: Created or updated certificate resource
27
    """
28

29
def get(
30
    resource_group_name: str,
31
    name: str,
32
    **kwargs
33
) -> Certificate:
34
    """
35
    Gets details of a specific certificate.
36
    
37
    Parameters:
38
    - resource_group_name (str): Name of the resource group
39
    - name (str): Name of the certificate
40
    
41
    Returns:
42
    Certificate: Certificate details and properties
43
    """
44

45
def delete(
46
    resource_group_name: str,
47
    name: str,
48
    **kwargs
49
) -> None:
50
    """
51
    Deletes an SSL certificate.
52
    
53
    Parameters:
54
    - resource_group_name (str): Name of the resource group
55
    - name (str): Name of the certificate
56
    """
57

58
def list(self, **kwargs) -> List[Certificate]:
59
    """
60
    Lists all certificates in the subscription.
61
    
62
    Returns:
63
    List[Certificate]: List of certificates
64
    """
65

66
def list_by_resource_group(
67
    resource_group_name: str,
68
    **kwargs
69
) -> List[Certificate]:
70
    """
71
    Lists certificates in a specific resource group.
72
    
73
    Parameters:
74
    - resource_group_name (str): Name of the resource group
75
    
76
    Returns:
77
    List[Certificate]: List of certificates in the resource group
78
    """
79

80
def update(
81
    resource_group_name: str,
82
    name: str,
83
    certificate_patch_resource: CertificatePatchResource,
84
    **kwargs
85
) -> Certificate:
86
    """
87
    Updates an existing certificate.
88
    
89
    Parameters:
90
    - resource_group_name (str): Name of the resource group
91
    - name (str): Name of the certificate
92
    - certificate_patch_resource (CertificatePatchResource): Properties to update
93
    
94
    Returns:
95
    Certificate: Updated certificate
96
    """
97
```
98

99
### Certificate Orders Management
100

101
Manage App Service Certificate orders for automated certificate provisioning and lifecycle management.
102

103
```python { .api }
104
def begin_create_or_update(
105
    resource_group_name: str,
106
    certificate_order_name: str,
107
    certificate_distinguished_name: AppServiceCertificateOrder,
108
    **kwargs
109
) -> LROPoller[AppServiceCertificateOrder]:
110
    """
111
    Creates or updates an App Service Certificate order.
112
    
113
    Parameters:
114
    - resource_group_name (str): Name of the resource group
115
    - certificate_order_name (str): Name of the certificate order
116
    - certificate_distinguished_name (AppServiceCertificateOrder): Order configuration
117
    
118
    Returns:
119
    LROPoller[AppServiceCertificateOrder]: Long-running operation poller
120
    """
121

122
def get(
123
    resource_group_name: str,
124
    certificate_order_name: str,
125
    **kwargs
126
) -> AppServiceCertificateOrder:
127
    """
128
    Gets details of a certificate order.
129
    
130
    Parameters:
131
    - resource_group_name (str): Name of the resource group
132
    - certificate_order_name (str): Name of the certificate order
133
    
134
    Returns:
135
    AppServiceCertificateOrder: Certificate order details
136
    """
137

138
def reissue(
139
    resource_group_name: str,
140
    certificate_order_name: str,
141
    reissue_certificate_order_request: ReissueCertificateOrderRequest,
142
    **kwargs
143
) -> None:
144
    """
145
    Reissues an existing certificate order.
146
    
147
    Parameters:
148
    - resource_group_name (str): Name of the resource group
149
    - certificate_order_name (str): Name of the certificate order
150
    - reissue_certificate_order_request (ReissueCertificateOrderRequest): Reissue parameters
151
    """
152

153
def renew(
154
    resource_group_name: str,
155
    certificate_order_name: str,
156
    renew_certificate_order_request: RenewCertificateOrderRequest,
157
    **kwargs
158
) -> None:
159
    """
160
    Renews an existing certificate order.
161
    
162
    Parameters:
163
    - resource_group_name (str): Name of the resource group
164
    - certificate_order_name (str): Name of the certificate order
165
    - renew_certificate_order_request (RenewCertificateOrderRequest): Renewal parameters
166
    """
167
```
168

169
### Domain Management
170

171
Manage custom domains for web applications including domain registration, DNS configuration, and domain verification.
172

173
```python { .api }
174
def begin_create_or_update(
175
    resource_group_name: str,
176
    domain_name: str,
177
    domain: Domain,
178
    **kwargs
179
) -> LROPoller[Domain]:
180
    """
181
    Creates or updates a custom domain registration.
182
    
183
    Parameters:
184
    - resource_group_name (str): Name of the resource group
185
    - domain_name (str): Name of the domain
186
    - domain (Domain): Domain configuration and properties
187
    
188
    Returns:
189
    LROPoller[Domain]: Long-running operation poller for domain creation
190
    """
191

192
def get(
193
    resource_group_name: str,
194
    domain_name: str,
195
    **kwargs
196
) -> Domain:
197
    """
198
    Gets details of a specific domain.
199
    
200
    Parameters:
201
    - resource_group_name (str): Name of the resource group
202
    - domain_name (str): Name of the domain
203
    
204
    Returns:
205
    Domain: Domain details and configuration
206
    """
207

208
def delete(
209
    resource_group_name: str,
210
    domain_name: str,
211
    force_hard_delete_domain: Optional[bool] = None,
212
    **kwargs
213
) -> None:
214
    """
215
    Deletes a domain registration.
216
    
217
    Parameters:
218
    - resource_group_name (str): Name of the resource group
219
    - domain_name (str): Name of the domain
220
    - force_hard_delete_domain (bool, optional): Force permanent deletion
221
    """
222

223
def list(self, **kwargs) -> List[Domain]:
224
    """
225
    Lists all domains in the subscription.
226
    
227
    Returns:
228
    List[Domain]: List of domains
229
    """
230

231
def list_ownership_identifiers(
232
    resource_group_name: str,
233
    domain_name: str,
234
    **kwargs
235
) -> List[DomainOwnershipIdentifier]:
236
    """
237
    Lists ownership identifiers for domain verification.
238
    
239
    Parameters:
240
    - resource_group_name (str): Name of the resource group
241
    - domain_name (str): Name of the domain
242
    
243
    Returns:
244
    List[DomainOwnershipIdentifier]: Domain ownership verification identifiers
245
    """
246

247
def renew(
248
    resource_group_name: str,
249
    domain_name: str,
250
    **kwargs
251
) -> None:
252
    """
253
    Renews a domain registration.
254
    
255
    Parameters:
256
    - resource_group_name (str): Name of the resource group
257
    - domain_name (str): Name of the domain
258
    """
259
```
260

261
### Site Certificate Bindings
262

263
Manage SSL certificate bindings for web applications and their custom domains.
264

265
```python { .api }
266
def create_or_update(
267
    resource_group_name: str,
268
    name: str,
269
    certificate_name: str,
270
    certificate_envelope: Certificate,
271
    **kwargs
272
) -> Certificate:
273
    """
274
    Creates or updates a certificate binding for a web app.
275
    
276
    Parameters:
277
    - resource_group_name (str): Name of the resource group
278
    - name (str): Name of the web app
279
    - certificate_name (str): Name of the certificate
280
    - certificate_envelope (Certificate): Certificate binding configuration
281
    
282
    Returns:
283
    Certificate: Certificate binding details
284
    """
285

286
def get(
287
    resource_group_name: str,
288
    name: str,
289
    certificate_name: str,
290
    **kwargs
291
) -> Certificate:
292
    """
293
    Gets a certificate binding for a web app.
294
    
295
    Parameters:
296
    - resource_group_name (str): Name of the resource group
297
    - name (str): Name of the web app
298
    - certificate_name (str): Name of the certificate
299
    
300
    Returns:
301
    Certificate: Certificate binding details
302
    """
303

304
def delete(
305
    resource_group_name: str,
306
    name: str,
307
    certificate_name: str,
308
    **kwargs
309
) -> None:
310
    """
311
    Removes a certificate binding from a web app.
312
    
313
    Parameters:
314
    - resource_group_name (str): Name of the resource group
315
    - name (str): Name of the web app
316
    - certificate_name (str): Name of the certificate
317
    """
318

319
def list(
320
    resource_group_name: str,
321
    name: str,
322
    **kwargs
323
) -> List[Certificate]:
324
    """
325
    Lists certificate bindings for a web app.
326
    
327
    Parameters:
328
    - resource_group_name (str): Name of the resource group
329
    - name (str): Name of the web app
330
    
331
    Returns:
332
    List[Certificate]: Certificate bindings for the web app
333
    """
334
```
335

336
### Top-Level Domain Information
337

338
Query available top-level domains and their registration requirements.
339

340
```python { .api }
341
def list(self, **kwargs) -> List[TopLevelDomain]:
342
    """
343
    Lists all available top-level domains.
344
    
345
    Returns:
346
    List[TopLevelDomain]: Available top-level domains
347
    """
348

349
def get(
350
    name: str,
351
    **kwargs
352
) -> TopLevelDomain:
353
    """
354
    Gets information about a specific top-level domain.
355
    
356
    Parameters:
357
    - name (str): Name of the top-level domain (e.g., 'com', 'org')
358
    
359
    Returns:
360
    TopLevelDomain: Top-level domain information and requirements
361
    """
362

363
def list_agreements(
364
    name: str,
365
    agreement_option: TopLevelDomainAgreementOption,
366
    **kwargs
367
) -> List[TldLegalAgreement]:
368
    """
369
    Lists legal agreements for a top-level domain.
370
    
371
    Parameters:
372
    - name (str): Name of the top-level domain
373
    - agreement_option (TopLevelDomainAgreementOption): Agreement options
374
    
375
    Returns:
376
    List[TldLegalAgreement]: Legal agreements for the domain
377
    """
378
```
379

380
## Types
381

382
```python { .api }
383
class Certificate:
384
    """Represents an SSL certificate resource."""
385
    id: Optional[str]
386
    name: Optional[str]
387
    type: Optional[str]
388
    location: str
389
    tags: Optional[Dict[str, str]]
390
    friendly_name: Optional[str]
391
    subject_name: Optional[str]
392
    host_names: Optional[List[str]]
393
    pfx_blob: Optional[bytes]
394
    site_name: Optional[str]
395
    self_link: Optional[str]
396
    issuer: Optional[str]
397
    issue_date: Optional[datetime]
398
    expiration_date: Optional[datetime]
399
    password: Optional[str]
400
    thumbprint: Optional[str]
401
    valid: Optional[bool]
402
    public_key_hash: Optional[str]
403
    server_farm_id: Optional[str]
404
    key_vault_id: Optional[str]
405
    key_vault_secret_name: Optional[str]
406
    key_vault_secret_status: Optional[KeyVaultSecretStatus]
407

408
class AppServiceCertificateOrder:
409
    """Represents an App Service certificate order."""
410
    id: Optional[str]
411
    name: Optional[str]
412
    type: Optional[str]
413
    location: str
414
    tags: Optional[Dict[str, str]]
415
    certificates: Optional[Dict[str, AppServiceCertificate]]
416
    distinguished_name: Optional[str]
417
    domain_verification_token: Optional[str]
418
    validity_in_years: Optional[int]
419
    key_size: Optional[int]
420
    product_type: CertificateProductType
421
    auto_renew: Optional[bool]
422
    provisioning_state: Optional[ProvisioningState]
423
    status: Optional[CertificateOrderStatus]
424
    signed_certificate: Optional[CertificateDetails]
425
    csr: Optional[str]
426
    intermediate: Optional[CertificateDetails]
427
    root: Optional[CertificateDetails]
428
    serial_number: Optional[str]
429
    last_certificate_issuance_time: Optional[datetime]
430
    expiration_time: Optional[datetime]
431
    is_private_key_external: Optional[bool]
432
    app_service_certificate_not_renewable_reasons: Optional[List[AppServiceCertificateOrderPropertiesAppServiceCertificateNotRenewableReasonsItem]]
433
    next_auto_renewal_time_stamp: Optional[datetime]
434
    contact: Optional[CertificateOrderContact]
435

436
class Domain:
437
    """Represents a custom domain resource."""
438
    id: Optional[str]
439
    name: Optional[str]
440
    type: Optional[str]
441
    location: str
442
    tags: Optional[Dict[str, str]]
443
    contact_admin: Contact
444
    contact_billing: Contact
445
    contact_registrant: Contact
446
    contact_tech: Contact
447
    registration_status: Optional[DomainStatus]
448
    provisioning_state: Optional[ProvisioningState]
449
    name_servers: Optional[List[str]]
450
    privacy: Optional[bool]
451
    created_time: Optional[datetime]
452
    expiration_time: Optional[datetime]
453
    last_renewed_time: Optional[datetime]
454
    auto_renew: Optional[bool]
455
    ready_for_dns_record_management: Optional[bool]
456
    managed_host_names: Optional[List[HostName]]
457
    consent: DomainPurchaseConsent
458
    domain_not_renewable_reasons: Optional[List[DomainPropertiesDomainNotRenewableReasonsItem]]
459
    dns_type: Optional[DnsType]
460
    dns_zone_id: Optional[str]
461
    target_dns_type: Optional[DnsType]
462
    auth_code: Optional[str]
463

464
class CertificatePatchResource:
465
    """Properties for updating a certificate."""
466
    password: Optional[str]
467
    host_names: Optional[List[str]]
468
    server_farm_id: Optional[str]
469
    key_vault_id: Optional[str]
470
    key_vault_secret_name: Optional[str]
471

472
class DomainOwnershipIdentifier:
473
    """Domain ownership verification identifier."""
474
    id: Optional[str]
475
    name: Optional[str]
476
    ownership_id: Optional[str]
477

478
class TopLevelDomain:
479
    """Top-level domain information."""
480
    id: Optional[str]
481
    name: Optional[str]
482
    type: Optional[str]
483
    privacy: Optional[bool]
484

485
class Contact:
486
    """Contact information for domain registration."""
487
    address_mailing: Optional[Address]
488
    email: str
489
    fax: Optional[str]
490
    job_title: Optional[str]
491
    name_first: str
492
    name_last: str
493
    name_middle: Optional[str]
494
    organization: Optional[str]
495
    phone: str
496

497
class Address:
498
    """Mailing address information."""
499
    address1: str
500
    address2: Optional[str]
501
    city: str
502
    country: str
503
    postal_code: str
504
    state: str
505

506
class ReissueCertificateOrderRequest:
507
    """Request for reissuing a certificate order."""
508
    key_size: Optional[int]
509
    distinguished_name: Optional[str]
510
    csr: Optional[str]
511
    delay_existing_revoke_in_hours: Optional[int]
512

513
class RenewCertificateOrderRequest:
514
    """Request for renewing a certificate order."""
515
    key_size: Optional[int]
516
    distinguished_name: Optional[str]
517
    csr: Optional[str]
518
```