ACM (acm)

Primary Models

Primary models are models that you can act on directly. They are the models that represent resources in the AWS service, and are acted on by the managers.

pydantic model botocraft.services.acm.ACMCertificate

Bases: TagsDictMixin, PrimaryBoto3Model

Contains metadata about an ACM certificate.

This structure is returned in the response to a DescribeCertificate request.

Show JSON schema

{
   "title": "ACMCertificate",
   "description": "Contains metadata about an ACM certificate.\n\nThis structure is returned in the response to a DescribeCertificate request.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "KeyAlgorithm": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Keyalgorithm"
      },
      "CertificateArn": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Certificatearn"
      },
      "DomainName": {
         "default": null,
         "title": "Domainname",
         "type": "string"
      },
      "SubjectAlternativeNames": {
         "items": {
            "type": "string"
         },
         "title": "Subjectalternativenames",
         "type": "array"
      },
      "ManagedBy": {
         "const": "CLOUDFRONT",
         "default": null,
         "title": "Managedby",
         "type": "string"
      },
      "DomainValidationOptions": {
         "items": {
            "$ref": "#/$defs/DomainValidation"
         },
         "title": "Domainvalidationoptions",
         "type": "array"
      },
      "Serial": {
         "default": null,
         "title": "Serial",
         "type": "string"
      },
      "Subject": {
         "default": null,
         "title": "Subject",
         "type": "string"
      },
      "Issuer": {
         "default": null,
         "title": "Issuer",
         "type": "string"
      },
      "CreatedAt": {
         "default": null,
         "format": "date-time",
         "title": "Createdat",
         "type": "string"
      },
      "IssuedAt": {
         "default": null,
         "format": "date-time",
         "title": "Issuedat",
         "type": "string"
      },
      "ImportedAt": {
         "default": null,
         "format": "date-time",
         "title": "Importedat",
         "type": "string"
      },
      "Status": {
         "default": null,
         "enum": [
            "PENDING_VALIDATION",
            "ISSUED",
            "INACTIVE",
            "EXPIRED",
            "VALIDATION_TIMED_OUT",
            "REVOKED",
            "FAILED"
         ],
         "title": "Status",
         "type": "string"
      },
      "RevokedAt": {
         "default": null,
         "format": "date-time",
         "title": "Revokedat",
         "type": "string"
      },
      "RevocationReason": {
         "default": null,
         "enum": [
            "UNSPECIFIED",
            "KEY_COMPROMISE",
            "CA_COMPROMISE",
            "AFFILIATION_CHANGED",
            "SUPERCEDED",
            "SUPERSEDED",
            "CESSATION_OF_OPERATION",
            "CERTIFICATE_HOLD",
            "REMOVE_FROM_CRL",
            "PRIVILEGE_WITHDRAWN",
            "A_A_COMPROMISE"
         ],
         "title": "Revocationreason",
         "type": "string"
      },
      "NotBefore": {
         "default": null,
         "format": "date-time",
         "title": "Notbefore",
         "type": "string"
      },
      "NotAfter": {
         "default": null,
         "format": "date-time",
         "title": "Notafter",
         "type": "string"
      },
      "SignatureAlgorithm": {
         "default": null,
         "title": "Signaturealgorithm",
         "type": "string"
      },
      "InUseBy": {
         "items": {
            "type": "string"
         },
         "title": "Inuseby",
         "type": "array"
      },
      "FailureReason": {
         "default": null,
         "enum": [
            "NO_AVAILABLE_CONTACTS",
            "ADDITIONAL_VERIFICATION_REQUIRED",
            "DOMAIN_NOT_ALLOWED",
            "INVALID_PUBLIC_DOMAIN",
            "DOMAIN_VALIDATION_DENIED",
            "CAA_ERROR",
            "PCA_LIMIT_EXCEEDED",
            "PCA_INVALID_ARN",
            "PCA_INVALID_STATE",
            "PCA_REQUEST_FAILED",
            "PCA_NAME_CONSTRAINTS_VALIDATION",
            "PCA_RESOURCE_NOT_FOUND",
            "PCA_INVALID_ARGS",
            "PCA_INVALID_DURATION",
            "PCA_ACCESS_DENIED",
            "SLR_NOT_FOUND",
            "OTHER"
         ],
         "title": "Failurereason",
         "type": "string"
      },
      "Type": {
         "default": null,
         "enum": [
            "IMPORTED",
            "AMAZON_ISSUED",
            "PRIVATE"
         ],
         "title": "Type",
         "type": "string"
      },
      "RenewalSummary": {
         "$ref": "#/$defs/ACMRenewalSummary",
         "default": null
      },
      "KeyUsages": {
         "items": {
            "$ref": "#/$defs/KeyUsage"
         },
         "title": "Keyusages",
         "type": "array"
      },
      "ExtendedKeyUsages": {
         "items": {
            "$ref": "#/$defs/ExtendedKeyUsage"
         },
         "title": "Extendedkeyusages",
         "type": "array"
      },
      "CertificateAuthorityArn": {
         "default": null,
         "title": "Certificateauthorityarn",
         "type": "string"
      },
      "RenewalEligibility": {
         "default": null,
         "enum": [
            "ELIGIBLE",
            "INELIGIBLE"
         ],
         "title": "Renewaleligibility",
         "type": "string"
      },
      "Options": {
         "$ref": "#/$defs/CertificateOptions",
         "default": null
      },
      "Tags": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/Tag"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Tags"
      }
   },
   "$defs": {
      "ACMHttpRedirect": {
         "description": "Contains information for HTTP-based domain validation of certificates requested\nthrough Amazon CloudFront and issued by ACM.\n\nThis field exists only when the certificate type is ``AMAZON_ISSUED`` and the validation method is ``HTTP``.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "RedirectFrom": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Redirectfrom"
            },
            "RedirectTo": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Redirectto"
            }
         },
         "title": "ACMHttpRedirect",
         "type": "object"
      },
      "ACMRenewalSummary": {
         "description": "Contains information about the status of ACM's `managed renewal <https://docs.aws.amazon.com/acm/latest/userguide/acm-\nrenewal.html>`_ for the certificate. This structure exists only when the certificate type is ``AMAZON_ISSUED``.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "RenewalStatus": {
               "enum": [
                  "PENDING_AUTO_RENEWAL",
                  "PENDING_VALIDATION",
                  "SUCCESS",
                  "FAILED"
               ],
               "title": "Renewalstatus",
               "type": "string"
            },
            "DomainValidationOptions": {
               "items": {
                  "$ref": "#/$defs/DomainValidation"
               },
               "title": "Domainvalidationoptions",
               "type": "array"
            },
            "RenewalStatusReason": {
               "anyOf": [
                  {
                     "enum": [
                        "NO_AVAILABLE_CONTACTS",
                        "ADDITIONAL_VERIFICATION_REQUIRED",
                        "DOMAIN_NOT_ALLOWED",
                        "INVALID_PUBLIC_DOMAIN",
                        "DOMAIN_VALIDATION_DENIED",
                        "CAA_ERROR",
                        "PCA_LIMIT_EXCEEDED",
                        "PCA_INVALID_ARN",
                        "PCA_INVALID_STATE",
                        "PCA_REQUEST_FAILED",
                        "PCA_NAME_CONSTRAINTS_VALIDATION",
                        "PCA_RESOURCE_NOT_FOUND",
                        "PCA_INVALID_ARGS",
                        "PCA_INVALID_DURATION",
                        "PCA_ACCESS_DENIED",
                        "SLR_NOT_FOUND",
                        "OTHER"
                     ],
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Renewalstatusreason"
            },
            "UpdatedAt": {
               "format": "date-time",
               "title": "Updatedat",
               "type": "string"
            }
         },
         "required": [
            "RenewalStatus",
            "DomainValidationOptions",
            "UpdatedAt"
         ],
         "title": "ACMRenewalSummary",
         "type": "object"
      },
      "ACMResourceRecord": {
         "description": "Contains a DNS record value that you can use to validate ownership or control of a\ndomain.\n\nThis is used by the DescribeCertificate action.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Name": {
               "title": "Name",
               "type": "string"
            },
            "Type": {
               "const": "CNAME",
               "title": "Type",
               "type": "string"
            },
            "Value": {
               "title": "Value",
               "type": "string"
            }
         },
         "required": [
            "Name",
            "Type",
            "Value"
         ],
         "title": "ACMResourceRecord",
         "type": "object"
      },
      "CertificateOptions": {
         "description": "Structure that contains options for your certificate. You can use this structure to\nspecify whether to opt in to or out of certificate transparency logging and export\nyour certificate.\n\nSome browsers require that public certificates issued for your domain be recorded in\na log. Certificates that are not logged typically generate a browser error.\nTransparency makes it possible for you to detect SSL/TLS certificates that have been\nmistakenly or maliciously issued for your domain. For general information, see\n`Certificate Transparency Logging <https://docs.aws.amazon.com/acm/latest/userguide/acm-concepts.html#concept-transparency>`_.\n\nYou can export public ACM certificates to use with Amazon Web Services services as\nwell as outside Amazon Web Services Cloud. For more information, see\n`Certificate Manager exportable public certificate <https://docs.aws.amazon.com/acm/latest/userguide/acm-exportable-certificates.html>`_.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "CertificateTransparencyLoggingPreference": {
               "anyOf": [
                  {
                     "enum": [
                        "ENABLED",
                        "DISABLED"
                     ],
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Certificatetransparencyloggingpreference"
            },
            "Export": {
               "anyOf": [
                  {
                     "enum": [
                        "ENABLED",
                        "DISABLED"
                     ],
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Export"
            }
         },
         "title": "CertificateOptions",
         "type": "object"
      },
      "DomainValidation": {
         "description": "Contains information about the validation of each domain name in the certificate.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "DomainName": {
               "title": "Domainname",
               "type": "string"
            },
            "ValidationEmails": {
               "anyOf": [
                  {
                     "items": {
                        "type": "string"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Validationemails"
            },
            "ValidationDomain": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Validationdomain"
            },
            "ValidationStatus": {
               "anyOf": [
                  {
                     "enum": [
                        "PENDING_VALIDATION",
                        "SUCCESS",
                        "FAILED"
                     ],
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Validationstatus"
            },
            "ResourceRecord": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ACMResourceRecord"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null
            },
            "HttpRedirect": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ACMHttpRedirect"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null
            },
            "ValidationMethod": {
               "anyOf": [
                  {
                     "enum": [
                        "EMAIL",
                        "DNS",
                        "HTTP"
                     ],
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Validationmethod"
            }
         },
         "required": [
            "DomainName"
         ],
         "title": "DomainValidation",
         "type": "object"
      },
      "ExtendedKeyUsage": {
         "description": "The Extended Key Usage X.509 v3 extension defines one or more purposes for which the\npublic key can be used.\n\nThis is in addition to or in place of the basic purposes specified by the Key Usage\nextension.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Name": {
               "anyOf": [
                  {
                     "enum": [
                        "TLS_WEB_SERVER_AUTHENTICATION",
                        "TLS_WEB_CLIENT_AUTHENTICATION",
                        "CODE_SIGNING",
                        "EMAIL_PROTECTION",
                        "TIME_STAMPING",
                        "OCSP_SIGNING",
                        "IPSEC_END_SYSTEM",
                        "IPSEC_TUNNEL",
                        "IPSEC_USER",
                        "ANY",
                        "NONE",
                        "CUSTOM"
                     ],
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Name"
            },
            "OID": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Oid"
            }
         },
         "title": "ExtendedKeyUsage",
         "type": "object"
      },
      "KeyUsage": {
         "description": "The Key Usage X.509 v3 extension defines the purpose of the public key contained in\nthe certificate.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Name": {
               "anyOf": [
                  {
                     "enum": [
                        "DIGITAL_SIGNATURE",
                        "NON_REPUDIATION",
                        "KEY_ENCIPHERMENT",
                        "DATA_ENCIPHERMENT",
                        "KEY_AGREEMENT",
                        "CERTIFICATE_SIGNING",
                        "CRL_SIGNING",
                        "ENCIPHER_ONLY",
                        "DECIPHER_ONLY",
                        "ANY",
                        "CUSTOM"
                     ],
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Name"
            }
         },
         "title": "KeyUsage",
         "type": "object"
      },
      "Tag": {
         "description": "The metadata that you apply to a resource to help you categorize and\norganize them. Each tag consists of a key and an optional value. You define\nthem.\n\nThe following basic restrictions apply to tags:\n\n* Maximum number of tags per resource - 50\n* For each resource, each tag key must be unique, and each tag key can have\n  only one value.\n* Maximum key length - 128 Unicode characters in UTF-8\n* Maximum value length - 256 Unicode characters in UTF-8\n* If your tagging schema is used across multiple services and resources,\n  remember that other services may have restrictions on allowed characters.\n  Generally allowed characters are: letters, numbers, and spaces representable in\n  UTF-8, and the following characters: + - = . _ : / @.\n* Tag keys and values are case-sensitive.\n* Do not use ``aws:``, ``AWS:``, or any upper or lowercase combination of such\n  as a prefix for either keys or values as it is reserved for Amazon Web Services\n  use. You cannot edit or delete tag keys or values with this prefix. Tags with\n  this prefix do not count against your tags per resource limit.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Key": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Key"
            },
            "Value": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Value"
            }
         },
         "title": "Tag",
         "type": "object"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• CertificateArn (str | None)

• CertificateAuthorityArn (str)

• CreatedAt (datetime.datetime)

• DomainName (str)

• DomainValidationOptions (list[botocraft.services.acm.DomainValidation])

• ExtendedKeyUsages (list[botocraft.services.acm.ExtendedKeyUsage])

• FailureReason (Literal['NO_AVAILABLE_CONTACTS', 'ADDITIONAL_VERIFICATION_REQUIRED', 'DOMAIN_NOT_ALLOWED', 'INVALID_PUBLIC_DOMAIN', 'DOMAIN_VALIDATION_DENIED', 'CAA_ERROR', 'PCA_LIMIT_EXCEEDED', 'PCA_INVALID_ARN', 'PCA_INVALID_STATE', 'PCA_REQUEST_FAILED', 'PCA_NAME_CONSTRAINTS_VALIDATION', 'PCA_RESOURCE_NOT_FOUND', 'PCA_INVALID_ARGS', 'PCA_INVALID_DURATION', 'PCA_ACCESS_DENIED', 'SLR_NOT_FOUND', 'OTHER'])

• ImportedAt (datetime.datetime)

• InUseBy (list[str])

• IssuedAt (datetime.datetime)

• Issuer (str)

• KeyAlgorithm (str | None)

• KeyUsages (list[botocraft.services.acm.KeyUsage])

• ManagedBy (Literal['CLOUDFRONT'])

• NotAfter (datetime.datetime)

• NotBefore (datetime.datetime)

• Options (botocraft.services.acm.CertificateOptions)

• RenewalEligibility (Literal['ELIGIBLE', 'INELIGIBLE'])

• RenewalSummary (botocraft.services.acm.ACMRenewalSummary)

• RevocationReason (Literal['UNSPECIFIED', 'KEY_COMPROMISE', 'CA_COMPROMISE', 'AFFILIATION_CHANGED', 'SUPERCEDED', 'SUPERSEDED', 'CESSATION_OF_OPERATION', 'CERTIFICATE_HOLD', 'REMOVE_FROM_CRL', 'PRIVILEGE_WITHDRAWN', 'A_A_COMPROMISE'])

• RevokedAt (datetime.datetime)

• Serial (str)

• SignatureAlgorithm (str)

• Status (Literal['PENDING_VALIDATION', 'ISSUED', 'INACTIVE', 'EXPIRED', 'VALIDATION_TIMED_OUT', 'REVOKED', 'FAILED'])

• Subject (str)

• SubjectAlternativeNames (list[str])

• Tags (list[botocraft.services.common.Tag] | None)

• Type (Literal['IMPORTED', 'AMAZON_ISSUED', 'PRIVATE'])

• session (Any | None)

field CertificateArn: str | None = None

The Amazon Resource Name (ARN) of the certificate.

For more information about ARNs, see Amazon Resource Names (ARNs) in the Amazon Web Services General Reference.

field CertificateAuthorityArn: str = None

The Amazon Resource Name (ARN) of the private certificate authority (CA) that issued the certificate.

This has the following format:

field CreatedAt: datetime = None

The time at which the certificate was requested.

field DomainName: str = None

The fully qualified domain name for the certificate, such as www.example.com or example.com.

field DomainValidationOptions: builtins.list[DomainValidation] [Optional]

Contains information about the initial validation of each domain name that occurs as a result of the RequestCertificate request.

This field exists only when the certificate type is AMAZON_ISSUED.

field ExtendedKeyUsages: builtins.list[ExtendedKeyUsage] [Optional]

Contains a list of Extended Key Usage X.509 v3 extension objects.

Each object specifies a purpose for which the certificate public key can be used and consists of a name and an object identifier (OID).

field FailureReason: Literal['NO_AVAILABLE_CONTACTS', 'ADDITIONAL_VERIFICATION_REQUIRED', 'DOMAIN_NOT_ALLOWED', 'INVALID_PUBLIC_DOMAIN', 'DOMAIN_VALIDATION_DENIED', 'CAA_ERROR', 'PCA_LIMIT_EXCEEDED', 'PCA_INVALID_ARN', 'PCA_INVALID_STATE', 'PCA_REQUEST_FAILED', 'PCA_NAME_CONSTRAINTS_VALIDATION', 'PCA_RESOURCE_NOT_FOUND', 'PCA_INVALID_ARGS', 'PCA_INVALID_DURATION', 'PCA_ACCESS_DENIED', 'SLR_NOT_FOUND', 'OTHER'] = None

The reason the certificate request failed.

This value exists only when the certificate status is FAILED. For more information, see Certificate Request Failed in the Certificate Manager User Guide.

field ImportedAt: datetime = None

The date and time when the certificate was imported.

This value exists only when the certificate type is IMPORTED.

field InUseBy: builtins.list[str] [Optional]

A list of ARNs for the Amazon Web Services resources that are using the certificate.

A certificate can be used by multiple Amazon Web Services resources.

field IssuedAt: datetime = None

The time at which the certificate was issued.

This value exists only when the certificate type is AMAZON_ISSUED.

field Issuer: str = None

The name of the certificate authority that issued and signed the certificate.

field KeyAlgorithm: str | None = None

The algorithm that was used to generate the public-private key pair.

field KeyUsages: builtins.list[KeyUsage] [Optional]

A list of Key Usage X.509 v3 extension objects.

Each object is a string value that identifies the purpose of the public key contained in the certificate. Possible extension values include DIGITAL_SIGNATURE, KEY_ENCHIPHERMENT, NON_REPUDIATION, and more.

field ManagedBy: Literal['CLOUDFRONT'] = None

Identifies the Amazon Web Services service that manages the certificate issued by ACM.

field NotAfter: datetime = None

The time after which the certificate is not valid.

field NotBefore: datetime = None

The time before which the certificate is not valid.

field Options: CertificateOptions = None

Value that specifies whether to add the certificate to a transparency log.

Certificate transparency makes it possible to detect SSL certificates that have been mistakenly or maliciously issued. A browser might respond to certificate that has not been logged by showing an error message. The logs are cryptographically secure.

field RenewalEligibility: Literal['ELIGIBLE', 'INELIGIBLE'] = None

Specifies whether the certificate is eligible for renewal.

At this time, only exported private certificates can be renewed with the RenewCertificate command.

field RenewalSummary: ACMRenewalSummary = None

Contains information about the status of ACM’s managed renewal for the certificate. This field exists only when the certificate type is AMAZON_ISSUED.

field RevocationReason: Literal['UNSPECIFIED', 'KEY_COMPROMISE', 'CA_COMPROMISE', 'AFFILIATION_CHANGED', 'SUPERCEDED', 'SUPERSEDED', 'CESSATION_OF_OPERATION', 'CERTIFICATE_HOLD', 'REMOVE_FROM_CRL', 'PRIVILEGE_WITHDRAWN', 'A_A_COMPROMISE'] = None

The reason the certificate was revoked.

This value exists only when the certificate status is REVOKED.

field RevokedAt: datetime = None

The time at which the certificate was revoked.

This value exists only when the certificate status is REVOKED.

field Serial: str = None

The serial number of the certificate.

field SignatureAlgorithm: str = None

The algorithm that was used to sign the certificate.

field Status: Literal['PENDING_VALIDATION', 'ISSUED', 'INACTIVE', 'EXPIRED', 'VALIDATION_TIMED_OUT', 'REVOKED', 'FAILED'] = None

The status of the certificate.

field Subject: str = None

The name of the entity that is associated with the public key contained in the certificate.

field SubjectAlternativeNames: builtins.list[str] [Optional]

One or more domain names (subject alternative names) included in the certificate.

This list contains the domain names that are bound to the public key that is contained in the certificate. The subject alternative names include the canonical domain name (CN) of the certificate and additional domain names that can be used to connect to the website.

field Tags: builtins.list[Tag] | None [Optional]

The tags associated with the log group.

field Type: Literal['IMPORTED', 'AMAZON_ISSUED', 'PRIVATE'] = None

The source of the certificate.

For certificates provided by ACM, this value is AMAZON_ISSUED. For certificates that you imported with ImportCertificate, this value is IMPORTED. ACM does not provide managed renewal for imported certificates. For more information about the differences between certificates that you import and those that ACM provides, see Importing Certificates in the Certificate Manager User Guide.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

manager_class

alias of ACMCertificateManager

tag_class

alias of Tag

delete()

Delete the model.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

Creates a new instance of the Model class with validated data.

Creates a new model setting __dict__ and __pydantic_fields_set__ from trusted or pre-validated data. Default values are respected, but no other validation is performed.

!!! note

model_construct() generally respects the model_config.extra setting on the provided model. That is, if model_config.extra == ‘allow’, then all extra passed values are added to the model instance’s __dict__ and __pydantic_extra__ fields. If model_config.extra == ‘ignore’ (the default), then all extra passed values are ignored. Because no validation is performed with a call to model_construct(), having model_config.extra == ‘forbid’ does not result in an error if extra values are passed, but they will be ignored.

Parameters:

• _fields_set – A set of field names that were originally explicitly set during instantiation. If provided, this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute. Otherwise, the field names from the values argument will be used.

• values – Trusted or pre-validated data dictionary.

Returns:

A new instance of the Model class with validated data.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

save(**kwargs)

Save the model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

property arn: str | None

Return the ARN of the model. This is the value of the CertificateArn attribute.

Returns:

The ARN of the model instance.

property name: str | None

Return the name of the model. This is the value of the DomainName attribute.

Returns:

The name of the model instance.

objects: ClassVar[classproperty]

Get the manager for this model, and set it as a class property

property pk: str | None

Return the primary key of the model. This is the value of the CertificateArn attribute.

Returns:

The primary key of the model instance.

property tags: TagsDict

Get the tags for the model instance.

Returns:

The tags for the model instance.

Managers

Managers work with the primary models to provide a high-level interface to the AWS service. They are responsible for creating, updating, and deleting the resources in the service, as well as any additional operations that are available for those models.

class botocraft.services.acm.ACMCertificateManager

Bases: Boto3ModelManager

delete(CertificateArn: str) → None

Deletes a certificate and its associated private key. If this action succeeds, the certificate is not available for use by Amazon Web Services services integrated with ACM. Deleting a certificate is eventually consistent. The may be a short delay before the certificate no longer appears in the list that can be displayed by calling the ListCertificates action or be retrieved by calling the GetCertificate action.

Parameters:

CertificateArn – String that contains the ARN of the ACM certificate to be deleted. This must be of the form:

get(CertificateArn: str) → ACMCertificate | None

Returns detailed metadata about the specified ACM certificate.

Parameters:

CertificateArn – The Amazon Resource Name (ARN) of the ACM certificate. The ARN must have the following form:

import_certificate(Certificate: bytes, PrivateKey: bytes, *, CertificateArn: str | None = None, CertificateChain: bytes | None = None, Tags: list[botocraft.services.common.Tag] | None = None) → str

Imports a certificate into Certificate Manager (ACM) to use with services that are integrated with ACM. Note that integrated services allow only certificate types and keys they support to be associated with their resources. Further, their support differs depending on whether the certificate is imported into IAM or into ACM. For more information, see the documentation for each service. For more information about importing certificates into ACM, see Importing Certificates in the Certificate Manager User Guide.

Parameters:

• Certificate – The certificate to import.

• PrivateKey – The private key that matches the public key in the certificate.

Keyword Arguments:

• CertificateArn – The Amazon Resource Name (ARN) of an imported certificate to replace. To import a new certificate, omit this field.

• CertificateChain – The PEM encoded certificate chain.

• Tags – One or more resource tags to associate with the imported certificate.

list(*, CertificateStatuses: list[Literal['PENDING_VALIDATION', 'ISSUED', 'INACTIVE', 'EXPIRED', 'VALIDATION_TIMED_OUT', 'REVOKED', 'FAILED']] | None = None, Includes: Filters | None = None, MaxItems: int | None = None, SortBy: Literal['CREATED_AT'] | None = None, SortOrder: Literal['ASCENDING', 'DESCENDING'] | None = None) → PrimaryBoto3ModelQuerySet

Retrieves a list of certificate ARNs and domain names. You can request that only certificates that match a specific status be listed. You can also filter by specific attributes of the certificate. Default filtering returns only RSA_2048 certificates. For more information, see Filters.

Keyword Arguments:

• CertificateStatuses – Filter the certificate list by status value.

• Includes – Filter the certificate list. For more information, see the Filters structure.

• MaxItems – Use this parameter when paginating results to specify the maximum number of items to return in the response. If additional items exist beyond the number you specify, the NextToken element is sent in the response. Use this NextToken value in a subsequent request to retrieve additional items.

• SortBy – Specifies the field to sort results by. If you specify SortBy, you must also specify SortOrder.

• SortOrder – Specifies the order of sorted results. If you specify SortOrder, you must also specify SortBy.

renew(CertificateArn: str) → None

Renews an eligible ACM certificate. In order to renew your Amazon Web Services Private CA certificates with ACM, you must first grant the ACM service principal permission to do so. For more information, see Testing Managed Renewal in the ACM User Guide.

Parameters:

CertificateArn – String that contains the ARN of the ACM certificate to be renewed. This must be of the form:

request(DomainName: str, *, ValidationMethod: Literal['EMAIL', 'DNS', 'HTTP'] | None = None, SubjectAlternativeNames: list[str] | None = None, IdempotencyToken: str | None = None, DomainValidationOptions: list[botocraft.services.acm.DomainValidationOption] | None = None, Options: CertificateOptions | None = None, CertificateAuthorityArn: str | None = None, Tags: list[botocraft.services.common.Tag] | None = None, KeyAlgorithm: Literal['RSA_1024', 'RSA_2048', 'RSA_3072', 'RSA_4096', 'EC_prime256v1', 'EC_secp384r1', 'EC_secp521r1'] | None = None, ManagedBy: Literal['CLOUDFRONT'] | None = None) → str

Requests an ACM certificate for use with other Amazon Web Services services. To request an ACM certificate, you must specify a fully qualified domain name (FQDN) in the DomainName parameter. You can also specify additional FQDNs in the SubjectAlternativeNames parameter.

Parameters:

DomainName – Fully qualified domain name (FQDN), such as www.example.com, that you want to secure with an ACM certificate. Use an asterisk (*) to create a wildcard certificate that protects several sites in the same domain. For example, *.example.com protects www.example.com, site.example.com, and images.example.com.

Keyword Arguments:

• ValidationMethod – The method you want to use if you are requesting a public certificate to validate that you own or control domain. You can validate with DNS or validate with email. We recommend that you use DNS validation.

• SubjectAlternativeNames – Additional FQDNs to be included in the Subject Alternative Name extension of the ACM certificate. For example, add the name www.example.net to a certificate for which the DomainName field is www.example.com if users can reach your site by using either name. The maximum number of domain names that you can add to an ACM certificate is 100. However, the initial quota is 10 domain names. If you need more than 10 names, you must request a quota increase. For more information, see Quotas.

• IdempotencyToken – Customer chosen string that can be used to distinguish between calls to RequestCertificate. Idempotency tokens time out after one hour. Therefore, if you call RequestCertificate multiple times with the same idempotency token within one hour, ACM recognizes that you are requesting only one certificate and will issue only one. If you change the idempotency token for each call, ACM recognizes that you are requesting multiple certificates.

• DomainValidationOptions – The domain name that you want ACM to use to send you emails so that you can validate domain ownership.

• Options – You can use this parameter to specify whether to add the certificate to a certificate transparency log and export your certificate.

• CertificateAuthorityArn – The Amazon Resource Name (ARN) of the private certificate authority (CA) that will be used to issue the certificate. If you do not provide an ARN and you are trying to request a private certificate, ACM will attempt to issue a public certificate. For more information about private CAs, see the Amazon Web Services Private Certificate Authority user guide. The ARN must have the following form:

• Tags – One or more resource tags to associate with the certificate.

• KeyAlgorithm – Specifies the algorithm of the public and private key pair that your certificate uses to encrypt data. RSA is the default key algorithm for ACM certificates. Elliptic Curve Digital Signature Algorithm (ECDSA) keys are smaller, offering security comparable to RSA keys but with greater computing efficiency. However, ECDSA is not supported by all network clients. Some Amazon Web Services services may require RSA keys, or only support ECDSA keys of a particular size, while others allow the use of either RSA and ECDSA keys to ensure that compatibility is not broken. Check the requirements for the Amazon Web Services service where you plan to deploy your certificate. For more information about selecting an algorithm, see Key algorithms.

• ManagedBy – Identifies the Amazon Web Services service that manages the certificate issued by ACM.

revoke(CertificateArn: str, RevocationReason: Literal['UNSPECIFIED', 'KEY_COMPROMISE', 'CA_COMPROMISE', 'AFFILIATION_CHANGED', 'SUPERCEDED', 'SUPERSEDED', 'CESSATION_OF_OPERATION', 'CERTIFICATE_HOLD', 'REMOVE_FROM_CRL', 'PRIVILEGE_WITHDRAWN', 'A_A_COMPROMISE']) → str

Revokes a public ACM certificate. You can only revoke certificates that have been previously exported.

Parameters:

• CertificateArn – The Amazon Resource Name (ARN) of the public or private certificate that will be revoked. The ARN must have the following form:

• RevocationReason – Specifies why you revoked the certificate.

service_name: str = 'acm'

ec2, s3, etc.

Type:

The name of the boto3 service. Example

Secondary Models

Secondary models are models that are used by the primary models to organize their data. They are not acted on directly, but are used to describe the structure of the fields in the primary models or other secondary models.

pydantic model botocraft.services.acm.ACMHttpRedirect

Bases: Boto3Model

Contains information for HTTP-based domain validation of certificates requested through Amazon CloudFront and issued by ACM.

This field exists only when the certificate type is AMAZON_ISSUED and the validation method is HTTP.

Show JSON schema

{
   "title": "ACMHttpRedirect",
   "description": "Contains information for HTTP-based domain validation of certificates requested\nthrough Amazon CloudFront and issued by ACM.\n\nThis field exists only when the certificate type is ``AMAZON_ISSUED`` and the validation method is ``HTTP``.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "RedirectFrom": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Redirectfrom"
      },
      "RedirectTo": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Redirectto"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• RedirectFrom (str | None)

• RedirectTo (str | None)

• session (Any | None)

field RedirectFrom: str | None = None

The URL including the domain to be validated.

The certificate authority sends GET requests here during validation.

field RedirectTo: str | None = None

The URL hosting the validation token.

RedirectFrom must return this content or redirect here.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

Creates a new instance of the Model class with validated data.

Creates a new model setting __dict__ and __pydantic_fields_set__ from trusted or pre-validated data. Default values are respected, but no other validation is performed.

!!! note

model_construct() generally respects the model_config.extra setting on the provided model. That is, if model_config.extra == ‘allow’, then all extra passed values are added to the model instance’s __dict__ and __pydantic_extra__ fields. If model_config.extra == ‘ignore’ (the default), then all extra passed values are ignored. Because no validation is performed with a call to model_construct(), having model_config.extra == ‘forbid’ does not result in an error if extra values are passed, but they will be ignored.

Parameters:

• _fields_set – A set of field names that were originally explicitly set during instantiation. If provided, this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute. Otherwise, the field names from the values argument will be used.

• values – Trusted or pre-validated data dictionary.

Returns:

A new instance of the Model class with validated data.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.acm.ACMRenewalSummary

Bases: Boto3Model

Contains information about the status of ACM’s managed renewal for the certificate. This structure exists only when the certificate type is AMAZON_ISSUED.

Show JSON schema

{
   "title": "ACMRenewalSummary",
   "description": "Contains information about the status of ACM's `managed renewal <https://docs.aws.amazon.com/acm/latest/userguide/acm-\nrenewal.html>`_ for the certificate. This structure exists only when the certificate type is ``AMAZON_ISSUED``.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "RenewalStatus": {
         "enum": [
            "PENDING_AUTO_RENEWAL",
            "PENDING_VALIDATION",
            "SUCCESS",
            "FAILED"
         ],
         "title": "Renewalstatus",
         "type": "string"
      },
      "DomainValidationOptions": {
         "items": {
            "$ref": "#/$defs/DomainValidation"
         },
         "title": "Domainvalidationoptions",
         "type": "array"
      },
      "RenewalStatusReason": {
         "anyOf": [
            {
               "enum": [
                  "NO_AVAILABLE_CONTACTS",
                  "ADDITIONAL_VERIFICATION_REQUIRED",
                  "DOMAIN_NOT_ALLOWED",
                  "INVALID_PUBLIC_DOMAIN",
                  "DOMAIN_VALIDATION_DENIED",
                  "CAA_ERROR",
                  "PCA_LIMIT_EXCEEDED",
                  "PCA_INVALID_ARN",
                  "PCA_INVALID_STATE",
                  "PCA_REQUEST_FAILED",
                  "PCA_NAME_CONSTRAINTS_VALIDATION",
                  "PCA_RESOURCE_NOT_FOUND",
                  "PCA_INVALID_ARGS",
                  "PCA_INVALID_DURATION",
                  "PCA_ACCESS_DENIED",
                  "SLR_NOT_FOUND",
                  "OTHER"
               ],
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Renewalstatusreason"
      },
      "UpdatedAt": {
         "format": "date-time",
         "title": "Updatedat",
         "type": "string"
      }
   },
   "$defs": {
      "ACMHttpRedirect": {
         "description": "Contains information for HTTP-based domain validation of certificates requested\nthrough Amazon CloudFront and issued by ACM.\n\nThis field exists only when the certificate type is ``AMAZON_ISSUED`` and the validation method is ``HTTP``.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "RedirectFrom": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Redirectfrom"
            },
            "RedirectTo": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Redirectto"
            }
         },
         "title": "ACMHttpRedirect",
         "type": "object"
      },
      "ACMResourceRecord": {
         "description": "Contains a DNS record value that you can use to validate ownership or control of a\ndomain.\n\nThis is used by the DescribeCertificate action.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Name": {
               "title": "Name",
               "type": "string"
            },
            "Type": {
               "const": "CNAME",
               "title": "Type",
               "type": "string"
            },
            "Value": {
               "title": "Value",
               "type": "string"
            }
         },
         "required": [
            "Name",
            "Type",
            "Value"
         ],
         "title": "ACMResourceRecord",
         "type": "object"
      },
      "DomainValidation": {
         "description": "Contains information about the validation of each domain name in the certificate.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "DomainName": {
               "title": "Domainname",
               "type": "string"
            },
            "ValidationEmails": {
               "anyOf": [
                  {
                     "items": {
                        "type": "string"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Validationemails"
            },
            "ValidationDomain": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Validationdomain"
            },
            "ValidationStatus": {
               "anyOf": [
                  {
                     "enum": [
                        "PENDING_VALIDATION",
                        "SUCCESS",
                        "FAILED"
                     ],
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Validationstatus"
            },
            "ResourceRecord": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ACMResourceRecord"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null
            },
            "HttpRedirect": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ACMHttpRedirect"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null
            },
            "ValidationMethod": {
               "anyOf": [
                  {
                     "enum": [
                        "EMAIL",
                        "DNS",
                        "HTTP"
                     ],
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Validationmethod"
            }
         },
         "required": [
            "DomainName"
         ],
         "title": "DomainValidation",
         "type": "object"
      }
   },
   "required": [
      "RenewalStatus",
      "DomainValidationOptions",
      "UpdatedAt"
   ]
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• DomainValidationOptions (list[botocraft.services.acm.DomainValidation])

• RenewalStatus (Literal['PENDING_AUTO_RENEWAL', 'PENDING_VALIDATION', 'SUCCESS', 'FAILED'])

• RenewalStatusReason (Literal['NO_AVAILABLE_CONTACTS', 'ADDITIONAL_VERIFICATION_REQUIRED', 'DOMAIN_NOT_ALLOWED', 'INVALID_PUBLIC_DOMAIN', 'DOMAIN_VALIDATION_DENIED', 'CAA_ERROR', 'PCA_LIMIT_EXCEEDED', 'PCA_INVALID_ARN', 'PCA_INVALID_STATE', 'PCA_REQUEST_FAILED', 'PCA_NAME_CONSTRAINTS_VALIDATION', 'PCA_RESOURCE_NOT_FOUND', 'PCA_INVALID_ARGS', 'PCA_INVALID_DURATION', 'PCA_ACCESS_DENIED', 'SLR_NOT_FOUND', 'OTHER'] | None)

• UpdatedAt (datetime.datetime)

• session (Any | None)

field DomainValidationOptions: builtins.list[DomainValidation] [Required]

Contains information about the validation of each domain name in the certificate, as it pertains to ACM’s managed renewal. This is different from the initial validation that occurs as a result of the RequestCertificate request. This field exists only when the certificate type is AMAZON_ISSUED.

field RenewalStatus: Literal['PENDING_AUTO_RENEWAL', 'PENDING_VALIDATION', 'SUCCESS', 'FAILED'] [Required]

The status of ACM’s managed renewal of the certificate.

field RenewalStatusReason: Literal['NO_AVAILABLE_CONTACTS', 'ADDITIONAL_VERIFICATION_REQUIRED', 'DOMAIN_NOT_ALLOWED', 'INVALID_PUBLIC_DOMAIN', 'DOMAIN_VALIDATION_DENIED', 'CAA_ERROR', 'PCA_LIMIT_EXCEEDED', 'PCA_INVALID_ARN', 'PCA_INVALID_STATE', 'PCA_REQUEST_FAILED', 'PCA_NAME_CONSTRAINTS_VALIDATION', 'PCA_RESOURCE_NOT_FOUND', 'PCA_INVALID_ARGS', 'PCA_INVALID_DURATION', 'PCA_ACCESS_DENIED', 'SLR_NOT_FOUND', 'OTHER'] | None = None

The reason that a renewal request was unsuccessful.

field UpdatedAt: datetime [Required]

The time at which the renewal summary was last updated.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

Creates a new instance of the Model class with validated data.

Creates a new model setting __dict__ and __pydantic_fields_set__ from trusted or pre-validated data. Default values are respected, but no other validation is performed.

!!! note

model_construct() generally respects the model_config.extra setting on the provided model. That is, if model_config.extra == ‘allow’, then all extra passed values are added to the model instance’s __dict__ and __pydantic_extra__ fields. If model_config.extra == ‘ignore’ (the default), then all extra passed values are ignored. Because no validation is performed with a call to model_construct(), having model_config.extra == ‘forbid’ does not result in an error if extra values are passed, but they will be ignored.

Parameters:

• _fields_set – A set of field names that were originally explicitly set during instantiation. If provided, this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute. Otherwise, the field names from the values argument will be used.

• values – Trusted or pre-validated data dictionary.

Returns:

A new instance of the Model class with validated data.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.acm.ACMResourceRecord

Bases: Boto3Model

Contains a DNS record value that you can use to validate ownership or control of a domain.

This is used by the DescribeCertificate action.

Show JSON schema

{
   "title": "ACMResourceRecord",
   "description": "Contains a DNS record value that you can use to validate ownership or control of a\ndomain.\n\nThis is used by the DescribeCertificate action.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Name": {
         "title": "Name",
         "type": "string"
      },
      "Type": {
         "const": "CNAME",
         "title": "Type",
         "type": "string"
      },
      "Value": {
         "title": "Value",
         "type": "string"
      }
   },
   "required": [
      "Name",
      "Type",
      "Value"
   ]
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• Name (str)

• Type (Literal['CNAME'])

• Value (str)

• session (Any | None)

field Name: str [Required]

The name of the DNS record to create in your domain.

This is supplied by ACM.

field Type: Literal['CNAME'] [Required]

The type of DNS record.

Currently this can be CNAME.

field Value: str [Required]

The value of the CNAME record to add to your DNS database.

This is supplied by ACM.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

Creates a new instance of the Model class with validated data.

Creates a new model setting __dict__ and __pydantic_fields_set__ from trusted or pre-validated data. Default values are respected, but no other validation is performed.

!!! note

model_construct() generally respects the model_config.extra setting on the provided model. That is, if model_config.extra == ‘allow’, then all extra passed values are added to the model instance’s __dict__ and __pydantic_extra__ fields. If model_config.extra == ‘ignore’ (the default), then all extra passed values are ignored. Because no validation is performed with a call to model_construct(), having model_config.extra == ‘forbid’ does not result in an error if extra values are passed, but they will be ignored.

Parameters:

• _fields_set – A set of field names that were originally explicitly set during instantiation. If provided, this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute. Otherwise, the field names from the values argument will be used.

• values – Trusted or pre-validated data dictionary.

Returns:

A new instance of the Model class with validated data.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.acm.CertificateOptions

Bases: Boto3Model

Structure that contains options for your certificate. You can use this structure to specify whether to opt in to or out of certificate transparency logging and export your certificate.

Some browsers require that public certificates issued for your domain be recorded in a log. Certificates that are not logged typically generate a browser error. Transparency makes it possible for you to detect SSL/TLS certificates that have been mistakenly or maliciously issued for your domain. For general information, see Certificate Transparency Logging.

You can export public ACM certificates to use with Amazon Web Services services as well as outside Amazon Web Services Cloud. For more information, see Certificate Manager exportable public certificate.

Show JSON schema

{
   "title": "CertificateOptions",
   "description": "Structure that contains options for your certificate. You can use this structure to\nspecify whether to opt in to or out of certificate transparency logging and export\nyour certificate.\n\nSome browsers require that public certificates issued for your domain be recorded in\na log. Certificates that are not logged typically generate a browser error.\nTransparency makes it possible for you to detect SSL/TLS certificates that have been\nmistakenly or maliciously issued for your domain. For general information, see\n`Certificate Transparency Logging <https://docs.aws.amazon.com/acm/latest/userguide/acm-concepts.html#concept-transparency>`_.\n\nYou can export public ACM certificates to use with Amazon Web Services services as\nwell as outside Amazon Web Services Cloud. For more information, see\n`Certificate Manager exportable public certificate <https://docs.aws.amazon.com/acm/latest/userguide/acm-exportable-certificates.html>`_.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "CertificateTransparencyLoggingPreference": {
         "anyOf": [
            {
               "enum": [
                  "ENABLED",
                  "DISABLED"
               ],
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Certificatetransparencyloggingpreference"
      },
      "Export": {
         "anyOf": [
            {
               "enum": [
                  "ENABLED",
                  "DISABLED"
               ],
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Export"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• CertificateTransparencyLoggingPreference (Literal['ENABLED', 'DISABLED'] | None)

• Export (Literal['ENABLED', 'DISABLED'] | None)

• session (Any | None)

field CertificateTransparencyLoggingPreference: Literal['ENABLED', 'DISABLED'] | None = None

You can opt out of certificate transparency logging by specifying the DISABLED option.

Opt in by specifying ENABLED.

field Export: Literal['ENABLED', 'DISABLED'] | None = None

You can opt in to allow the export of your certificates by specifying ENABLED.

You cannot update the value of Export after the the certificate is created.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

Creates a new instance of the Model class with validated data.

Creates a new model setting __dict__ and __pydantic_fields_set__ from trusted or pre-validated data. Default values are respected, but no other validation is performed.

!!! note

model_construct() generally respects the model_config.extra setting on the provided model. That is, if model_config.extra == ‘allow’, then all extra passed values are added to the model instance’s __dict__ and __pydantic_extra__ fields. If model_config.extra == ‘ignore’ (the default), then all extra passed values are ignored. Because no validation is performed with a call to model_construct(), having model_config.extra == ‘forbid’ does not result in an error if extra values are passed, but they will be ignored.

Parameters:

• _fields_set – A set of field names that were originally explicitly set during instantiation. If provided, this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute. Otherwise, the field names from the values argument will be used.

• values – Trusted or pre-validated data dictionary.

Returns:

A new instance of the Model class with validated data.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.acm.DomainValidation

Bases: Boto3Model

Contains information about the validation of each domain name in the certificate.

Show JSON schema

{
   "title": "DomainValidation",
   "description": "Contains information about the validation of each domain name in the certificate.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "DomainName": {
         "title": "Domainname",
         "type": "string"
      },
      "ValidationEmails": {
         "anyOf": [
            {
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Validationemails"
      },
      "ValidationDomain": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Validationdomain"
      },
      "ValidationStatus": {
         "anyOf": [
            {
               "enum": [
                  "PENDING_VALIDATION",
                  "SUCCESS",
                  "FAILED"
               ],
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Validationstatus"
      },
      "ResourceRecord": {
         "anyOf": [
            {
               "$ref": "#/$defs/ACMResourceRecord"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "HttpRedirect": {
         "anyOf": [
            {
               "$ref": "#/$defs/ACMHttpRedirect"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "ValidationMethod": {
         "anyOf": [
            {
               "enum": [
                  "EMAIL",
                  "DNS",
                  "HTTP"
               ],
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Validationmethod"
      }
   },
   "$defs": {
      "ACMHttpRedirect": {
         "description": "Contains information for HTTP-based domain validation of certificates requested\nthrough Amazon CloudFront and issued by ACM.\n\nThis field exists only when the certificate type is ``AMAZON_ISSUED`` and the validation method is ``HTTP``.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "RedirectFrom": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Redirectfrom"
            },
            "RedirectTo": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Redirectto"
            }
         },
         "title": "ACMHttpRedirect",
         "type": "object"
      },
      "ACMResourceRecord": {
         "description": "Contains a DNS record value that you can use to validate ownership or control of a\ndomain.\n\nThis is used by the DescribeCertificate action.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Name": {
               "title": "Name",
               "type": "string"
            },
            "Type": {
               "const": "CNAME",
               "title": "Type",
               "type": "string"
            },
            "Value": {
               "title": "Value",
               "type": "string"
            }
         },
         "required": [
            "Name",
            "Type",
            "Value"
         ],
         "title": "ACMResourceRecord",
         "type": "object"
      }
   },
   "required": [
      "DomainName"
   ]
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• DomainName (str)

• HttpRedirect (botocraft.services.acm.ACMHttpRedirect | None)

• ResourceRecord (botocraft.services.acm.ACMResourceRecord | None)

• ValidationDomain (str | None)

• ValidationEmails (list[str] | None)

• ValidationMethod (Literal['EMAIL', 'DNS', 'HTTP'] | None)

• ValidationStatus (Literal['PENDING_VALIDATION', 'SUCCESS', 'FAILED'] | None)

• session (Any | None)

field DomainName: str [Required]

A fully qualified domain name (FQDN) in the certificate.

For example, www.example.com or example.com.

field HttpRedirect: ACMHttpRedirect | None = None

Contains information for HTTP-based domain validation of certificates requested through Amazon CloudFront and issued by ACM.

This field exists only when the certificate type is AMAZON_ISSUED and the validation method is HTTP.

field ResourceRecord: ACMResourceRecord | None = None

Contains the CNAME record that you add to your DNS database for domain validation.

For more information, see Use DNS to Validate Domain Ownership.

field ValidationDomain: str | None = None

The domain name that ACM used to send domain validation emails.

field ValidationEmails: builtins.list[str] | None [Optional]

A list of email addresses that ACM used to send domain validation emails.

field ValidationMethod: Literal['EMAIL', 'DNS', 'HTTP'] | None = None

Specifies the domain validation method.

field ValidationStatus: Literal['PENDING_VALIDATION', 'SUCCESS', 'FAILED'] | None = None

The validation status of the domain name.

This can be one of the following values:

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

Creates a new instance of the Model class with validated data.

Creates a new model setting __dict__ and __pydantic_fields_set__ from trusted or pre-validated data. Default values are respected, but no other validation is performed.

!!! note

model_construct() generally respects the model_config.extra setting on the provided model. That is, if model_config.extra == ‘allow’, then all extra passed values are added to the model instance’s __dict__ and __pydantic_extra__ fields. If model_config.extra == ‘ignore’ (the default), then all extra passed values are ignored. Because no validation is performed with a call to model_construct(), having model_config.extra == ‘forbid’ does not result in an error if extra values are passed, but they will be ignored.

Parameters:

• _fields_set – A set of field names that were originally explicitly set during instantiation. If provided, this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute. Otherwise, the field names from the values argument will be used.

• values – Trusted or pre-validated data dictionary.

Returns:

A new instance of the Model class with validated data.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.acm.ExtendedKeyUsage

Bases: Boto3Model

The Extended Key Usage X.509 v3 extension defines one or more purposes for which the public key can be used.

This is in addition to or in place of the basic purposes specified by the Key Usage extension.

Show JSON schema

{
   "title": "ExtendedKeyUsage",
   "description": "The Extended Key Usage X.509 v3 extension defines one or more purposes for which the\npublic key can be used.\n\nThis is in addition to or in place of the basic purposes specified by the Key Usage\nextension.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Name": {
         "anyOf": [
            {
               "enum": [
                  "TLS_WEB_SERVER_AUTHENTICATION",
                  "TLS_WEB_CLIENT_AUTHENTICATION",
                  "CODE_SIGNING",
                  "EMAIL_PROTECTION",
                  "TIME_STAMPING",
                  "OCSP_SIGNING",
                  "IPSEC_END_SYSTEM",
                  "IPSEC_TUNNEL",
                  "IPSEC_USER",
                  "ANY",
                  "NONE",
                  "CUSTOM"
               ],
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Name"
      },
      "OID": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Oid"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• Name (Literal['TLS_WEB_SERVER_AUTHENTICATION', 'TLS_WEB_CLIENT_AUTHENTICATION', 'CODE_SIGNING', 'EMAIL_PROTECTION', 'TIME_STAMPING', 'OCSP_SIGNING', 'IPSEC_END_SYSTEM', 'IPSEC_TUNNEL', 'IPSEC_USER', 'ANY', 'NONE', 'CUSTOM'] | None)

• OID (str | None)

• session (Any | None)

field Name: Literal['TLS_WEB_SERVER_AUTHENTICATION', 'TLS_WEB_CLIENT_AUTHENTICATION', 'CODE_SIGNING', 'EMAIL_PROTECTION', 'TIME_STAMPING', 'OCSP_SIGNING', 'IPSEC_END_SYSTEM', 'IPSEC_TUNNEL', 'IPSEC_USER', 'ANY', 'NONE', 'CUSTOM'] | None = None

The name of an Extended Key Usage value.

field OID: str | None = None

An object identifier (OID) for the extension value.

OIDs are strings of numbers separated by periods. The following OIDs are defined in RFC 3280 and RFC 5280.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

Creates a new instance of the Model class with validated data.

Creates a new model setting __dict__ and __pydantic_fields_set__ from trusted or pre-validated data. Default values are respected, but no other validation is performed.

!!! note

model_construct() generally respects the model_config.extra setting on the provided model. That is, if model_config.extra == ‘allow’, then all extra passed values are added to the model instance’s __dict__ and __pydantic_extra__ fields. If model_config.extra == ‘ignore’ (the default), then all extra passed values are ignored. Because no validation is performed with a call to model_construct(), having model_config.extra == ‘forbid’ does not result in an error if extra values are passed, but they will be ignored.

Parameters:

• _fields_set – A set of field names that were originally explicitly set during instantiation. If provided, this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute. Otherwise, the field names from the values argument will be used.

• values – Trusted or pre-validated data dictionary.

Returns:

A new instance of the Model class with validated data.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.acm.KeyUsage

Bases: Boto3Model

The Key Usage X.509 v3 extension defines the purpose of the public key contained in the certificate.

Show JSON schema

{
   "title": "KeyUsage",
   "description": "The Key Usage X.509 v3 extension defines the purpose of the public key contained in\nthe certificate.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Name": {
         "anyOf": [
            {
               "enum": [
                  "DIGITAL_SIGNATURE",
                  "NON_REPUDIATION",
                  "KEY_ENCIPHERMENT",
                  "DATA_ENCIPHERMENT",
                  "KEY_AGREEMENT",
                  "CERTIFICATE_SIGNING",
                  "CRL_SIGNING",
                  "ENCIPHER_ONLY",
                  "DECIPHER_ONLY",
                  "ANY",
                  "CUSTOM"
               ],
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Name"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• Name (Literal['DIGITAL_SIGNATURE', 'NON_REPUDIATION', 'KEY_ENCIPHERMENT', 'DATA_ENCIPHERMENT', 'KEY_AGREEMENT', 'CERTIFICATE_SIGNING', 'CRL_SIGNING', 'ENCIPHER_ONLY', 'DECIPHER_ONLY', 'ANY', 'CUSTOM'] | None)

• session (Any | None)

field Name: Literal['DIGITAL_SIGNATURE', 'NON_REPUDIATION', 'KEY_ENCIPHERMENT', 'DATA_ENCIPHERMENT', 'KEY_AGREEMENT', 'CERTIFICATE_SIGNING', 'CRL_SIGNING', 'ENCIPHER_ONLY', 'DECIPHER_ONLY', 'ANY', 'CUSTOM'] | None = None

A string value that contains a Key Usage extension name.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

Creates a new instance of the Model class with validated data.

Creates a new model setting __dict__ and __pydantic_fields_set__ from trusted or pre-validated data. Default values are respected, but no other validation is performed.

!!! note

model_construct() generally respects the model_config.extra setting on the provided model. That is, if model_config.extra == ‘allow’, then all extra passed values are added to the model instance’s __dict__ and __pydantic_extra__ fields. If model_config.extra == ‘ignore’ (the default), then all extra passed values are ignored. Because no validation is performed with a call to model_construct(), having model_config.extra == ‘forbid’ does not result in an error if extra values are passed, but they will be ignored.

Parameters:

• _fields_set – A set of field names that were originally explicitly set during instantiation. If provided, this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute. Otherwise, the field names from the values argument will be used.

• values – Trusted or pre-validated data dictionary.

Returns:

A new instance of the Model class with validated data.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

Request/Response Models

Request/response models are models that are used to describe the structure of the data that is sent to and received from the AWS service. They are used by the managers to send requests to the service and to parse the responses that are received.

You will not often use them directly – typically they are used by the managers internally to send requests and parse responses – but they are included here for completeness, and because occasionally we return them directly to you because they have some useful additional information.

pydantic model botocraft.services.acm.CertificateSummary

Bases: Boto3Model

This structure is returned in the response object of ListCertificates action.

Show JSON schema

{
   "title": "CertificateSummary",
   "description": "This structure is returned in the response object of ListCertificates action.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "KeyAlgorithm": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Keyalgorithm"
      },
      "CertificateArn": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Certificatearn"
      },
      "DomainName": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Domainname"
      },
      "SubjectAlternativeNameSummaries": {
         "anyOf": [
            {
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Subjectalternativenamesummaries"
      },
      "HasAdditionalSubjectAlternativeNames": {
         "anyOf": [
            {
               "type": "boolean"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Hasadditionalsubjectalternativenames"
      },
      "Status": {
         "anyOf": [
            {
               "enum": [
                  "PENDING_VALIDATION",
                  "ISSUED",
                  "INACTIVE",
                  "EXPIRED",
                  "VALIDATION_TIMED_OUT",
                  "REVOKED",
                  "FAILED"
               ],
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Status"
      },
      "Type": {
         "anyOf": [
            {
               "enum": [
                  "IMPORTED",
                  "AMAZON_ISSUED",
                  "PRIVATE"
               ],
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Type"
      },
      "KeyUsages": {
         "anyOf": [
            {
               "items": {
                  "enum": [
                     "DIGITAL_SIGNATURE",
                     "NON_REPUDIATION",
                     "KEY_ENCIPHERMENT",
                     "DATA_ENCIPHERMENT",
                     "KEY_AGREEMENT",
                     "CERTIFICATE_SIGNING",
                     "CRL_SIGNING",
                     "ENCIPHER_ONLY",
                     "DECIPHER_ONLY",
                     "ANY",
                     "CUSTOM"
                  ],
                  "type": "string"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Keyusages"
      },
      "ExtendedKeyUsages": {
         "anyOf": [
            {
               "items": {
                  "enum": [
                     "TLS_WEB_SERVER_AUTHENTICATION",
                     "TLS_WEB_CLIENT_AUTHENTICATION",
                     "CODE_SIGNING",
                     "EMAIL_PROTECTION",
                     "TIME_STAMPING",
                     "OCSP_SIGNING",
                     "IPSEC_END_SYSTEM",
                     "IPSEC_TUNNEL",
                     "IPSEC_USER",
                     "ANY",
                     "NONE",
                     "CUSTOM"
                  ],
                  "type": "string"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Extendedkeyusages"
      },
      "ExportOption": {
         "anyOf": [
            {
               "enum": [
                  "ENABLED",
                  "DISABLED"
               ],
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Exportoption"
      },
      "InUse": {
         "anyOf": [
            {
               "type": "boolean"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Inuse"
      },
      "Exported": {
         "anyOf": [
            {
               "type": "boolean"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Exported"
      },
      "RenewalEligibility": {
         "anyOf": [
            {
               "enum": [
                  "ELIGIBLE",
                  "INELIGIBLE"
               ],
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Renewaleligibility"
      },
      "NotBefore": {
         "anyOf": [
            {
               "format": "date-time",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Notbefore"
      },
      "NotAfter": {
         "anyOf": [
            {
               "format": "date-time",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Notafter"
      },
      "CreatedAt": {
         "anyOf": [
            {
               "format": "date-time",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Createdat"
      },
      "IssuedAt": {
         "anyOf": [
            {
               "format": "date-time",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Issuedat"
      },
      "ImportedAt": {
         "anyOf": [
            {
               "format": "date-time",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Importedat"
      },
      "RevokedAt": {
         "anyOf": [
            {
               "format": "date-time",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Revokedat"
      },
      "ManagedBy": {
         "anyOf": [
            {
               "const": "CLOUDFRONT",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Managedby"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• CertificateArn (str | None)

• CreatedAt (datetime.datetime | None)

• DomainName (str | None)

• ExportOption (Literal['ENABLED', 'DISABLED'] | None)

• Exported (bool | None)

• ExtendedKeyUsages (list[typing.Literal['TLS_WEB_SERVER_AUTHENTICATION', 'TLS_WEB_CLIENT_AUTHENTICATION', 'CODE_SIGNING', 'EMAIL_PROTECTION', 'TIME_STAMPING', 'OCSP_SIGNING', 'IPSEC_END_SYSTEM', 'IPSEC_TUNNEL', 'IPSEC_USER', 'ANY', 'NONE', 'CUSTOM']] | None)

• HasAdditionalSubjectAlternativeNames (bool | None)

• ImportedAt (datetime.datetime | None)

• InUse (bool | None)

• IssuedAt (datetime.datetime | None)

• KeyAlgorithm (str | None)

• KeyUsages (list[typing.Literal['DIGITAL_SIGNATURE', 'NON_REPUDIATION', 'KEY_ENCIPHERMENT', 'DATA_ENCIPHERMENT', 'KEY_AGREEMENT', 'CERTIFICATE_SIGNING', 'CRL_SIGNING', 'ENCIPHER_ONLY', 'DECIPHER_ONLY', 'ANY', 'CUSTOM']] | None)

• ManagedBy (Literal['CLOUDFRONT'] | None)

• NotAfter (datetime.datetime | None)

• NotBefore (datetime.datetime | None)

• RenewalEligibility (Literal['ELIGIBLE', 'INELIGIBLE'] | None)

• RevokedAt (datetime.datetime | None)

• Status (Literal['PENDING_VALIDATION', 'ISSUED', 'INACTIVE', 'EXPIRED', 'VALIDATION_TIMED_OUT', 'REVOKED', 'FAILED'] | None)

• SubjectAlternativeNameSummaries (list[str] | None)

• Type (Literal['IMPORTED', 'AMAZON_ISSUED', 'PRIVATE'] | None)

• session (Any | None)

field CertificateArn: str | None = None

Amazon Resource Name (ARN) of the certificate.

This is of the form:

field CreatedAt: datetime | None = None

The time at which the certificate was requested.

field DomainName: str | None = None

Fully qualified domain name (FQDN), such as www.example.com or example.com, for the certificate.

field ExportOption: Literal['ENABLED', 'DISABLED'] | None = None

Indicates if export is enabled for the certificate.

field Exported: bool | None = None

Indicates whether the certificate has been exported.

This value exists only when the certificate type is PRIVATE.

field ExtendedKeyUsages: builtins.list[Literal['TLS_WEB_SERVER_AUTHENTICATION', 'TLS_WEB_CLIENT_AUTHENTICATION', 'CODE_SIGNING', 'EMAIL_PROTECTION', 'TIME_STAMPING', 'OCSP_SIGNING', 'IPSEC_END_SYSTEM', 'IPSEC_TUNNEL', 'IPSEC_USER', 'ANY', 'NONE', 'CUSTOM']] | None [Optional]

Contains a list of Extended Key Usage X.509 v3 extension objects.

Each object specifies a purpose for which the certificate public key can be used and consists of a name and an object identifier (OID).

field HasAdditionalSubjectAlternativeNames: bool | None = None

When called by ListCertificates, indicates whether the full list of subject alternative names has been included in the response. If false, the response includes all of the subject alternative names included in the certificate. If true, the response only includes the first 100 subject alternative names included in the certificate. To display the full list of subject alternative names, use DescribeCertificate.

field ImportedAt: datetime | None = None

The date and time when the certificate was imported.

This value exists only when the certificate type is IMPORTED.

field InUse: bool | None = None

Indicates whether the certificate is currently in use by any Amazon Web Services resources.

field IssuedAt: datetime | None = None

The time at which the certificate was issued.

This value exists only when the certificate type is AMAZON_ISSUED.

field KeyAlgorithm: str | None = None

The algorithm that was used to generate the public-private key pair.

field KeyUsages: builtins.list[Literal['DIGITAL_SIGNATURE', 'NON_REPUDIATION', 'KEY_ENCIPHERMENT', 'DATA_ENCIPHERMENT', 'KEY_AGREEMENT', 'CERTIFICATE_SIGNING', 'CRL_SIGNING', 'ENCIPHER_ONLY', 'DECIPHER_ONLY', 'ANY', 'CUSTOM']] | None [Optional]

A list of Key Usage X.509 v3 extension objects.

Each object is a string value that identifies the purpose of the public key contained in the certificate. Possible extension values include DIGITAL_SIGNATURE, KEY_ENCHIPHERMENT, NON_REPUDIATION, and more.

field ManagedBy: Literal['CLOUDFRONT'] | None = None

Identifies the Amazon Web Services service that manages the certificate issued by ACM.

field NotAfter: datetime | None = None

The time after which the certificate is not valid.

field NotBefore: datetime | None = None

The time before which the certificate is not valid.

field RenewalEligibility: Literal['ELIGIBLE', 'INELIGIBLE'] | None = None

Specifies whether the certificate is eligible for renewal.

At this time, only exported private certificates can be renewed with the RenewCertificate command.

field RevokedAt: datetime | None = None

The time at which the certificate was revoked.

This value exists only when the certificate status is REVOKED.

field Status: Literal['PENDING_VALIDATION', 'ISSUED', 'INACTIVE', 'EXPIRED', 'VALIDATION_TIMED_OUT', 'REVOKED', 'FAILED'] | None = None

The status of the certificate.

field SubjectAlternativeNameSummaries: builtins.list[str] | None [Optional]

One or more domain names (subject alternative names) included in the certificate.

This list contains the domain names that are bound to the public key that is contained in the certificate. The subject alternative names include the canonical domain name (CN) of the certificate and additional domain names that can be used to connect to the website.

field Type: Literal['IMPORTED', 'AMAZON_ISSUED', 'PRIVATE'] | None = None

The source of the certificate.

For certificates provided by ACM, this value is AMAZON_ISSUED. For certificates that you imported with ImportCertificate, this value is IMPORTED. ACM does not provide managed renewal for imported certificates. For more information about the differences between certificates that you import and those that ACM provides, see Importing Certificates in the Certificate Manager User Guide.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

Creates a new instance of the Model class with validated data.

Creates a new model setting __dict__ and __pydantic_fields_set__ from trusted or pre-validated data. Default values are respected, but no other validation is performed.

!!! note

model_construct() generally respects the model_config.extra setting on the provided model. That is, if model_config.extra == ‘allow’, then all extra passed values are added to the model instance’s __dict__ and __pydantic_extra__ fields. If model_config.extra == ‘ignore’ (the default), then all extra passed values are ignored. Because no validation is performed with a call to model_construct(), having model_config.extra == ‘forbid’ does not result in an error if extra values are passed, but they will be ignored.

Parameters:

• _fields_set – A set of field names that were originally explicitly set during instantiation. If provided, this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute. Otherwise, the field names from the values argument will be used.

• values – Trusted or pre-validated data dictionary.

Returns:

A new instance of the Model class with validated data.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.acm.DescribeCertificateResponse

Bases: Boto3Model

Show JSON schema

{
   "title": "DescribeCertificateResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Certificate": {
         "anyOf": [
            {
               "$ref": "#/$defs/ACMCertificate"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      }
   },
   "$defs": {
      "ACMCertificate": {
         "description": "Contains metadata about an ACM certificate.\n\nThis structure is returned in the response to a DescribeCertificate request.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "KeyAlgorithm": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Keyalgorithm"
            },
            "CertificateArn": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Certificatearn"
            },
            "DomainName": {
               "default": null,
               "title": "Domainname",
               "type": "string"
            },
            "SubjectAlternativeNames": {
               "items": {
                  "type": "string"
               },
               "title": "Subjectalternativenames",
               "type": "array"
            },
            "ManagedBy": {
               "const": "CLOUDFRONT",
               "default": null,
               "title": "Managedby",
               "type": "string"
            },
            "DomainValidationOptions": {
               "items": {
                  "$ref": "#/$defs/DomainValidation"
               },
               "title": "Domainvalidationoptions",
               "type": "array"
            },
            "Serial": {
               "default": null,
               "title": "Serial",
               "type": "string"
            },
            "Subject": {
               "default": null,
               "title": "Subject",
               "type": "string"
            },
            "Issuer": {
               "default": null,
               "title": "Issuer",
               "type": "string"
            },
            "CreatedAt": {
               "default": null,
               "format": "date-time",
               "title": "Createdat",
               "type": "string"
            },
            "IssuedAt": {
               "default": null,
               "format": "date-time",
               "title": "Issuedat",
               "type": "string"
            },
            "ImportedAt": {
               "default": null,
               "format": "date-time",
               "title": "Importedat",
               "type": "string"
            },
            "Status": {
               "default": null,
               "enum": [
                  "PENDING_VALIDATION",
                  "ISSUED",
                  "INACTIVE",
                  "EXPIRED",
                  "VALIDATION_TIMED_OUT",
                  "REVOKED",
                  "FAILED"
               ],
               "title": "Status",
               "type": "string"
            },
            "RevokedAt": {
               "default": null,
               "format": "date-time",
               "title": "Revokedat",
               "type": "string"
            },
            "RevocationReason": {
               "default": null,
               "enum": [
                  "UNSPECIFIED",
                  "KEY_COMPROMISE",
                  "CA_COMPROMISE",
                  "AFFILIATION_CHANGED",
                  "SUPERCEDED",
                  "SUPERSEDED",
                  "CESSATION_OF_OPERATION",
                  "CERTIFICATE_HOLD",
                  "REMOVE_FROM_CRL",
                  "PRIVILEGE_WITHDRAWN",
                  "A_A_COMPROMISE"
               ],
               "title": "Revocationreason",
               "type": "string"
            },
            "NotBefore": {
               "default": null,
               "format": "date-time",
               "title": "Notbefore",
               "type": "string"
            },
            "NotAfter": {
               "default": null,
               "format": "date-time",
               "title": "Notafter",
               "type": "string"
            },
            "SignatureAlgorithm": {
               "default": null,
               "title": "Signaturealgorithm",
               "type": "string"
            },
            "InUseBy": {
               "items": {
                  "type": "string"
               },
               "title": "Inuseby",
               "type": "array"
            },
            "FailureReason": {
               "default": null,
               "enum": [
                  "NO_AVAILABLE_CONTACTS",
                  "ADDITIONAL_VERIFICATION_REQUIRED",
                  "DOMAIN_NOT_ALLOWED",
                  "INVALID_PUBLIC_DOMAIN",
                  "DOMAIN_VALIDATION_DENIED",
                  "CAA_ERROR",
                  "PCA_LIMIT_EXCEEDED",
                  "PCA_INVALID_ARN",
                  "PCA_INVALID_STATE",
                  "PCA_REQUEST_FAILED",
                  "PCA_NAME_CONSTRAINTS_VALIDATION",
                  "PCA_RESOURCE_NOT_FOUND",
                  "PCA_INVALID_ARGS",
                  "PCA_INVALID_DURATION",
                  "PCA_ACCESS_DENIED",
                  "SLR_NOT_FOUND",
                  "OTHER"
               ],
               "title": "Failurereason",
               "type": "string"
            },
            "Type": {
               "default": null,
               "enum": [
                  "IMPORTED",
                  "AMAZON_ISSUED",
                  "PRIVATE"
               ],
               "title": "Type",
               "type": "string"
            },
            "RenewalSummary": {
               "$ref": "#/$defs/ACMRenewalSummary",
               "default": null
            },
            "KeyUsages": {
               "items": {
                  "$ref": "#/$defs/KeyUsage"
               },
               "title": "Keyusages",
               "type": "array"
            },
            "ExtendedKeyUsages": {
               "items": {
                  "$ref": "#/$defs/ExtendedKeyUsage"
               },
               "title": "Extendedkeyusages",
               "type": "array"
            },
            "CertificateAuthorityArn": {
               "default": null,
               "title": "Certificateauthorityarn",
               "type": "string"
            },
            "RenewalEligibility": {
               "default": null,
               "enum": [
                  "ELIGIBLE",
                  "INELIGIBLE"
               ],
               "title": "Renewaleligibility",
               "type": "string"
            },
            "Options": {
               "$ref": "#/$defs/CertificateOptions",
               "default": null
            },
            "Tags": {
               "anyOf": [
                  {
                     "items": {
                        "$ref": "#/$defs/Tag"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Tags"
            }
         },
         "title": "ACMCertificate",
         "type": "object"
      },
      "ACMHttpRedirect": {
         "description": "Contains information for HTTP-based domain validation of certificates requested\nthrough Amazon CloudFront and issued by ACM.\n\nThis field exists only when the certificate type is ``AMAZON_ISSUED`` and the validation method is ``HTTP``.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "RedirectFrom": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Redirectfrom"
            },
            "RedirectTo": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Redirectto"
            }
         },
         "title": "ACMHttpRedirect",
         "type": "object"
      },
      "ACMRenewalSummary": {
         "description": "Contains information about the status of ACM's `managed renewal <https://docs.aws.amazon.com/acm/latest/userguide/acm-\nrenewal.html>`_ for the certificate. This structure exists only when the certificate type is ``AMAZON_ISSUED``.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "RenewalStatus": {
               "enum": [
                  "PENDING_AUTO_RENEWAL",
                  "PENDING_VALIDATION",
                  "SUCCESS",
                  "FAILED"
               ],
               "title": "Renewalstatus",
               "type": "string"
            },
            "DomainValidationOptions": {
               "items": {
                  "$ref": "#/$defs/DomainValidation"
               },
               "title": "Domainvalidationoptions",
               "type": "array"
            },
            "RenewalStatusReason": {
               "anyOf": [
                  {
                     "enum": [
                        "NO_AVAILABLE_CONTACTS",
                        "ADDITIONAL_VERIFICATION_REQUIRED",
                        "DOMAIN_NOT_ALLOWED",
                        "INVALID_PUBLIC_DOMAIN",
                        "DOMAIN_VALIDATION_DENIED",
                        "CAA_ERROR",
                        "PCA_LIMIT_EXCEEDED",
                        "PCA_INVALID_ARN",
                        "PCA_INVALID_STATE",
                        "PCA_REQUEST_FAILED",
                        "PCA_NAME_CONSTRAINTS_VALIDATION",
                        "PCA_RESOURCE_NOT_FOUND",
                        "PCA_INVALID_ARGS",
                        "PCA_INVALID_DURATION",
                        "PCA_ACCESS_DENIED",
                        "SLR_NOT_FOUND",
                        "OTHER"
                     ],
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Renewalstatusreason"
            },
            "UpdatedAt": {
               "format": "date-time",
               "title": "Updatedat",
               "type": "string"
            }
         },
         "required": [
            "RenewalStatus",
            "DomainValidationOptions",
            "UpdatedAt"
         ],
         "title": "ACMRenewalSummary",
         "type": "object"
      },
      "ACMResourceRecord": {
         "description": "Contains a DNS record value that you can use to validate ownership or control of a\ndomain.\n\nThis is used by the DescribeCertificate action.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Name": {
               "title": "Name",
               "type": "string"
            },
            "Type": {
               "const": "CNAME",
               "title": "Type",
               "type": "string"
            },
            "Value": {
               "title": "Value",
               "type": "string"
            }
         },
         "required": [
            "Name",
            "Type",
            "Value"
         ],
         "title": "ACMResourceRecord",
         "type": "object"
      },
      "CertificateOptions": {
         "description": "Structure that contains options for your certificate. You can use this structure to\nspecify whether to opt in to or out of certificate transparency logging and export\nyour certificate.\n\nSome browsers require that public certificates issued for your domain be recorded in\na log. Certificates that are not logged typically generate a browser error.\nTransparency makes it possible for you to detect SSL/TLS certificates that have been\nmistakenly or maliciously issued for your domain. For general information, see\n`Certificate Transparency Logging <https://docs.aws.amazon.com/acm/latest/userguide/acm-concepts.html#concept-transparency>`_.\n\nYou can export public ACM certificates to use with Amazon Web Services services as\nwell as outside Amazon Web Services Cloud. For more information, see\n`Certificate Manager exportable public certificate <https://docs.aws.amazon.com/acm/latest/userguide/acm-exportable-certificates.html>`_.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "CertificateTransparencyLoggingPreference": {
               "anyOf": [
                  {
                     "enum": [
                        "ENABLED",
                        "DISABLED"
                     ],
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Certificatetransparencyloggingpreference"
            },
            "Export": {
               "anyOf": [
                  {
                     "enum": [
                        "ENABLED",
                        "DISABLED"
                     ],
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Export"
            }
         },
         "title": "CertificateOptions",
         "type": "object"
      },
      "DomainValidation": {
         "description": "Contains information about the validation of each domain name in the certificate.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "DomainName": {
               "title": "Domainname",
               "type": "string"
            },
            "ValidationEmails": {
               "anyOf": [
                  {
                     "items": {
                        "type": "string"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Validationemails"
            },
            "ValidationDomain": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Validationdomain"
            },
            "ValidationStatus": {
               "anyOf": [
                  {
                     "enum": [
                        "PENDING_VALIDATION",
                        "SUCCESS",
                        "FAILED"
                     ],
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Validationstatus"
            },
            "ResourceRecord": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ACMResourceRecord"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null
            },
            "HttpRedirect": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ACMHttpRedirect"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null
            },
            "ValidationMethod": {
               "anyOf": [
                  {
                     "enum": [
                        "EMAIL",
                        "DNS",
                        "HTTP"
                     ],
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Validationmethod"
            }
         },
         "required": [
            "DomainName"
         ],
         "title": "DomainValidation",
         "type": "object"
      },
      "ExtendedKeyUsage": {
         "description": "The Extended Key Usage X.509 v3 extension defines one or more purposes for which the\npublic key can be used.\n\nThis is in addition to or in place of the basic purposes specified by the Key Usage\nextension.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Name": {
               "anyOf": [
                  {
                     "enum": [
                        "TLS_WEB_SERVER_AUTHENTICATION",
                        "TLS_WEB_CLIENT_AUTHENTICATION",
                        "CODE_SIGNING",
                        "EMAIL_PROTECTION",
                        "TIME_STAMPING",
                        "OCSP_SIGNING",
                        "IPSEC_END_SYSTEM",
                        "IPSEC_TUNNEL",
                        "IPSEC_USER",
                        "ANY",
                        "NONE",
                        "CUSTOM"
                     ],
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Name"
            },
            "OID": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Oid"
            }
         },
         "title": "ExtendedKeyUsage",
         "type": "object"
      },
      "KeyUsage": {
         "description": "The Key Usage X.509 v3 extension defines the purpose of the public key contained in\nthe certificate.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Name": {
               "anyOf": [
                  {
                     "enum": [
                        "DIGITAL_SIGNATURE",
                        "NON_REPUDIATION",
                        "KEY_ENCIPHERMENT",
                        "DATA_ENCIPHERMENT",
                        "KEY_AGREEMENT",
                        "CERTIFICATE_SIGNING",
                        "CRL_SIGNING",
                        "ENCIPHER_ONLY",
                        "DECIPHER_ONLY",
                        "ANY",
                        "CUSTOM"
                     ],
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Name"
            }
         },
         "title": "KeyUsage",
         "type": "object"
      },
      "Tag": {
         "description": "The metadata that you apply to a resource to help you categorize and\norganize them. Each tag consists of a key and an optional value. You define\nthem.\n\nThe following basic restrictions apply to tags:\n\n* Maximum number of tags per resource - 50\n* For each resource, each tag key must be unique, and each tag key can have\n  only one value.\n* Maximum key length - 128 Unicode characters in UTF-8\n* Maximum value length - 256 Unicode characters in UTF-8\n* If your tagging schema is used across multiple services and resources,\n  remember that other services may have restrictions on allowed characters.\n  Generally allowed characters are: letters, numbers, and spaces representable in\n  UTF-8, and the following characters: + - = . _ : / @.\n* Tag keys and values are case-sensitive.\n* Do not use ``aws:``, ``AWS:``, or any upper or lowercase combination of such\n  as a prefix for either keys or values as it is reserved for Amazon Web Services\n  use. You cannot edit or delete tag keys or values with this prefix. Tags with\n  this prefix do not count against your tags per resource limit.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Key": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Key"
            },
            "Value": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Value"
            }
         },
         "title": "Tag",
         "type": "object"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• Certificate (botocraft.services.acm.ACMCertificate | None)

• session (Any | None)

field Certificate: ACMCertificate | None = None

Metadata about an ACM certificate.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

Creates a new instance of the Model class with validated data.

Creates a new model setting __dict__ and __pydantic_fields_set__ from trusted or pre-validated data. Default values are respected, but no other validation is performed.

!!! note

model_construct() generally respects the model_config.extra setting on the provided model. That is, if model_config.extra == ‘allow’, then all extra passed values are added to the model instance’s __dict__ and __pydantic_extra__ fields. If model_config.extra == ‘ignore’ (the default), then all extra passed values are ignored. Because no validation is performed with a call to model_construct(), having model_config.extra == ‘forbid’ does not result in an error if extra values are passed, but they will be ignored.

Parameters:

• _fields_set – A set of field names that were originally explicitly set during instantiation. If provided, this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute. Otherwise, the field names from the values argument will be used.

• values – Trusted or pre-validated data dictionary.

Returns:

A new instance of the Model class with validated data.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.acm.DomainValidationOption

Bases: Boto3Model

Contains information about the domain names that you want ACM to use to send you emails that enable you to validate domain ownership.

Show JSON schema

{
   "title": "DomainValidationOption",
   "description": "Contains information about the domain names that you want ACM to use to send you\nemails that enable you to validate domain ownership.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "DomainName": {
         "title": "Domainname",
         "type": "string"
      },
      "ValidationDomain": {
         "title": "Validationdomain",
         "type": "string"
      }
   },
   "required": [
      "DomainName",
      "ValidationDomain"
   ]
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• DomainName (str)

• ValidationDomain (str)

• session (Any | None)

field DomainName: str [Required]

A fully qualified domain name (FQDN) in the certificate request.

field ValidationDomain: str [Required]

The domain name that you want ACM to use to send you validation emails.

This domain name is the suffix of the email addresses that you want ACM to use. This must be the same as the DomainName value or a superdomain of the DomainName value. For example, if you request a certificate for testing.example.com, you can specify example.com for this value. In that case, ACM sends domain validation emails to the following five addresses:

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

Creates a new instance of the Model class with validated data.

Creates a new model setting __dict__ and __pydantic_fields_set__ from trusted or pre-validated data. Default values are respected, but no other validation is performed.

!!! note

model_construct() generally respects the model_config.extra setting on the provided model. That is, if model_config.extra == ‘allow’, then all extra passed values are added to the model instance’s __dict__ and __pydantic_extra__ fields. If model_config.extra == ‘ignore’ (the default), then all extra passed values are ignored. Because no validation is performed with a call to model_construct(), having model_config.extra == ‘forbid’ does not result in an error if extra values are passed, but they will be ignored.

Parameters:

• _fields_set – A set of field names that were originally explicitly set during instantiation. If provided, this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute. Otherwise, the field names from the values argument will be used.

• values – Trusted or pre-validated data dictionary.

Returns:

A new instance of the Model class with validated data.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.acm.Filters

Bases: Boto3Model

This structure can be used in the ListCertificates action to filter the output of the certificate list.

Show JSON schema

{
   "title": "Filters",
   "description": "This structure can be used in the ListCertificates action to filter the output of\nthe certificate list.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "extendedKeyUsage": {
         "anyOf": [
            {
               "items": {
                  "enum": [
                     "TLS_WEB_SERVER_AUTHENTICATION",
                     "TLS_WEB_CLIENT_AUTHENTICATION",
                     "CODE_SIGNING",
                     "EMAIL_PROTECTION",
                     "TIME_STAMPING",
                     "OCSP_SIGNING",
                     "IPSEC_END_SYSTEM",
                     "IPSEC_TUNNEL",
                     "IPSEC_USER",
                     "ANY",
                     "NONE",
                     "CUSTOM"
                  ],
                  "type": "string"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Extendedkeyusage"
      },
      "keyUsage": {
         "anyOf": [
            {
               "items": {
                  "enum": [
                     "DIGITAL_SIGNATURE",
                     "NON_REPUDIATION",
                     "KEY_ENCIPHERMENT",
                     "DATA_ENCIPHERMENT",
                     "KEY_AGREEMENT",
                     "CERTIFICATE_SIGNING",
                     "CRL_SIGNING",
                     "ENCIPHER_ONLY",
                     "DECIPHER_ONLY",
                     "ANY",
                     "CUSTOM"
                  ],
                  "type": "string"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Keyusage"
      },
      "keyTypes": {
         "anyOf": [
            {
               "items": {
                  "enum": [
                     "RSA_1024",
                     "RSA_2048",
                     "RSA_3072",
                     "RSA_4096",
                     "EC_prime256v1",
                     "EC_secp384r1",
                     "EC_secp521r1"
                  ],
                  "type": "string"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Keytypes"
      },
      "exportOption": {
         "anyOf": [
            {
               "enum": [
                  "ENABLED",
                  "DISABLED"
               ],
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Exportoption"
      },
      "managedBy": {
         "anyOf": [
            {
               "const": "CLOUDFRONT",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Managedby"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• exportOption (Literal['ENABLED', 'DISABLED'] | None)

• extendedKeyUsage (list[typing.Literal['TLS_WEB_SERVER_AUTHENTICATION', 'TLS_WEB_CLIENT_AUTHENTICATION', 'CODE_SIGNING', 'EMAIL_PROTECTION', 'TIME_STAMPING', 'OCSP_SIGNING', 'IPSEC_END_SYSTEM', 'IPSEC_TUNNEL', 'IPSEC_USER', 'ANY', 'NONE', 'CUSTOM']] | None)

• keyTypes (list[typing.Literal['RSA_1024', 'RSA_2048', 'RSA_3072', 'RSA_4096', 'EC_prime256v1', 'EC_secp384r1', 'EC_secp521r1']] | None)

• keyUsage (list[typing.Literal['DIGITAL_SIGNATURE', 'NON_REPUDIATION', 'KEY_ENCIPHERMENT', 'DATA_ENCIPHERMENT', 'KEY_AGREEMENT', 'CERTIFICATE_SIGNING', 'CRL_SIGNING', 'ENCIPHER_ONLY', 'DECIPHER_ONLY', 'ANY', 'CUSTOM']] | None)

• managedBy (Literal['CLOUDFRONT'] | None)

• session (Any | None)

field exportOption: Literal['ENABLED', 'DISABLED'] | None = None

Specify ENABLED or DISABLED to identify certificates that can be exported.

field extendedKeyUsage: builtins.list[Literal['TLS_WEB_SERVER_AUTHENTICATION', 'TLS_WEB_CLIENT_AUTHENTICATION', 'CODE_SIGNING', 'EMAIL_PROTECTION', 'TIME_STAMPING', 'OCSP_SIGNING', 'IPSEC_END_SYSTEM', 'IPSEC_TUNNEL', 'IPSEC_USER', 'ANY', 'NONE', 'CUSTOM']] | None [Optional]

Specify one or more ExtendedKeyUsage extension values.

field keyTypes: builtins.list[Literal['RSA_1024', 'RSA_2048', 'RSA_3072', 'RSA_4096', 'EC_prime256v1', 'EC_secp384r1', 'EC_secp521r1']] | None [Optional]

Specify one or more algorithms that can be used to generate key pairs.

field keyUsage: builtins.list[Literal['DIGITAL_SIGNATURE', 'NON_REPUDIATION', 'KEY_ENCIPHERMENT', 'DATA_ENCIPHERMENT', 'KEY_AGREEMENT', 'CERTIFICATE_SIGNING', 'CRL_SIGNING', 'ENCIPHER_ONLY', 'DECIPHER_ONLY', 'ANY', 'CUSTOM']] | None [Optional]

Specify one or more KeyUsage extension values.

field managedBy: Literal['CLOUDFRONT'] | None = None

Identifies the Amazon Web Services service that manages the certificate issued by ACM.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

Creates a new instance of the Model class with validated data.

Creates a new model setting __dict__ and __pydantic_fields_set__ from trusted or pre-validated data. Default values are respected, but no other validation is performed.

!!! note

model_construct() generally respects the model_config.extra setting on the provided model. That is, if model_config.extra == ‘allow’, then all extra passed values are added to the model instance’s __dict__ and __pydantic_extra__ fields. If model_config.extra == ‘ignore’ (the default), then all extra passed values are ignored. Because no validation is performed with a call to model_construct(), having model_config.extra == ‘forbid’ does not result in an error if extra values are passed, but they will be ignored.

Parameters:

• _fields_set – A set of field names that were originally explicitly set during instantiation. If provided, this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute. Otherwise, the field names from the values argument will be used.

• values – Trusted or pre-validated data dictionary.

Returns:

A new instance of the Model class with validated data.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.acm.ImportCertificateResponse

Bases: Boto3Model

Show JSON schema

{
   "title": "ImportCertificateResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "CertificateArn": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Certificatearn"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• CertificateArn (str | None)

• session (Any | None)

field CertificateArn: str | None = None

The Amazon Resource Name (ARN) of the imported certificate.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

Creates a new instance of the Model class with validated data.

Creates a new model setting __dict__ and __pydantic_fields_set__ from trusted or pre-validated data. Default values are respected, but no other validation is performed.

!!! note

model_construct() generally respects the model_config.extra setting on the provided model. That is, if model_config.extra == ‘allow’, then all extra passed values are added to the model instance’s __dict__ and __pydantic_extra__ fields. If model_config.extra == ‘ignore’ (the default), then all extra passed values are ignored. Because no validation is performed with a call to model_construct(), having model_config.extra == ‘forbid’ does not result in an error if extra values are passed, but they will be ignored.

Parameters:

• _fields_set – A set of field names that were originally explicitly set during instantiation. If provided, this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute. Otherwise, the field names from the values argument will be used.

• values – Trusted or pre-validated data dictionary.

Returns:

A new instance of the Model class with validated data.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.acm.ListCertificatesResponse

Bases: Boto3Model

Show JSON schema

{
   "title": "ListCertificatesResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "NextToken": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Nexttoken"
      },
      "CertificateSummaryList": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/CertificateSummary"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Certificatesummarylist"
      }
   },
   "$defs": {
      "CertificateSummary": {
         "description": "This structure is returned in the response object of ListCertificates action.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "KeyAlgorithm": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Keyalgorithm"
            },
            "CertificateArn": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Certificatearn"
            },
            "DomainName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Domainname"
            },
            "SubjectAlternativeNameSummaries": {
               "anyOf": [
                  {
                     "items": {
                        "type": "string"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Subjectalternativenamesummaries"
            },
            "HasAdditionalSubjectAlternativeNames": {
               "anyOf": [
                  {
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Hasadditionalsubjectalternativenames"
            },
            "Status": {
               "anyOf": [
                  {
                     "enum": [
                        "PENDING_VALIDATION",
                        "ISSUED",
                        "INACTIVE",
                        "EXPIRED",
                        "VALIDATION_TIMED_OUT",
                        "REVOKED",
                        "FAILED"
                     ],
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Status"
            },
            "Type": {
               "anyOf": [
                  {
                     "enum": [
                        "IMPORTED",
                        "AMAZON_ISSUED",
                        "PRIVATE"
                     ],
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Type"
            },
            "KeyUsages": {
               "anyOf": [
                  {
                     "items": {
                        "enum": [
                           "DIGITAL_SIGNATURE",
                           "NON_REPUDIATION",
                           "KEY_ENCIPHERMENT",
                           "DATA_ENCIPHERMENT",
                           "KEY_AGREEMENT",
                           "CERTIFICATE_SIGNING",
                           "CRL_SIGNING",
                           "ENCIPHER_ONLY",
                           "DECIPHER_ONLY",
                           "ANY",
                           "CUSTOM"
                        ],
                        "type": "string"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Keyusages"
            },
            "ExtendedKeyUsages": {
               "anyOf": [
                  {
                     "items": {
                        "enum": [
                           "TLS_WEB_SERVER_AUTHENTICATION",
                           "TLS_WEB_CLIENT_AUTHENTICATION",
                           "CODE_SIGNING",
                           "EMAIL_PROTECTION",
                           "TIME_STAMPING",
                           "OCSP_SIGNING",
                           "IPSEC_END_SYSTEM",
                           "IPSEC_TUNNEL",
                           "IPSEC_USER",
                           "ANY",
                           "NONE",
                           "CUSTOM"
                        ],
                        "type": "string"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Extendedkeyusages"
            },
            "ExportOption": {
               "anyOf": [
                  {
                     "enum": [
                        "ENABLED",
                        "DISABLED"
                     ],
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Exportoption"
            },
            "InUse": {
               "anyOf": [
                  {
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Inuse"
            },
            "Exported": {
               "anyOf": [
                  {
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Exported"
            },
            "RenewalEligibility": {
               "anyOf": [
                  {
                     "enum": [
                        "ELIGIBLE",
                        "INELIGIBLE"
                     ],
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Renewaleligibility"
            },
            "NotBefore": {
               "anyOf": [
                  {
                     "format": "date-time",
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Notbefore"
            },
            "NotAfter": {
               "anyOf": [
                  {
                     "format": "date-time",
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Notafter"
            },
            "CreatedAt": {
               "anyOf": [
                  {
                     "format": "date-time",
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Createdat"
            },
            "IssuedAt": {
               "anyOf": [
                  {
                     "format": "date-time",
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Issuedat"
            },
            "ImportedAt": {
               "anyOf": [
                  {
                     "format": "date-time",
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Importedat"
            },
            "RevokedAt": {
               "anyOf": [
                  {
                     "format": "date-time",
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Revokedat"
            },
            "ManagedBy": {
               "anyOf": [
                  {
                     "const": "CLOUDFRONT",
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Managedby"
            }
         },
         "title": "CertificateSummary",
         "type": "object"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• CertificateSummaryList (list[botocraft.services.acm.CertificateSummary] | None)

• NextToken (str | None)

• session (Any | None)

field CertificateSummaryList: builtins.list[CertificateSummary] | None [Optional]

A list of ACM certificates.

field NextToken: str | None = None

When the list is truncated, this value is present and contains the value to use for the NextToken parameter in a subsequent pagination request.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

Creates a new instance of the Model class with validated data.

Creates a new model setting __dict__ and __pydantic_fields_set__ from trusted or pre-validated data. Default values are respected, but no other validation is performed.

!!! note

model_construct() generally respects the model_config.extra setting on the provided model. That is, if model_config.extra == ‘allow’, then all extra passed values are added to the model instance’s __dict__ and __pydantic_extra__ fields. If model_config.extra == ‘ignore’ (the default), then all extra passed values are ignored. Because no validation is performed with a call to model_construct(), having model_config.extra == ‘forbid’ does not result in an error if extra values are passed, but they will be ignored.

Parameters:

• _fields_set – A set of field names that were originally explicitly set during instantiation. If provided, this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute. Otherwise, the field names from the values argument will be used.

• values – Trusted or pre-validated data dictionary.

Returns:

A new instance of the Model class with validated data.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.acm.RequestCertificateResponse

Bases: Boto3Model

Show JSON schema

{
   "title": "RequestCertificateResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "CertificateArn": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Certificatearn"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• CertificateArn (str | None)

• session (Any | None)

field CertificateArn: str | None = None

String that contains the ARN of the issued certificate.

This must be of the form:

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

Creates a new instance of the Model class with validated data.

Creates a new model setting __dict__ and __pydantic_fields_set__ from trusted or pre-validated data. Default values are respected, but no other validation is performed.

!!! note

model_construct() generally respects the model_config.extra setting on the provided model. That is, if model_config.extra == ‘allow’, then all extra passed values are added to the model instance’s __dict__ and __pydantic_extra__ fields. If model_config.extra == ‘ignore’ (the default), then all extra passed values are ignored. Because no validation is performed with a call to model_construct(), having model_config.extra == ‘forbid’ does not result in an error if extra values are passed, but they will be ignored.

Parameters:

• _fields_set – A set of field names that were originally explicitly set during instantiation. If provided, this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute. Otherwise, the field names from the values argument will be used.

• values – Trusted or pre-validated data dictionary.

Returns:

A new instance of the Model class with validated data.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.acm.RevokeCertificateResponse

Bases: Boto3Model

Show JSON schema

{
   "title": "RevokeCertificateResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "CertificateArn": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Certificatearn"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• CertificateArn (str | None)

• session (Any | None)

field CertificateArn: str | None = None

The Amazon Resource Name (ARN) of the public or private certificate that was revoked.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

Creates a new instance of the Model class with validated data.

Creates a new model setting __dict__ and __pydantic_fields_set__ from trusted or pre-validated data. Default values are respected, but no other validation is performed.

!!! note

model_construct() generally respects the model_config.extra setting on the provided model. That is, if model_config.extra == ‘allow’, then all extra passed values are added to the model instance’s __dict__ and __pydantic_extra__ fields. If model_config.extra == ‘ignore’ (the default), then all extra passed values are ignored. Because no validation is performed with a call to model_construct(), having model_config.extra == ‘forbid’ does not result in an error if extra values are passed, but they will be ignored.

Parameters:

• _fields_set – A set of field names that were originally explicitly set during instantiation. If provided, this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute. Otherwise, the field names from the values argument will be used.

• values – Trusted or pre-validated data dictionary.

Returns:

A new instance of the Model class with validated data.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.