Elastic Load Balancing (elb)

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.elb.ClassicELB

Bases: ClassicELBModelMixin, PrimaryBoto3Model

Information about a load balancer.

Show JSON schema

{
   "title": "ClassicELB",
   "description": "Information about a load balancer.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "LoadBalancerName": {
         "title": "Loadbalancername",
         "type": "string"
      },
      "AvailabilityZones": {
         "items": {
            "type": "string"
         },
         "title": "Availabilityzones",
         "type": "array"
      },
      "Scheme": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": "",
         "title": "Scheme"
      },
      "VPCId": {
         "default": null,
         "title": "Vpcid",
         "type": "string"
      },
      "CreatedTime": {
         "default": null,
         "format": "date-time",
         "title": "Createdtime",
         "type": "string"
      },
      "Instances": {
         "items": {
            "$ref": "#/$defs/ClassicELBInstance"
         },
         "title": "Instances",
         "type": "array"
      },
      "DNSName": {
         "default": null,
         "title": "Dnsname",
         "type": "string"
      },
      "CanonicalHostedZoneName": {
         "default": null,
         "title": "Canonicalhostedzonename",
         "type": "string"
      },
      "CanonicalHostedZoneNameID": {
         "default": null,
         "title": "Canonicalhostedzonenameid",
         "type": "string"
      },
      "ListenerDescriptions": {
         "items": {
            "$ref": "#/$defs/ListenerDescription"
         },
         "title": "Listenerdescriptions",
         "type": "array"
      },
      "SourceSecurityGroup": {
         "$ref": "#/$defs/ClassicELBSourceSecurityGroup",
         "default": null
      },
      "Policies": {
         "anyOf": [
            {
               "$ref": "#/$defs/ClassicELBPolicies"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "BackendServerDescriptions": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/BackendServerDescription"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Backendserverdescriptions"
      },
      "Subnets": {
         "anyOf": [
            {
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Subnets"
      },
      "HealthCheck": {
         "anyOf": [
            {
               "$ref": "#/$defs/ClassicELBHealthCheck"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "SecurityGroups": {
         "anyOf": [
            {
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Securitygroups"
      },
      "Tags": {
         "anyOf": [
            {
               "additionalProperties": {
                  "type": "string"
               },
               "type": "object"
            },
            {
               "type": "null"
            }
         ],
         "title": "Tags"
      },
      "CrossZoneLoadBalancing": {
         "anyOf": [
            {
               "type": "boolean"
            },
            {
               "type": "null"
            }
         ],
         "default": false,
         "title": "Crosszoneloadbalancing"
      },
      "AccessLog": {
         "anyOf": [
            {
               "$ref": "#/$defs/ClassicELBAccessLog"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "ConnectionDraining": {
         "anyOf": [
            {
               "$ref": "#/$defs/ClassicELBConnectionDraining"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "ConnectionSettings": {
         "anyOf": [
            {
               "$ref": "#/$defs/ClassicELBConnectionSettings"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "AdditionalAttributes": {
         "anyOf": [
            {
               "additionalProperties": {
                  "type": "string"
               },
               "type": "object"
            },
            {
               "type": "null"
            }
         ],
         "title": "Additionalattributes"
      }
   },
   "$defs": {
      "AppCookieStickinessPolicy": {
         "description": "Information about a policy for application-controlled session stickiness.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "PolicyName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Policyname"
            },
            "CookieName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Cookiename"
            }
         },
         "title": "AppCookieStickinessPolicy",
         "type": "object"
      },
      "BackendServerDescription": {
         "description": "Information about the configuration of an EC2 instance.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "InstancePort": {
               "anyOf": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Instanceport"
            },
            "PolicyNames": {
               "anyOf": [
                  {
                     "items": {
                        "type": "string"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Policynames"
            }
         },
         "title": "BackendServerDescription",
         "type": "object"
      },
      "ClassicELBAccessLog": {
         "description": "Information about the ``AccessLog`` attribute.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Enabled": {
               "title": "Enabled",
               "type": "boolean"
            },
            "S3BucketName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "S3Bucketname"
            },
            "EmitInterval": {
               "anyOf": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Emitinterval"
            },
            "S3BucketPrefix": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "S3Bucketprefix"
            }
         },
         "required": [
            "Enabled"
         ],
         "title": "ClassicELBAccessLog",
         "type": "object"
      },
      "ClassicELBConnectionDraining": {
         "description": "Information about the ``ConnectionDraining`` attribute.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Enabled": {
               "title": "Enabled",
               "type": "boolean"
            },
            "Timeout": {
               "anyOf": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Timeout"
            }
         },
         "required": [
            "Enabled"
         ],
         "title": "ClassicELBConnectionDraining",
         "type": "object"
      },
      "ClassicELBConnectionSettings": {
         "description": "Information about the ``ConnectionSettings`` attribute.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "IdleTimeout": {
               "title": "Idletimeout",
               "type": "integer"
            }
         },
         "required": [
            "IdleTimeout"
         ],
         "title": "ClassicELBConnectionSettings",
         "type": "object"
      },
      "ClassicELBHealthCheck": {
         "description": "Information about a health check.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Target": {
               "title": "Target",
               "type": "string"
            },
            "Interval": {
               "title": "Interval",
               "type": "integer"
            },
            "Timeout": {
               "title": "Timeout",
               "type": "integer"
            },
            "UnhealthyThreshold": {
               "title": "Unhealthythreshold",
               "type": "integer"
            },
            "HealthyThreshold": {
               "title": "Healthythreshold",
               "type": "integer"
            }
         },
         "required": [
            "Target",
            "Interval",
            "Timeout",
            "UnhealthyThreshold",
            "HealthyThreshold"
         ],
         "title": "ClassicELBHealthCheck",
         "type": "object"
      },
      "ClassicELBInstance": {
         "description": "The ID of an EC2 instance.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "InstanceId": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Instanceid"
            }
         },
         "title": "ClassicELBInstance",
         "type": "object"
      },
      "ClassicELBListener": {
         "description": "Information about a listener.\n\nFor information about the protocols and the ports supported by Elastic Load\nBalancing, see\n`Listeners for Your Classic Load Balancer <https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-listener-config.html>`_\nin the *Classic\nLoad Balancers Guide*.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Protocol": {
               "title": "Protocol",
               "type": "string"
            },
            "LoadBalancerPort": {
               "title": "Loadbalancerport",
               "type": "integer"
            },
            "InstanceProtocol": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Instanceprotocol"
            },
            "InstancePort": {
               "title": "Instanceport",
               "type": "integer"
            },
            "SSLCertificateId": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Sslcertificateid"
            }
         },
         "required": [
            "Protocol",
            "LoadBalancerPort",
            "InstancePort"
         ],
         "title": "ClassicELBListener",
         "type": "object"
      },
      "ClassicELBPolicies": {
         "description": "The policies for a load balancer.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "AppCookieStickinessPolicies": {
               "anyOf": [
                  {
                     "items": {
                        "$ref": "#/$defs/AppCookieStickinessPolicy"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Appcookiestickinesspolicies"
            },
            "LBCookieStickinessPolicies": {
               "anyOf": [
                  {
                     "items": {
                        "$ref": "#/$defs/LBCookieStickinessPolicy"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Lbcookiestickinesspolicies"
            },
            "OtherPolicies": {
               "anyOf": [
                  {
                     "items": {
                        "type": "string"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Otherpolicies"
            }
         },
         "title": "ClassicELBPolicies",
         "type": "object"
      },
      "ClassicELBSourceSecurityGroup": {
         "description": "Information about a source security group.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "OwnerAlias": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Owneralias"
            },
            "GroupName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Groupname"
            }
         },
         "title": "ClassicELBSourceSecurityGroup",
         "type": "object"
      },
      "LBCookieStickinessPolicy": {
         "description": "Information about a policy for duration-based session stickiness.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "PolicyName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Policyname"
            },
            "CookieExpirationPeriod": {
               "anyOf": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Cookieexpirationperiod"
            }
         },
         "title": "LBCookieStickinessPolicy",
         "type": "object"
      },
      "ListenerDescription": {
         "description": "The policies enabled for a listener.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Listener": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ClassicELBListener"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null
            },
            "PolicyNames": {
               "anyOf": [
                  {
                     "items": {
                        "type": "string"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Policynames"
            }
         },
         "title": "ListenerDescription",
         "type": "object"
      }
   },
   "required": [
      "LoadBalancerName",
      "AvailabilityZones"
   ]
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• AccessLog (botocraft.services.elb.ClassicELBAccessLog | None)

• AdditionalAttributes (dict[str, str] | None)

• AvailabilityZones (list[str])

• BackendServerDescriptions (list[botocraft.services.elb.BackendServerDescription] | None)

• CanonicalHostedZoneName (str)

• CanonicalHostedZoneNameID (str)

• ConnectionDraining (botocraft.services.elb.ClassicELBConnectionDraining | None)

• ConnectionSettings (botocraft.services.elb.ClassicELBConnectionSettings | None)

• CreatedTime (datetime.datetime)

• CrossZoneLoadBalancing (bool | None)

• DNSName (str)

• HealthCheck (botocraft.services.elb.ClassicELBHealthCheck | None)

• Instances (list[botocraft.services.elb.ClassicELBInstance])

• Listeners (list[botocraft.services.elb.ListenerDescription])

• LoadBalancerName (str)

• Policies (botocraft.services.elb.ClassicELBPolicies | None)

• Scheme (str | None)

• SecurityGroups (list[str] | None)

• SourceSecurityGroup (botocraft.services.elb.ClassicELBSourceSecurityGroup)

• Subnets (list[str] | None)

• Tags (dict[str, str] | None)

• VPCId (str)

• session (Any | None)

field AccessLog: ClassicELBAccessLog | None = None

The access log settings for the load balancer.

field AdditionalAttributes: dict[str, str] | None [Optional]

Additional attributes for the load balancer.

field AvailabilityZones: builtins.list[str] [Required]

The Availability Zones for the load balancer.

field BackendServerDescriptions: builtins.list[BackendServerDescription] | None [Optional]

Information about your EC2 instances.

field CanonicalHostedZoneName: str = None

The DNS name of the load balancer.

field CanonicalHostedZoneNameID: str = None

The ID of the Amazon Route 53 hosted zone for the load balancer.

field ConnectionDraining: ClassicELBConnectionDraining | None = None

The connection draining settings for the load balancer.

field ConnectionSettings: ClassicELBConnectionSettings | None = None

The connection settings for the load balancer.

field CreatedTime: datetime = None

The date and time the load balancer was created.

field CrossZoneLoadBalancing: bool | None = False

Whether cross-zone load balancing is enabled for the load balancer.

field DNSName: str = None

The DNS name of the load balancer.

field HealthCheck: ClassicELBHealthCheck | None = None

Information about the health checks conducted on the load balancer.

field Instances: builtins.list[ClassicELBInstance] [Optional]

The IDs of the instances for the load balancer.

field Listeners: builtins.list[ListenerDescription] [Optional] (alias 'ListenerDescriptions')

The listeners for the load balancer.

field LoadBalancerName: str [Required]

The name of the load balancer.

field Policies: ClassicELBPolicies | None = None

The policies defined for the load balancer.

field Scheme: str | None = ''

The type of load balancer.

Valid only for load balancers in a VPC.

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

The security groups for the load balancer.

Valid only for load balancers in a VPC.

field SourceSecurityGroup: ClassicELBSourceSecurityGroup = None

The security group for the load balancer, which you can use as part of your inbound rules for your registered instances.

To only allow traffic from load balancers, add a security group rule that specifies this source security group as the inbound source.

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

The IDs of the subnets for the load balancer.

field Tags: dict[str, str] | None [Optional]

The tags associated with the load balancer.

field VPCId: str = None

The ID of the VPC for the load balancer.

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 ClassicELBManager

add_instances(Instances: list[botocraft.services.elb.ClassicELBInstance]) → list[botocraft.services.elb.ClassicELBInstance]

Add instances to the load balancer.

Parameters:

Instances – The IDs of the instances.

add_listeners(Listeners: list[botocraft.services.elb.ClassicELBListener]) → None

Add listeners to the load balancer.

Parameters:

Listeners – The listeners.

add_policy(PolicyName: str, PolicyTypeName: str, PolicyAttributes: list[botocraft.services.elb.PolicyAttribute] | None = None) → None

Add a policy to the load balancer.

Parameters:

• PolicyName – The name of the load balancer policy to be created. This name must be unique within the set of policies for this load balancer.

• PolicyTypeName – The name of the base policy type. To get the list of policy types, use DescribeLoadBalancerPolicyTypes.

Keyword Arguments:

PolicyAttributes – The policy attributes.

delete()

Delete the model.

delete_policy(PolicyName: str) → None

Delete a policy from the load balancer.

Parameters:

PolicyName – The name of the policy.

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.

policies() → list[botocraft.services.elb.PolicyDescription]

Return the policies associated with this load balancer.

This is excludes the StickinessPolicy and the LBCookieStickinessPolicy. You can look directly on this object for those policies.

remove_instances(Instances: list[botocraft.services.elb.ClassicELBInstance]) → list[botocraft.services.elb.ClassicELBInstance]

Remove instances from the load balancer.

Parameters:

Instances – The IDs of the instances.

remove_listeners(LoadBalancerPorts: list[int]) → None

Remove listeners from the load balancer.

Parameters:

LoadBalancerPorts – The client port numbers of the listeners.

save(**kwargs)

Save the model.

set_backend_policies(InstancePort: int, PolicyNames: list[str]) → None

Set the policies for a backend server on the load balancer.

Parameters:

• InstancePort – The port number associated with the EC2 instance.

• PolicyNames – The names of the policies. If the list is empty, then all current polices are removed from the EC2 instance.

set_listener_policies(LoadBalancerPort: int, PolicyNames: list[str]) → None

Set the policies for a listener on the load balancer.

Parameters:

• LoadBalancerPort – The external port of the load balancer.

• PolicyNames – The names of the policies. This list must include all policies to be enabled. If you omit a policy that is currently enabled, it is disabled. If the list is empty, all current policies are disabled.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

set_ssl_certificate(LoadBalancerPort: int, SSLCertificateId: str) → None

Set the SSL certificate for a listener on the load balancer.

Parameters:

• LoadBalancerPort – The port that uses the specified SSL certificate.

• SSLCertificateId – The Amazon Resource Name (ARN) of the SSL certificate.

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

Get the ARN of the model instance.

Returns:

The ARN of the model instance.

Raises:

ValueError – If the model has no ARN identity field.

property ec2_instances: PrimaryBoto3ModelQuerySet

List all the Instance objects that are part of this ELB.

property instances: list[botocraft.services.ec2.Instance] | None

Return the instances associated with this load balancer.

Note

The output of this property is cached on the model instance, so calling this multiple times will not result in multiple calls to the AWS API. If you need a fresh copy of the data, you can re-get the model instance from the manager.

property name: str | None

Return the name of the model. This is the value of the LoadBalancerName 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 LoadBalancerName attribute.

Returns:

The primary key of the model instance.

property security_groups: list[botocraft.services.ec2.SecurityGroup] | None

Return the security groups associated with this load balancer.

Note

The output of this property is cached on the model instance, so calling this multiple times will not result in multiple calls to the AWS API. If you need a fresh copy of the data, you can re-get the model instance from the manager.

property subnets: list[botocraft.services.ec2.Subnet] | None

Return the subnets associated with this load balancer.

Note

The output of this property is cached on the model instance, so calling this multiple times will not result in multiple calls to the AWS API. If you need a fresh copy of the data, you can re-get the model instance from the manager.

property vpc: Vpc | None

Return the Vpc object that this load balancer is associated with.

Note

The output of this property is cached on the model instance, so calling this multiple times will not result in multiple calls to the AWS API. If you need a fresh copy of the data, you can re-get the model instance from the manager.

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.elb.ClassicELBManager

Bases: ClassicELBManagerMixin, Boto3ModelManager

add_listeners(LoadBalancerName: str, Listeners: list[botocraft.services.elb.ClassicELBListener]) → None

Creates one or more listeners for the specified load balancer. If a listener with the specified port does not already exist, it is created; otherwise, the properties of the new listener must match the properties of the existing listener.

Parameters:

• LoadBalancerName – The name of the load balancer.

• Listeners – The listeners.

add_policy(LoadBalancerName: str, PolicyName: str, PolicyTypeName: str, *, PolicyAttributes: list[botocraft.services.elb.PolicyAttribute] | None = None) → None

Creates a policy with the specified attributes for the specified load balancer.

Parameters:

• LoadBalancerName – The name of the load balancer.

• PolicyName – The name of the load balancer policy to be created. This name must be unique within the set of policies for this load balancer.

• PolicyTypeName – The name of the base policy type. To get the list of policy types, use DescribeLoadBalancerPolicyTypes.

Keyword Arguments:

PolicyAttributes – The policy attributes.

add_tags(LoadBalancerNames: list[str], Tags: list[botocraft.services.common.Tag]) → None

Adds the specified tags to the specified load balancer. Each load balancer can have a maximum of 10 tags.

Parameters:

• LoadBalancerNames – The name of the load balancer. You can specify one load balancer only.

• Tags – The tags.

apply_security_groups(LoadBalancerName: str, SecurityGroups: list[str]) → list[str]

Associates one or more security groups with your load balancer in a virtual private cloud (VPC). The specified security groups override the previously associated security groups.

Parameters:

• LoadBalancerName – The name of the load balancer.

• SecurityGroups – The IDs of the security groups to associate with the load balancer. Note that you cannot specify the name of the security group.

attach_to_subnets(LoadBalancerName: str, Subnets: list[str]) → list[str]

Adds one or more subnets to the set of configured subnets for the specified load balancer.

Parameters:

• LoadBalancerName – The name of the load balancer.

• Subnets – The IDs of the subnets to add. You can add only one subnet per Availability Zone.

configure_health_check(LoadBalancerName: str, HealthCheck: ClassicELBHealthCheck) → None

Specifies the health check settings to use when evaluating the health state of your EC2 instances.

Parameters:

• LoadBalancerName – The name of the load balancer.

• HealthCheck – The configuration information.

delete(LoadBalancerName: str) → None

Deletes the specified load balancer.

Parameters:

LoadBalancerName – The name of the load balancer.

delete_policy(LoadBalancerName: str, PolicyName: str) → None

Deletes the specified policy from the specified load balancer. This policy must not be enabled for any listeners.

Parameters:

• LoadBalancerName – The name of the load balancer.

• PolicyName – The name of the policy.

deregister_instances(LoadBalancerName: str, Instances: list[botocraft.services.elb.ClassicELBInstance]) → list[botocraft.services.elb.ClassicELBInstance]

Deregisters the specified instances from the specified load balancer. After the instance is deregistered, it no longer receives traffic from the load balancer.

Parameters:

• LoadBalancerName – The name of the load balancer.

• Instances – The IDs of the instances.

describe_attributes(LoadBalancerName: str) → ClassicELBLoadBalancerAttributes

Describes the attributes for the specified load balancer.

Parameters:

LoadBalancerName – The name of the load balancer.

describe_policies(LoadBalancerName: str, *, PolicyNames: list[str] | None = None) → list[botocraft.services.elb.PolicyDescription]

Describes the specified policies.

Parameters:

LoadBalancerName – The name of the load balancer.

Keyword Arguments:

PolicyNames – The names of the policies.

describe_policy_types(PolicyTypeNames: list[str]) → list[botocraft.services.elb.PolicyTypeDescription]

Describes the specified load balancer policy types or all load balancer policy types.

Parameters:

PolicyTypeNames – The names of the policy types. If no names are specified, describes all policy types defined by Elastic Load Balancing.

describe_tags(LoadBalancerNames: list[str]) → list[botocraft.services.elb.ClassicELBTagDescription]

Describes the tags associated with the specified load balancers.

Parameters:

LoadBalancerNames – The names of the load balancers.

detach_from_subnets(LoadBalancerName: str, Subnets: list[str]) → list[str]

Removes the specified subnets from the set of configured subnets for the load balancer.

Parameters:

• LoadBalancerName – The name of the load balancer.

• Subnets – The IDs of the subnets.

disable_availability_zones(LoadBalancerName: str, AvailabilityZones: list[str]) → list[str]

Removes the specified Availability Zones from the set of Availability Zones for the specified load balancer in EC2-Classic or a default VPC.

Parameters:

• LoadBalancerName – The name of the load balancer.

• AvailabilityZones – The Availability Zones.

enable_availability_zones(LoadBalancerName: str, AvailabilityZones: list[str]) → list[str]

Adds the specified Availability Zones to the set of Availability Zones for the specified load balancer in EC2-Classic or a default VPC.

Parameters:

• LoadBalancerName – The name of the load balancer.

• AvailabilityZones – The Availability Zones. These must be in the same region as the load balancer.

get(LoadBalancerName: str) → ClassicELB | None

Describes the specified the load balancers. If no load balancers are specified, the call describes all of your load balancers.

Parameters:

LoadBalancerName – The name of the classic load balancer.

instance_health(LoadBalancerName: str, *, Instances: list[botocraft.services.elb.ClassicELBInstance] | None = None) → list[botocraft.services.elb.ClassicELBInstanceState]

Describes the state of the specified instances with respect to the specified load balancer. If no instances are specified, the call describes the state of all instances that are currently registered with the load balancer. If instances are specified, their state is returned even if they are no longer registered with the load balancer. The state of terminated instances is not returned.

Parameters:

LoadBalancerName – The name of the load balancer.

Keyword Arguments:

Instances – The IDs of the instances.

list(*, LoadBalancerNames: list[str] | None = None) → PrimaryBoto3ModelQuerySet

Describes the specified the load balancers. If no load balancers are specified, the call describes all of your load balancers.

Keyword Arguments:

LoadBalancerNames – The names of the load balancers.

modify_attributes(LoadBalancerName: str, LoadBalancerAttributes: ClassicELBLoadBalancerAttributes) → ClassicELBLoadBalancerAttributes

Modifies the attributes of the specified load balancer.

Parameters:

• LoadBalancerName – The name of the load balancer.

• LoadBalancerAttributes – The attributes for the load balancer.

register_instances(LoadBalancerName: str, Instances: list[botocraft.services.elb.ClassicELBInstance]) → list[botocraft.services.elb.ClassicELBInstance]

Adds the specified instances to the specified load balancer.

Parameters:

• LoadBalancerName – The name of the load balancer.

• Instances – The IDs of the instances.

remove_listeners(LoadBalancerName: str, LoadBalancerPorts: list[int]) → None

Deletes the specified listeners from the specified load balancer.

Parameters:

• LoadBalancerName – The name of the load balancer.

• LoadBalancerPorts – The client port numbers of the listeners.

remove_tags(LoadBalancerNames: list[str], Tags: list[botocraft.services.elb.TagKeyOnly]) → None

Removes one or more tags from the specified load balancer.

Parameters:

• LoadBalancerNames – The name of the load balancer. You can specify a maximum of one load balancer name.

• Tags – The list of tag keys to remove.

set_backend_policies(LoadBalancerName: str, InstancePort: int, PolicyNames: list[str]) → None

Replaces the set of policies associated with the specified port on which the EC2 instance is listening with a new set of policies. At this time, only the back- end server authentication policy type can be applied to the instance ports; this policy type is composed of multiple public key policies.

Parameters:

• LoadBalancerName – The name of the load balancer.

• InstancePort – The port number associated with the EC2 instance.

• PolicyNames – The names of the policies. If the list is empty, then all current polices are removed from the EC2 instance.

set_listener_policies(LoadBalancerName: str, LoadBalancerPort: int, PolicyNames: list[str]) → None

Replaces the current set of policies for the specified load balancer port with the specified set of policies.

Parameters:

• LoadBalancerName – The name of the load balancer.

• LoadBalancerPort – The external port of the load balancer.

• PolicyNames – The names of the policies. This list must include all policies to be enabled. If you omit a policy that is currently enabled, it is disabled. If the list is empty, all current policies are disabled.

set_ssl_certificate(LoadBalancerName: str, LoadBalancerPort: int, SSLCertificateId: str) → None

Sets the certificate that terminates the specified listener’s SSL connections. The specified certificate replaces any prior certificate that was used on the same load balancer and port.

Parameters:

• LoadBalancerName – The name of the load balancer.

• LoadBalancerPort – The port that uses the specified SSL certificate.

• SSLCertificateId – The Amazon Resource Name (ARN) of the SSL certificate.

service_name: str = 'elb'

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.elb.AppCookieStickinessPolicy

Bases: Boto3Model

Information about a policy for application-controlled session stickiness.

Show JSON schema

{
   "title": "AppCookieStickinessPolicy",
   "description": "Information about a policy for application-controlled session stickiness.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "PolicyName": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Policyname"
      },
      "CookieName": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Cookiename"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• CookieName (str | None)

• PolicyName (str | None)

• session (Any | None)

field CookieName: str | None = None

The name of the application cookie used for stickiness.

field PolicyName: str | None = None

The mnemonic name for the policy being created.

The name must be unique within a set of policies for this load balancer.

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.elb.BackendServerDescription

Bases: Boto3Model

Information about the configuration of an EC2 instance.

Show JSON schema

{
   "title": "BackendServerDescription",
   "description": "Information about the configuration of an EC2 instance.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "InstancePort": {
         "anyOf": [
            {
               "type": "integer"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Instanceport"
      },
      "PolicyNames": {
         "anyOf": [
            {
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Policynames"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• InstancePort (int | None)

• PolicyNames (list[str] | None)

• session (Any | None)

field InstancePort: int | None = None

The port on which the EC2 instance is listening.

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

The names of the policies enabled for the EC2 instance.

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.elb.ClassicELBHealthCheck

Bases: Boto3Model

Information about a health check.

Show JSON schema

{
   "title": "ClassicELBHealthCheck",
   "description": "Information about a health check.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Target": {
         "title": "Target",
         "type": "string"
      },
      "Interval": {
         "title": "Interval",
         "type": "integer"
      },
      "Timeout": {
         "title": "Timeout",
         "type": "integer"
      },
      "UnhealthyThreshold": {
         "title": "Unhealthythreshold",
         "type": "integer"
      },
      "HealthyThreshold": {
         "title": "Healthythreshold",
         "type": "integer"
      }
   },
   "required": [
      "Target",
      "Interval",
      "Timeout",
      "UnhealthyThreshold",
      "HealthyThreshold"
   ]
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• HealthyThreshold (int)

• Interval (int)

• Target (str)

• Timeout (int)

• UnhealthyThreshold (int)

• session (Any | None)

field HealthyThreshold: int [Required]

The number of consecutive health checks successes required before moving the instance to the Healthy state.

field Interval: int [Required]

The approximate interval, in seconds, between health checks of an individual instance.

field Target: str [Required]

The instance being checked.

The protocol is either TCP, HTTP, HTTPS, or SSL. The range of valid ports is one (1) through 65535.

field Timeout: int [Required]

The amount of time, in seconds, during which no response means a failed health check.

field UnhealthyThreshold: int [Required]

The number of consecutive health check failures required before moving the instance to the Unhealthy state.

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.elb.ClassicELBInstance

Bases: Boto3Model

The ID of an EC2 instance.

Show JSON schema

{
   "title": "ClassicELBInstance",
   "description": "The ID of an EC2 instance.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "InstanceId": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Instanceid"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• InstanceId (str | None)

• session (Any | None)

field InstanceId: str | None = None

The instance ID.

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.elb.ClassicELBListener

Bases: Boto3Model

Information about a listener.

For information about the protocols and the ports supported by Elastic Load Balancing, see Listeners for Your Classic Load Balancer in the Classic Load Balancers Guide.

Show JSON schema

{
   "title": "ClassicELBListener",
   "description": "Information about a listener.\n\nFor information about the protocols and the ports supported by Elastic Load\nBalancing, see\n`Listeners for Your Classic Load Balancer <https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-listener-config.html>`_\nin the *Classic\nLoad Balancers Guide*.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Protocol": {
         "title": "Protocol",
         "type": "string"
      },
      "LoadBalancerPort": {
         "title": "Loadbalancerport",
         "type": "integer"
      },
      "InstanceProtocol": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Instanceprotocol"
      },
      "InstancePort": {
         "title": "Instanceport",
         "type": "integer"
      },
      "SSLCertificateId": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Sslcertificateid"
      }
   },
   "required": [
      "Protocol",
      "LoadBalancerPort",
      "InstancePort"
   ]
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• InstancePort (int)

• InstanceProtocol (str | None)

• LoadBalancerPort (int)

• Protocol (str)

• SSLCertificateId (str | None)

• session (Any | None)

field InstancePort: int [Required]

The port on which the instance is listening.

field InstanceProtocol: str | None = None

The protocol to use for routing traffic to instances: HTTP, HTTPS, TCP, or SSL.

field LoadBalancerPort: int [Required]

The port on which the load balancer is listening.

On EC2-VPC, you can specify any port from the range 1-65535. On EC2-Classic, you can specify any port from the following list: 25, 80, 443, 465, 587, 1024-65535.

field Protocol: str [Required]

The load balancer transport protocol to use for routing: HTTP, HTTPS, TCP, or SSL.

field SSLCertificateId: str | None = None

The Amazon Resource Name (ARN) of the server 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.elb.ClassicELBPolicies

Bases: Boto3Model

The policies for a load balancer.

Show JSON schema

{
   "title": "ClassicELBPolicies",
   "description": "The policies for a load balancer.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "AppCookieStickinessPolicies": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/AppCookieStickinessPolicy"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Appcookiestickinesspolicies"
      },
      "LBCookieStickinessPolicies": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/LBCookieStickinessPolicy"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Lbcookiestickinesspolicies"
      },
      "OtherPolicies": {
         "anyOf": [
            {
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Otherpolicies"
      }
   },
   "$defs": {
      "AppCookieStickinessPolicy": {
         "description": "Information about a policy for application-controlled session stickiness.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "PolicyName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Policyname"
            },
            "CookieName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Cookiename"
            }
         },
         "title": "AppCookieStickinessPolicy",
         "type": "object"
      },
      "LBCookieStickinessPolicy": {
         "description": "Information about a policy for duration-based session stickiness.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "PolicyName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Policyname"
            },
            "CookieExpirationPeriod": {
               "anyOf": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Cookieexpirationperiod"
            }
         },
         "title": "LBCookieStickinessPolicy",
         "type": "object"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• AppCookieStickinessPolicies (list[botocraft.services.elb.AppCookieStickinessPolicy] | None)

• LBCookieStickinessPolicies (list[botocraft.services.elb.LBCookieStickinessPolicy] | None)

• OtherPolicies (list[str] | None)

• session (Any | None)

field AppCookieStickinessPolicies: builtins.list[AppCookieStickinessPolicy] | None [Optional]

The stickiness policies created using CreateAppCookieStickinessPolicy.

field LBCookieStickinessPolicies: builtins.list[LBCookieStickinessPolicy] | None [Optional]

The stickiness policies created using CreateLBCookieStickinessPolicy.

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

The policies other than the stickiness policies.

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.elb.ClassicELBSourceSecurityGroup

Bases: Boto3Model

Information about a source security group.

Show JSON schema

{
   "title": "ClassicELBSourceSecurityGroup",
   "description": "Information about a source security group.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "OwnerAlias": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Owneralias"
      },
      "GroupName": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Groupname"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• GroupName (str | None)

• OwnerAlias (str | None)

• session (Any | None)

field GroupName: str | None = None

The name of the security group.

field OwnerAlias: str | None = None

The owner of the security group.

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.elb.LBCookieStickinessPolicy

Bases: Boto3Model

Information about a policy for duration-based session stickiness.

Show JSON schema

{
   "title": "LBCookieStickinessPolicy",
   "description": "Information about a policy for duration-based session stickiness.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "PolicyName": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Policyname"
      },
      "CookieExpirationPeriod": {
         "anyOf": [
            {
               "type": "integer"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Cookieexpirationperiod"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• CookieExpirationPeriod (int | None)

• PolicyName (str | None)

• session (Any | None)

field CookieExpirationPeriod: int | None = None

The time period, in seconds, after which the cookie should be considered stale.

If this parameter is not specified, the stickiness session lasts for the duration of the browser session.

field PolicyName: str | None = None

The name of the policy.

This name must be unique within the set of policies for this load balancer.

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.elb.ListenerDescription

Bases: Boto3Model

The policies enabled for a listener.

Show JSON schema

{
   "title": "ListenerDescription",
   "description": "The policies enabled for a listener.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Listener": {
         "anyOf": [
            {
               "$ref": "#/$defs/ClassicELBListener"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "PolicyNames": {
         "anyOf": [
            {
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Policynames"
      }
   },
   "$defs": {
      "ClassicELBListener": {
         "description": "Information about a listener.\n\nFor information about the protocols and the ports supported by Elastic Load\nBalancing, see\n`Listeners for Your Classic Load Balancer <https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-listener-config.html>`_\nin the *Classic\nLoad Balancers Guide*.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Protocol": {
               "title": "Protocol",
               "type": "string"
            },
            "LoadBalancerPort": {
               "title": "Loadbalancerport",
               "type": "integer"
            },
            "InstanceProtocol": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Instanceprotocol"
            },
            "InstancePort": {
               "title": "Instanceport",
               "type": "integer"
            },
            "SSLCertificateId": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Sslcertificateid"
            }
         },
         "required": [
            "Protocol",
            "LoadBalancerPort",
            "InstancePort"
         ],
         "title": "ClassicELBListener",
         "type": "object"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• Listener (botocraft.services.elb.ClassicELBListener | None)

• PolicyNames (list[str] | None)

• session (Any | None)

field Listener: ClassicELBListener | None = None

The listener.

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

The policies.

If there are no policies enabled, the list is empty.

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.elb.PolicyAttribute

Bases: Boto3Model

Information about a policy attribute.

Show JSON schema

{
   "title": "PolicyAttribute",
   "description": "Information about a policy attribute.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "AttributeName": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Attributename"
      },
      "AttributeValue": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Attributevalue"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• AttributeName (str | None)

• AttributeValue (str | None)

• session (Any | None)

field AttributeName: str | None = None

The name of the attribute.

field AttributeValue: str | None = None

The value of the attribute.

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.elb.AddAvailabilityZonesOutput

Bases: Boto3Model

Contains the output of EnableAvailabilityZonesForLoadBalancer.

Show JSON schema

{
   "title": "AddAvailabilityZonesOutput",
   "description": "Contains the output of EnableAvailabilityZonesForLoadBalancer.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "AvailabilityZones": {
         "anyOf": [
            {
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Availabilityzones"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• AvailabilityZones (list[str] | None)

• session (Any | None)

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

The updated list of Availability Zones for the load balancer.

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.elb.AddTagsOutput

Bases: Boto3Model

Contains the output of AddTags.

Show JSON schema

{
   "title": "AddTagsOutput",
   "description": "Contains the output of AddTags.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• session (Any | None)

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.elb.AdditionalAttribute

Bases: Boto3Model

Information about additional load balancer attributes.

Show JSON schema

{
   "title": "AdditionalAttribute",
   "description": "Information about additional load balancer attributes.",
   "type": "object",
   "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"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• Key (str | None)

• Value (str | None)

• session (Any | None)

field Key: str | None = None

The name of the attribute.

field Value: str | None = None

This value of the attribute.

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.elb.ApplySecurityGroupsToLoadBalancerOutput

Bases: Boto3Model

Contains the output of ApplySecurityGroupsToLoadBalancer.

Show JSON schema

{
   "title": "ApplySecurityGroupsToLoadBalancerOutput",
   "description": "Contains the output of ApplySecurityGroupsToLoadBalancer.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "SecurityGroups": {
         "anyOf": [
            {
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Securitygroups"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• SecurityGroups (list[str] | None)

• session (Any | None)

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

The IDs of the security groups associated with the load balancer.

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.elb.AttachLoadBalancerToSubnetsOutput

Bases: Boto3Model

Contains the output of AttachLoadBalancerToSubnets.

Show JSON schema

{
   "title": "AttachLoadBalancerToSubnetsOutput",
   "description": "Contains the output of AttachLoadBalancerToSubnets.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Subnets": {
         "anyOf": [
            {
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Subnets"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• Subnets (list[str] | None)

• session (Any | None)

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

The IDs of the subnets attached to the load balancer.

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.elb.ClassicELBAccessLog

Bases: Boto3Model

Information about the AccessLog attribute.

Show JSON schema

{
   "title": "ClassicELBAccessLog",
   "description": "Information about the ``AccessLog`` attribute.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Enabled": {
         "title": "Enabled",
         "type": "boolean"
      },
      "S3BucketName": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "S3Bucketname"
      },
      "EmitInterval": {
         "anyOf": [
            {
               "type": "integer"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Emitinterval"
      },
      "S3BucketPrefix": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "S3Bucketprefix"
      }
   },
   "required": [
      "Enabled"
   ]
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• EmitInterval (int | None)

• Enabled (bool)

• S3BucketName (str | None)

• S3BucketPrefix (str | None)

• session (Any | None)

field EmitInterval: int | None = None

The interval for publishing the access logs.

You can specify an interval of either 5 minutes or 60 minutes.

field Enabled: bool [Required]

Specifies whether access logs are enabled for the load balancer.

field S3BucketName: str | None = None

The name of the Amazon S3 bucket where the access logs are stored.

field S3BucketPrefix: str | None = None

The logical hierarchy you created for your Amazon S3 bucket, for example my- bucket-prefix/prod.

If the prefix is not provided, the log is placed at the root level of the bucket.

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.elb.ClassicELBConnectionDraining

Bases: Boto3Model

Information about the ConnectionDraining attribute.

Show JSON schema

{
   "title": "ClassicELBConnectionDraining",
   "description": "Information about the ``ConnectionDraining`` attribute.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Enabled": {
         "title": "Enabled",
         "type": "boolean"
      },
      "Timeout": {
         "anyOf": [
            {
               "type": "integer"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Timeout"
      }
   },
   "required": [
      "Enabled"
   ]
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• Enabled (bool)

• Timeout (int | None)

• session (Any | None)

field Enabled: bool [Required]

Specifies whether connection draining is enabled for the load balancer.

field Timeout: int | None = None

The maximum time, in seconds, to keep the existing connections open before deregistering the instances.

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.elb.ClassicELBConnectionSettings

Bases: Boto3Model

Information about the ConnectionSettings attribute.

Show JSON schema

{
   "title": "ClassicELBConnectionSettings",
   "description": "Information about the ``ConnectionSettings`` attribute.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "IdleTimeout": {
         "title": "Idletimeout",
         "type": "integer"
      }
   },
   "required": [
      "IdleTimeout"
   ]
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• IdleTimeout (int)

• session (Any | None)

field IdleTimeout: int [Required]

The time, in seconds, that the connection is allowed to be idle (no data has been sent over the connection) before it is closed by the load balancer.

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.elb.ClassicELBCrossZoneLoadBalancing

Bases: Boto3Model

Information about the CrossZoneLoadBalancing attribute.

Show JSON schema

{
   "title": "ClassicELBCrossZoneLoadBalancing",
   "description": "Information about the ``CrossZoneLoadBalancing`` attribute.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Enabled": {
         "title": "Enabled",
         "type": "boolean"
      }
   },
   "required": [
      "Enabled"
   ]
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• Enabled (bool)

• session (Any | None)

field Enabled: bool [Required]

Specifies whether cross-zone load balancing is enabled for the load balancer.

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.elb.ClassicELBInstanceState

Bases: Boto3Model

Information about the state of an EC2 instance.

Show JSON schema

{
   "title": "ClassicELBInstanceState",
   "description": "Information about the state of an EC2 instance.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "InstanceId": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Instanceid"
      },
      "State": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "State"
      },
      "ReasonCode": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Reasoncode"
      },
      "Description": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Description"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• Description (str | None)

• InstanceId (str | None)

• ReasonCode (str | None)

• State (str | None)

• session (Any | None)

field Description: str | None = None

A description of the instance state.

This string can contain one or more of the following messages.

field InstanceId: str | None = None

The ID of the instance.

field ReasonCode: str | None = None

Information about the cause of OutOfService instances.

Specifically, whether the cause is Elastic Load Balancing or the instance.

field State: str | None = None

The current state of the instance.

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.elb.ClassicELBLoadBalancerAttributes

Bases: Boto3Model

The attributes for a load balancer.

Show JSON schema

{
   "title": "ClassicELBLoadBalancerAttributes",
   "description": "The attributes for a load balancer.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "CrossZoneLoadBalancing": {
         "anyOf": [
            {
               "$ref": "#/$defs/ClassicELBCrossZoneLoadBalancing"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "AccessLog": {
         "anyOf": [
            {
               "$ref": "#/$defs/ClassicELBAccessLog"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "ConnectionDraining": {
         "anyOf": [
            {
               "$ref": "#/$defs/ClassicELBConnectionDraining"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "ConnectionSettings": {
         "anyOf": [
            {
               "$ref": "#/$defs/ClassicELBConnectionSettings"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "AdditionalAttributes": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/AdditionalAttribute"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Additionalattributes"
      }
   },
   "$defs": {
      "AdditionalAttribute": {
         "description": "Information about additional load balancer attributes.",
         "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": "AdditionalAttribute",
         "type": "object"
      },
      "ClassicELBAccessLog": {
         "description": "Information about the ``AccessLog`` attribute.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Enabled": {
               "title": "Enabled",
               "type": "boolean"
            },
            "S3BucketName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "S3Bucketname"
            },
            "EmitInterval": {
               "anyOf": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Emitinterval"
            },
            "S3BucketPrefix": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "S3Bucketprefix"
            }
         },
         "required": [
            "Enabled"
         ],
         "title": "ClassicELBAccessLog",
         "type": "object"
      },
      "ClassicELBConnectionDraining": {
         "description": "Information about the ``ConnectionDraining`` attribute.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Enabled": {
               "title": "Enabled",
               "type": "boolean"
            },
            "Timeout": {
               "anyOf": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Timeout"
            }
         },
         "required": [
            "Enabled"
         ],
         "title": "ClassicELBConnectionDraining",
         "type": "object"
      },
      "ClassicELBConnectionSettings": {
         "description": "Information about the ``ConnectionSettings`` attribute.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "IdleTimeout": {
               "title": "Idletimeout",
               "type": "integer"
            }
         },
         "required": [
            "IdleTimeout"
         ],
         "title": "ClassicELBConnectionSettings",
         "type": "object"
      },
      "ClassicELBCrossZoneLoadBalancing": {
         "description": "Information about the ``CrossZoneLoadBalancing`` attribute.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Enabled": {
               "title": "Enabled",
               "type": "boolean"
            }
         },
         "required": [
            "Enabled"
         ],
         "title": "ClassicELBCrossZoneLoadBalancing",
         "type": "object"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• AccessLog (botocraft.services.elb.ClassicELBAccessLog | None)

• AdditionalAttributes (list[botocraft.services.elb.AdditionalAttribute] | None)

• ConnectionDraining (botocraft.services.elb.ClassicELBConnectionDraining | None)

• ConnectionSettings (botocraft.services.elb.ClassicELBConnectionSettings | None)

• CrossZoneLoadBalancing (botocraft.services.elb.ClassicELBCrossZoneLoadBalancing | None)

• session (Any | None)

field AccessLog: ClassicELBAccessLog | None = None

If enabled, the load balancer captures detailed information of all requests and delivers the information to the Amazon S3 bucket that you specify.

field AdditionalAttributes: builtins.list[AdditionalAttribute] | None [Optional]

Any additional attributes.

field ConnectionDraining: ClassicELBConnectionDraining | None = None

If enabled, the load balancer allows existing requests to complete before the load balancer shifts traffic away from a deregistered or unhealthy instance.

field ConnectionSettings: ClassicELBConnectionSettings | None = None

If enabled, the load balancer allows the connections to remain idle (no data is sent over the connection) for the specified duration.

field CrossZoneLoadBalancing: ClassicELBCrossZoneLoadBalancing | None = None

If enabled, the load balancer routes the request traffic evenly across all instances regardless of the Availability Zones.

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.elb.ClassicELBTagDescription

Bases: TagsDictMixin, Boto3Model

The tags associated with a load balancer.

Show JSON schema

{
   "title": "ClassicELBTagDescription",
   "description": "The tags associated with a load balancer.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "LoadBalancerName": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Loadbalancername"
      },
      "Tags": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/Tag"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Tags"
      }
   },
   "$defs": {
      "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:

• LoadBalancerName (str | None)

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

• session (Any | None)

field LoadBalancerName: str | None = None

The name of the load balancer.

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

The tags.

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.

tag_class

alias of Tag

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.

property tags: TagsDict

Get the tags for the model instance.

Returns:

The tags for the model instance.

pydantic model botocraft.services.elb.ConfigureHealthCheckOutput

Bases: Boto3Model

Contains the output of ConfigureHealthCheck.

Show JSON schema

{
   "title": "ConfigureHealthCheckOutput",
   "description": "Contains the output of ConfigureHealthCheck.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "HealthCheck": {
         "anyOf": [
            {
               "$ref": "#/$defs/ClassicELBHealthCheck"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      }
   },
   "$defs": {
      "ClassicELBHealthCheck": {
         "description": "Information about a health check.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Target": {
               "title": "Target",
               "type": "string"
            },
            "Interval": {
               "title": "Interval",
               "type": "integer"
            },
            "Timeout": {
               "title": "Timeout",
               "type": "integer"
            },
            "UnhealthyThreshold": {
               "title": "Unhealthythreshold",
               "type": "integer"
            },
            "HealthyThreshold": {
               "title": "Healthythreshold",
               "type": "integer"
            }
         },
         "required": [
            "Target",
            "Interval",
            "Timeout",
            "UnhealthyThreshold",
            "HealthyThreshold"
         ],
         "title": "ClassicELBHealthCheck",
         "type": "object"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• HealthCheck (botocraft.services.elb.ClassicELBHealthCheck | None)

• session (Any | None)

field HealthCheck: ClassicELBHealthCheck | None = None

The updated health check.

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.elb.CreateLoadBalancerListenerOutput

Bases: Boto3Model

Contains the parameters for CreateLoadBalancerListener.

Show JSON schema

{
   "title": "CreateLoadBalancerListenerOutput",
   "description": "Contains the parameters for CreateLoadBalancerListener.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• session (Any | None)

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.elb.CreateLoadBalancerPolicyOutput

Bases: Boto3Model

Contains the output of CreateLoadBalancerPolicy.

Show JSON schema

{
   "title": "CreateLoadBalancerPolicyOutput",
   "description": "Contains the output of CreateLoadBalancerPolicy.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• session (Any | None)

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.elb.DeleteAccessPointOutput

Bases: Boto3Model

Contains the output of DeleteLoadBalancer.

Show JSON schema

{
   "title": "DeleteAccessPointOutput",
   "description": "Contains the output of DeleteLoadBalancer.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• session (Any | None)

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.elb.DeleteLoadBalancerListenerOutput

Bases: Boto3Model

Contains the output of DeleteLoadBalancerListeners.

Show JSON schema

{
   "title": "DeleteLoadBalancerListenerOutput",
   "description": "Contains the output of DeleteLoadBalancerListeners.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• session (Any | None)

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.elb.DeleteLoadBalancerPolicyOutput

Bases: Boto3Model

Contains the output of DeleteLoadBalancerPolicy.

Show JSON schema

{
   "title": "DeleteLoadBalancerPolicyOutput",
   "description": "Contains the output of DeleteLoadBalancerPolicy.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• session (Any | None)

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.elb.DeregisterEndPointsOutput

Bases: Boto3Model

Contains the output of DeregisterInstancesFromLoadBalancer.

Show JSON schema

{
   "title": "DeregisterEndPointsOutput",
   "description": "Contains the output of DeregisterInstancesFromLoadBalancer.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Instances": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/ClassicELBInstance"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Instances"
      }
   },
   "$defs": {
      "ClassicELBInstance": {
         "description": "The ID of an EC2 instance.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "InstanceId": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Instanceid"
            }
         },
         "title": "ClassicELBInstance",
         "type": "object"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• Instances (list[botocraft.services.elb.ClassicELBInstance] | None)

• session (Any | None)

field Instances: builtins.list[ClassicELBInstance] | None [Optional]

The remaining instances registered with the load balancer.

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.elb.DescribeAccessPointsOutput

Bases: Boto3Model

Contains the parameters for DescribeLoadBalancers.

Show JSON schema

{
   "title": "DescribeAccessPointsOutput",
   "description": "Contains the parameters for DescribeLoadBalancers.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "LoadBalancerDescriptions": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/ClassicELB"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Loadbalancerdescriptions"
      },
      "NextMarker": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Nextmarker"
      }
   },
   "$defs": {
      "AppCookieStickinessPolicy": {
         "description": "Information about a policy for application-controlled session stickiness.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "PolicyName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Policyname"
            },
            "CookieName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Cookiename"
            }
         },
         "title": "AppCookieStickinessPolicy",
         "type": "object"
      },
      "BackendServerDescription": {
         "description": "Information about the configuration of an EC2 instance.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "InstancePort": {
               "anyOf": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Instanceport"
            },
            "PolicyNames": {
               "anyOf": [
                  {
                     "items": {
                        "type": "string"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Policynames"
            }
         },
         "title": "BackendServerDescription",
         "type": "object"
      },
      "ClassicELB": {
         "description": "Information about a load balancer.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "LoadBalancerName": {
               "title": "Loadbalancername",
               "type": "string"
            },
            "AvailabilityZones": {
               "items": {
                  "type": "string"
               },
               "title": "Availabilityzones",
               "type": "array"
            },
            "Scheme": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": "",
               "title": "Scheme"
            },
            "VPCId": {
               "default": null,
               "title": "Vpcid",
               "type": "string"
            },
            "CreatedTime": {
               "default": null,
               "format": "date-time",
               "title": "Createdtime",
               "type": "string"
            },
            "Instances": {
               "items": {
                  "$ref": "#/$defs/ClassicELBInstance"
               },
               "title": "Instances",
               "type": "array"
            },
            "DNSName": {
               "default": null,
               "title": "Dnsname",
               "type": "string"
            },
            "CanonicalHostedZoneName": {
               "default": null,
               "title": "Canonicalhostedzonename",
               "type": "string"
            },
            "CanonicalHostedZoneNameID": {
               "default": null,
               "title": "Canonicalhostedzonenameid",
               "type": "string"
            },
            "ListenerDescriptions": {
               "items": {
                  "$ref": "#/$defs/ListenerDescription"
               },
               "title": "Listenerdescriptions",
               "type": "array"
            },
            "SourceSecurityGroup": {
               "$ref": "#/$defs/ClassicELBSourceSecurityGroup",
               "default": null
            },
            "Policies": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ClassicELBPolicies"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null
            },
            "BackendServerDescriptions": {
               "anyOf": [
                  {
                     "items": {
                        "$ref": "#/$defs/BackendServerDescription"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Backendserverdescriptions"
            },
            "Subnets": {
               "anyOf": [
                  {
                     "items": {
                        "type": "string"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Subnets"
            },
            "HealthCheck": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ClassicELBHealthCheck"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null
            },
            "SecurityGroups": {
               "anyOf": [
                  {
                     "items": {
                        "type": "string"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Securitygroups"
            },
            "Tags": {
               "anyOf": [
                  {
                     "additionalProperties": {
                        "type": "string"
                     },
                     "type": "object"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Tags"
            },
            "CrossZoneLoadBalancing": {
               "anyOf": [
                  {
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": false,
               "title": "Crosszoneloadbalancing"
            },
            "AccessLog": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ClassicELBAccessLog"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null
            },
            "ConnectionDraining": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ClassicELBConnectionDraining"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null
            },
            "ConnectionSettings": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ClassicELBConnectionSettings"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null
            },
            "AdditionalAttributes": {
               "anyOf": [
                  {
                     "additionalProperties": {
                        "type": "string"
                     },
                     "type": "object"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Additionalattributes"
            }
         },
         "required": [
            "LoadBalancerName",
            "AvailabilityZones"
         ],
         "title": "ClassicELB",
         "type": "object"
      },
      "ClassicELBAccessLog": {
         "description": "Information about the ``AccessLog`` attribute.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Enabled": {
               "title": "Enabled",
               "type": "boolean"
            },
            "S3BucketName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "S3Bucketname"
            },
            "EmitInterval": {
               "anyOf": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Emitinterval"
            },
            "S3BucketPrefix": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "S3Bucketprefix"
            }
         },
         "required": [
            "Enabled"
         ],
         "title": "ClassicELBAccessLog",
         "type": "object"
      },
      "ClassicELBConnectionDraining": {
         "description": "Information about the ``ConnectionDraining`` attribute.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Enabled": {
               "title": "Enabled",
               "type": "boolean"
            },
            "Timeout": {
               "anyOf": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Timeout"
            }
         },
         "required": [
            "Enabled"
         ],
         "title": "ClassicELBConnectionDraining",
         "type": "object"
      },
      "ClassicELBConnectionSettings": {
         "description": "Information about the ``ConnectionSettings`` attribute.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "IdleTimeout": {
               "title": "Idletimeout",
               "type": "integer"
            }
         },
         "required": [
            "IdleTimeout"
         ],
         "title": "ClassicELBConnectionSettings",
         "type": "object"
      },
      "ClassicELBHealthCheck": {
         "description": "Information about a health check.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Target": {
               "title": "Target",
               "type": "string"
            },
            "Interval": {
               "title": "Interval",
               "type": "integer"
            },
            "Timeout": {
               "title": "Timeout",
               "type": "integer"
            },
            "UnhealthyThreshold": {
               "title": "Unhealthythreshold",
               "type": "integer"
            },
            "HealthyThreshold": {
               "title": "Healthythreshold",
               "type": "integer"
            }
         },
         "required": [
            "Target",
            "Interval",
            "Timeout",
            "UnhealthyThreshold",
            "HealthyThreshold"
         ],
         "title": "ClassicELBHealthCheck",
         "type": "object"
      },
      "ClassicELBInstance": {
         "description": "The ID of an EC2 instance.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "InstanceId": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Instanceid"
            }
         },
         "title": "ClassicELBInstance",
         "type": "object"
      },
      "ClassicELBListener": {
         "description": "Information about a listener.\n\nFor information about the protocols and the ports supported by Elastic Load\nBalancing, see\n`Listeners for Your Classic Load Balancer <https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-listener-config.html>`_\nin the *Classic\nLoad Balancers Guide*.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Protocol": {
               "title": "Protocol",
               "type": "string"
            },
            "LoadBalancerPort": {
               "title": "Loadbalancerport",
               "type": "integer"
            },
            "InstanceProtocol": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Instanceprotocol"
            },
            "InstancePort": {
               "title": "Instanceport",
               "type": "integer"
            },
            "SSLCertificateId": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Sslcertificateid"
            }
         },
         "required": [
            "Protocol",
            "LoadBalancerPort",
            "InstancePort"
         ],
         "title": "ClassicELBListener",
         "type": "object"
      },
      "ClassicELBPolicies": {
         "description": "The policies for a load balancer.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "AppCookieStickinessPolicies": {
               "anyOf": [
                  {
                     "items": {
                        "$ref": "#/$defs/AppCookieStickinessPolicy"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Appcookiestickinesspolicies"
            },
            "LBCookieStickinessPolicies": {
               "anyOf": [
                  {
                     "items": {
                        "$ref": "#/$defs/LBCookieStickinessPolicy"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Lbcookiestickinesspolicies"
            },
            "OtherPolicies": {
               "anyOf": [
                  {
                     "items": {
                        "type": "string"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Otherpolicies"
            }
         },
         "title": "ClassicELBPolicies",
         "type": "object"
      },
      "ClassicELBSourceSecurityGroup": {
         "description": "Information about a source security group.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "OwnerAlias": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Owneralias"
            },
            "GroupName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Groupname"
            }
         },
         "title": "ClassicELBSourceSecurityGroup",
         "type": "object"
      },
      "LBCookieStickinessPolicy": {
         "description": "Information about a policy for duration-based session stickiness.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "PolicyName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Policyname"
            },
            "CookieExpirationPeriod": {
               "anyOf": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Cookieexpirationperiod"
            }
         },
         "title": "LBCookieStickinessPolicy",
         "type": "object"
      },
      "ListenerDescription": {
         "description": "The policies enabled for a listener.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Listener": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ClassicELBListener"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null
            },
            "PolicyNames": {
               "anyOf": [
                  {
                     "items": {
                        "type": "string"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Policynames"
            }
         },
         "title": "ListenerDescription",
         "type": "object"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• LoadBalancerDescriptions (list[botocraft.services.elb.ClassicELB] | None)

• NextMarker (str | None)

• session (Any | None)

field LoadBalancerDescriptions: builtins.list[ClassicELB] | None [Optional]

Information about the load balancers.

field NextMarker: str | None = None

The marker to use when requesting the next set of results.

If there are no additional results, the string is empty.

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.elb.DescribeClassicELBAttributesResponse

Bases: Boto3Model

Contains the output of DescribeLoadBalancerAttributes.

Show JSON schema

{
   "title": "DescribeClassicELBAttributesResponse",
   "description": "Contains the output of DescribeLoadBalancerAttributes.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "LoadBalancerAttributes": {
         "anyOf": [
            {
               "$ref": "#/$defs/ClassicELBLoadBalancerAttributes"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      }
   },
   "$defs": {
      "AdditionalAttribute": {
         "description": "Information about additional load balancer attributes.",
         "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": "AdditionalAttribute",
         "type": "object"
      },
      "ClassicELBAccessLog": {
         "description": "Information about the ``AccessLog`` attribute.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Enabled": {
               "title": "Enabled",
               "type": "boolean"
            },
            "S3BucketName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "S3Bucketname"
            },
            "EmitInterval": {
               "anyOf": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Emitinterval"
            },
            "S3BucketPrefix": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "S3Bucketprefix"
            }
         },
         "required": [
            "Enabled"
         ],
         "title": "ClassicELBAccessLog",
         "type": "object"
      },
      "ClassicELBConnectionDraining": {
         "description": "Information about the ``ConnectionDraining`` attribute.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Enabled": {
               "title": "Enabled",
               "type": "boolean"
            },
            "Timeout": {
               "anyOf": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Timeout"
            }
         },
         "required": [
            "Enabled"
         ],
         "title": "ClassicELBConnectionDraining",
         "type": "object"
      },
      "ClassicELBConnectionSettings": {
         "description": "Information about the ``ConnectionSettings`` attribute.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "IdleTimeout": {
               "title": "Idletimeout",
               "type": "integer"
            }
         },
         "required": [
            "IdleTimeout"
         ],
         "title": "ClassicELBConnectionSettings",
         "type": "object"
      },
      "ClassicELBCrossZoneLoadBalancing": {
         "description": "Information about the ``CrossZoneLoadBalancing`` attribute.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Enabled": {
               "title": "Enabled",
               "type": "boolean"
            }
         },
         "required": [
            "Enabled"
         ],
         "title": "ClassicELBCrossZoneLoadBalancing",
         "type": "object"
      },
      "ClassicELBLoadBalancerAttributes": {
         "description": "The attributes for a load balancer.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "CrossZoneLoadBalancing": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ClassicELBCrossZoneLoadBalancing"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null
            },
            "AccessLog": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ClassicELBAccessLog"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null
            },
            "ConnectionDraining": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ClassicELBConnectionDraining"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null
            },
            "ConnectionSettings": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ClassicELBConnectionSettings"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null
            },
            "AdditionalAttributes": {
               "anyOf": [
                  {
                     "items": {
                        "$ref": "#/$defs/AdditionalAttribute"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Additionalattributes"
            }
         },
         "title": "ClassicELBLoadBalancerAttributes",
         "type": "object"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• LoadBalancerAttributes (botocraft.services.elb.ClassicELBLoadBalancerAttributes | None)

• session (Any | None)

field LoadBalancerAttributes: ClassicELBLoadBalancerAttributes | None = None

Information about the load balancer attributes.

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.elb.DescribeEndPointStateOutput

Bases: Boto3Model

Contains the output for DescribeInstanceHealth.

Show JSON schema

{
   "title": "DescribeEndPointStateOutput",
   "description": "Contains the output for DescribeInstanceHealth.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "InstanceStates": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/ClassicELBInstanceState"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Instancestates"
      }
   },
   "$defs": {
      "ClassicELBInstanceState": {
         "description": "Information about the state of an EC2 instance.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "InstanceId": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Instanceid"
            },
            "State": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "State"
            },
            "ReasonCode": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Reasoncode"
            },
            "Description": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Description"
            }
         },
         "title": "ClassicELBInstanceState",
         "type": "object"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• InstanceStates (list[botocraft.services.elb.ClassicELBInstanceState] | None)

• session (Any | None)

field InstanceStates: builtins.list[ClassicELBInstanceState] | None [Optional]

Information about the health of the instances.

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.elb.DescribeLoadBalancerPoliciesOutput

Bases: Boto3Model

Contains the output of DescribeLoadBalancerPolicies.

Show JSON schema

{
   "title": "DescribeLoadBalancerPoliciesOutput",
   "description": "Contains the output of DescribeLoadBalancerPolicies.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "PolicyDescriptions": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/PolicyDescription"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Policydescriptions"
      }
   },
   "$defs": {
      "PolicyAttributeDescription": {
         "description": "Information about a policy attribute.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "AttributeName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Attributename"
            },
            "AttributeValue": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Attributevalue"
            }
         },
         "title": "PolicyAttributeDescription",
         "type": "object"
      },
      "PolicyDescription": {
         "description": "Information about a policy.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "PolicyName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Policyname"
            },
            "PolicyTypeName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Policytypename"
            },
            "PolicyAttributeDescriptions": {
               "anyOf": [
                  {
                     "items": {
                        "$ref": "#/$defs/PolicyAttributeDescription"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Policyattributedescriptions"
            }
         },
         "title": "PolicyDescription",
         "type": "object"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• PolicyDescriptions (list[botocraft.services.elb.PolicyDescription] | None)

• session (Any | None)

field PolicyDescriptions: builtins.list[PolicyDescription] | None [Optional]

Information about the policies.

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.elb.DescribeLoadBalancerPolicyTypesOutput

Bases: Boto3Model

Contains the output of DescribeLoadBalancerPolicyTypes.

Show JSON schema

{
   "title": "DescribeLoadBalancerPolicyTypesOutput",
   "description": "Contains the output of DescribeLoadBalancerPolicyTypes.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "PolicyTypeDescriptions": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/PolicyTypeDescription"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Policytypedescriptions"
      }
   },
   "$defs": {
      "PolicyAttributeTypeDescription": {
         "description": "Information about a policy attribute type.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "AttributeName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Attributename"
            },
            "AttributeType": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Attributetype"
            },
            "Description": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Description"
            },
            "DefaultValue": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Defaultvalue"
            },
            "Cardinality": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Cardinality"
            }
         },
         "title": "PolicyAttributeTypeDescription",
         "type": "object"
      },
      "PolicyTypeDescription": {
         "description": "Information about a policy type.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "PolicyTypeName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Policytypename"
            },
            "Description": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Description"
            },
            "PolicyAttributeTypeDescriptions": {
               "anyOf": [
                  {
                     "items": {
                        "$ref": "#/$defs/PolicyAttributeTypeDescription"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Policyattributetypedescriptions"
            }
         },
         "title": "PolicyTypeDescription",
         "type": "object"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• PolicyTypeDescriptions (list[botocraft.services.elb.PolicyTypeDescription] | None)

• session (Any | None)

field PolicyTypeDescriptions: builtins.list[PolicyTypeDescription] | None [Optional]

Information about the policy types.

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.elb.DescribeTagsOutput

Bases: Boto3Model

Contains the output for DescribeTags.

Show JSON schema

{
   "title": "DescribeTagsOutput",
   "description": "Contains the output for DescribeTags.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "TagDescriptions": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/ClassicELBTagDescription"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Tagdescriptions"
      }
   },
   "$defs": {
      "ClassicELBTagDescription": {
         "description": "The tags associated with a load balancer.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "LoadBalancerName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Loadbalancername"
            },
            "Tags": {
               "anyOf": [
                  {
                     "items": {
                        "$ref": "#/$defs/Tag"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Tags"
            }
         },
         "title": "ClassicELBTagDescription",
         "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:

• TagDescriptions (list[botocraft.services.elb.ClassicELBTagDescription] | None)

• session (Any | None)

field TagDescriptions: builtins.list[ClassicELBTagDescription] | None [Optional]

Information about the tags.

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.elb.DetachLoadBalancerFromSubnetsOutput

Bases: Boto3Model

Contains the output of DetachLoadBalancerFromSubnets.

Show JSON schema

{
   "title": "DetachLoadBalancerFromSubnetsOutput",
   "description": "Contains the output of DetachLoadBalancerFromSubnets.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Subnets": {
         "anyOf": [
            {
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Subnets"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• Subnets (list[str] | None)

• session (Any | None)

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

The IDs of the remaining subnets for the load balancer.

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.elb.ModifyLoadBalancerAttributesOutput

Bases: Boto3Model

Contains the output of ModifyLoadBalancerAttributes.

Show JSON schema

{
   "title": "ModifyLoadBalancerAttributesOutput",
   "description": "Contains the output of ModifyLoadBalancerAttributes.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "LoadBalancerName": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Loadbalancername"
      },
      "LoadBalancerAttributes": {
         "anyOf": [
            {
               "$ref": "#/$defs/ClassicELBLoadBalancerAttributes"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      }
   },
   "$defs": {
      "AdditionalAttribute": {
         "description": "Information about additional load balancer attributes.",
         "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": "AdditionalAttribute",
         "type": "object"
      },
      "ClassicELBAccessLog": {
         "description": "Information about the ``AccessLog`` attribute.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Enabled": {
               "title": "Enabled",
               "type": "boolean"
            },
            "S3BucketName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "S3Bucketname"
            },
            "EmitInterval": {
               "anyOf": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Emitinterval"
            },
            "S3BucketPrefix": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "S3Bucketprefix"
            }
         },
         "required": [
            "Enabled"
         ],
         "title": "ClassicELBAccessLog",
         "type": "object"
      },
      "ClassicELBConnectionDraining": {
         "description": "Information about the ``ConnectionDraining`` attribute.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Enabled": {
               "title": "Enabled",
               "type": "boolean"
            },
            "Timeout": {
               "anyOf": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Timeout"
            }
         },
         "required": [
            "Enabled"
         ],
         "title": "ClassicELBConnectionDraining",
         "type": "object"
      },
      "ClassicELBConnectionSettings": {
         "description": "Information about the ``ConnectionSettings`` attribute.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "IdleTimeout": {
               "title": "Idletimeout",
               "type": "integer"
            }
         },
         "required": [
            "IdleTimeout"
         ],
         "title": "ClassicELBConnectionSettings",
         "type": "object"
      },
      "ClassicELBCrossZoneLoadBalancing": {
         "description": "Information about the ``CrossZoneLoadBalancing`` attribute.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Enabled": {
               "title": "Enabled",
               "type": "boolean"
            }
         },
         "required": [
            "Enabled"
         ],
         "title": "ClassicELBCrossZoneLoadBalancing",
         "type": "object"
      },
      "ClassicELBLoadBalancerAttributes": {
         "description": "The attributes for a load balancer.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "CrossZoneLoadBalancing": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ClassicELBCrossZoneLoadBalancing"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null
            },
            "AccessLog": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ClassicELBAccessLog"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null
            },
            "ConnectionDraining": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ClassicELBConnectionDraining"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null
            },
            "ConnectionSettings": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/ClassicELBConnectionSettings"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null
            },
            "AdditionalAttributes": {
               "anyOf": [
                  {
                     "items": {
                        "$ref": "#/$defs/AdditionalAttribute"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Additionalattributes"
            }
         },
         "title": "ClassicELBLoadBalancerAttributes",
         "type": "object"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• LoadBalancerAttributes (botocraft.services.elb.ClassicELBLoadBalancerAttributes | None)

• LoadBalancerName (str | None)

• session (Any | None)

field LoadBalancerAttributes: ClassicELBLoadBalancerAttributes | None = None

Information about the load balancer attributes.

field LoadBalancerName: str | None = None

The name of the load balancer.

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.elb.PolicyAttributeDescription

Bases: Boto3Model

Information about a policy attribute.

Show JSON schema

{
   "title": "PolicyAttributeDescription",
   "description": "Information about a policy attribute.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "AttributeName": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Attributename"
      },
      "AttributeValue": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Attributevalue"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• AttributeName (str | None)

• AttributeValue (str | None)

• session (Any | None)

field AttributeName: str | None = None

The name of the attribute.

field AttributeValue: str | None = None

The value of the attribute.

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.elb.PolicyAttributeTypeDescription

Bases: Boto3Model

Information about a policy attribute type.

Show JSON schema

{
   "title": "PolicyAttributeTypeDescription",
   "description": "Information about a policy attribute type.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "AttributeName": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Attributename"
      },
      "AttributeType": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Attributetype"
      },
      "Description": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Description"
      },
      "DefaultValue": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Defaultvalue"
      },
      "Cardinality": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Cardinality"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• AttributeName (str | None)

• AttributeType (str | None)

• Cardinality (str | None)

• DefaultValue (str | None)

• Description (str | None)

• session (Any | None)

field AttributeName: str | None = None

The name of the attribute.

field AttributeType: str | None = None

The type of the attribute.

For example, Boolean or Integer.

field Cardinality: str | None = None

The cardinality of the attribute.

field DefaultValue: str | None = None

The default value of the attribute, if applicable.

field Description: str | None = None

A description of the attribute.

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.elb.PolicyDescription

Bases: Boto3Model

Information about a policy.

Show JSON schema

{
   "title": "PolicyDescription",
   "description": "Information about a policy.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "PolicyName": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Policyname"
      },
      "PolicyTypeName": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Policytypename"
      },
      "PolicyAttributeDescriptions": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/PolicyAttributeDescription"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Policyattributedescriptions"
      }
   },
   "$defs": {
      "PolicyAttributeDescription": {
         "description": "Information about a policy attribute.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "AttributeName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Attributename"
            },
            "AttributeValue": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Attributevalue"
            }
         },
         "title": "PolicyAttributeDescription",
         "type": "object"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• PolicyAttributeDescriptions (list[botocraft.services.elb.PolicyAttributeDescription] | None)

• PolicyName (str | None)

• PolicyTypeName (str | None)

• session (Any | None)

field PolicyAttributeDescriptions: builtins.list[PolicyAttributeDescription] | None [Optional]

The policy attributes.

field PolicyName: str | None = None

The name of the policy.

field PolicyTypeName: str | None = None

The name of the policy type.

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.elb.PolicyTypeDescription

Bases: Boto3Model

Information about a policy type.

Show JSON schema

{
   "title": "PolicyTypeDescription",
   "description": "Information about a policy type.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "PolicyTypeName": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Policytypename"
      },
      "Description": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Description"
      },
      "PolicyAttributeTypeDescriptions": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/PolicyAttributeTypeDescription"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Policyattributetypedescriptions"
      }
   },
   "$defs": {
      "PolicyAttributeTypeDescription": {
         "description": "Information about a policy attribute type.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "AttributeName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Attributename"
            },
            "AttributeType": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Attributetype"
            },
            "Description": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Description"
            },
            "DefaultValue": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Defaultvalue"
            },
            "Cardinality": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Cardinality"
            }
         },
         "title": "PolicyAttributeTypeDescription",
         "type": "object"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• Description (str | None)

• PolicyAttributeTypeDescriptions (list[botocraft.services.elb.PolicyAttributeTypeDescription] | None)

• PolicyTypeName (str | None)

• session (Any | None)

field Description: str | None = None

A description of the policy type.

field PolicyAttributeTypeDescriptions: builtins.list[PolicyAttributeTypeDescription] | None [Optional]

The description of the policy attributes associated with the policies defined by Elastic Load Balancing.

field PolicyTypeName: str | None = None

The name of the policy type.

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.elb.RegisterEndPointsOutput

Bases: Boto3Model

Contains the output of RegisterInstancesWithLoadBalancer.

Show JSON schema

{
   "title": "RegisterEndPointsOutput",
   "description": "Contains the output of RegisterInstancesWithLoadBalancer.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Instances": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/ClassicELBInstance"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Instances"
      }
   },
   "$defs": {
      "ClassicELBInstance": {
         "description": "The ID of an EC2 instance.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "InstanceId": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Instanceid"
            }
         },
         "title": "ClassicELBInstance",
         "type": "object"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• Instances (list[botocraft.services.elb.ClassicELBInstance] | None)

• session (Any | None)

field Instances: builtins.list[ClassicELBInstance] | None [Optional]

The updated list of instances for the load balancer.

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.elb.RemoveAvailabilityZonesOutput

Bases: Boto3Model

Contains the output for DisableAvailabilityZonesForLoadBalancer.

Show JSON schema

{
   "title": "RemoveAvailabilityZonesOutput",
   "description": "Contains the output for DisableAvailabilityZonesForLoadBalancer.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "AvailabilityZones": {
         "anyOf": [
            {
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Availabilityzones"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• AvailabilityZones (list[str] | None)

• session (Any | None)

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

The remaining Availability Zones for the load balancer.

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.elb.RemoveTagsOutput

Bases: Boto3Model

Contains the output of RemoveTags.

Show JSON schema

{
   "title": "RemoveTagsOutput",
   "description": "Contains the output of RemoveTags.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• session (Any | None)

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.elb.SetLoadBalancerListenerSSLCertificateOutput

Bases: Boto3Model

Contains the output of SetLoadBalancerListenerSSLCertificate.

Show JSON schema

{
   "title": "SetLoadBalancerListenerSSLCertificateOutput",
   "description": "Contains the output of SetLoadBalancerListenerSSLCertificate.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• session (Any | None)

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.elb.SetLoadBalancerPoliciesForBackendServerOutput

Bases: Boto3Model

Contains the output of SetLoadBalancerPoliciesForBackendServer.

Show JSON schema

{
   "title": "SetLoadBalancerPoliciesForBackendServerOutput",
   "description": "Contains the output of SetLoadBalancerPoliciesForBackendServer.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• session (Any | None)

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.elb.SetLoadBalancerPoliciesOfListenerOutput

Bases: Boto3Model

Contains the output of SetLoadBalancePoliciesOfListener.

Show JSON schema

{
   "title": "SetLoadBalancerPoliciesOfListenerOutput",
   "description": "Contains the output of SetLoadBalancePoliciesOfListener.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• session (Any | None)

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.elb.TagKeyOnly

Bases: Boto3Model

The key of a tag.

Show JSON schema

{
   "title": "TagKeyOnly",
   "description": "The key of a tag.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Key": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Key"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• Key (str | None)

• session (Any | None)

field Key: str | None = None

The name of the key.

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.