gcore 0.1.0__py3-none-any.whl

gcore/types/cloud/reserved_fixed_ip.py

@@ -0,0 +1,98 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from datetime import datetime
+
+from .network import Network
+from ..._models import BaseModel
+from .allowed_address_pairs import AllowedAddressPairs
+
+__all__ = ["ReservedFixedIP", "Attachment", "Reservation"]
+
+
+class Attachment(BaseModel):
+    resource_id: Optional[str] = None
+    """Resource ID"""
+
+    resource_type: Optional[str] = None
+    """Resource type"""
+
+
+class Reservation(BaseModel):
+    resource_id: Optional[str] = None
+    """ID of the instance or load balancer the IP is attached to"""
+
+    resource_type: Optional[str] = None
+    """Resource type of the resource the IP is attached to"""
+
+    status: Optional[str] = None
+    """IP reservation status"""
+
+
+class ReservedFixedIP(BaseModel):
+    allowed_address_pairs: List[AllowedAddressPairs]
+    """Group of subnet masks and/or IP addresses that share the current IP as VIP"""
+
+    attachments: List[Attachment]
+    """Reserved fixed IP attachment entities"""
+
+    created_at: datetime
+    """Datetime when the reserved fixed IP was created"""
+
+    is_external: bool
+    """If reserved fixed IP belongs to a public network"""
+
+    is_vip: bool
+    """If reserved fixed IP is a VIP"""
+
+    name: str
+    """Reserved fixed IP name"""
+
+    network: Network
+    """Network details"""
+
+    network_id: str
+    """ID of the network the port is attached to"""
+
+    port_id: str
+    """ID of the port underlying the reserved fixed IP"""
+
+    region: str
+    """Region name"""
+
+    region_id: int
+    """Region ID"""
+
+    reservation: Reservation
+    """Reserved fixed IP status with resource type and ID it is attached to"""
+
+    status: str
+    """Underlying port status"""
+
+    updated_at: datetime
+    """Datetime when the reserved fixed IP was last updated"""
+
+    creator_task_id: Optional[str] = None
+    """Task that created this entity"""
+
+    fixed_ip_address: Optional[str] = None
+    """IPv4 address of the reserved fixed IP"""
+
+    fixed_ipv6_address: Optional[str] = None
+    """IPv6 address of the reserved fixed IP"""
+
+    project_id: Optional[int] = None
+    """Project ID"""
+
+    subnet_id: Optional[str] = None
+    """ID of the subnet that owns the IP address"""
+
+    subnet_v6_id: Optional[str] = None
+    """ID of the subnet that owns the IPv6 address"""
+
+    task_id: Optional[str] = None
+    """The UUID of the active task that currently holds a lock on the resource.
+
+    This lock prevents concurrent modifications to ensure consistency. If `null`,
+    the resource is not locked.
+    """

gcore/types/cloud/reserved_fixed_ip_create_params.py

@@ -0,0 +1,107 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+from .interface_ip_family import InterfaceIPFamily
+
+__all__ = [
+    "ReservedFixedIPCreateParams",
+    "NewReservedFixedIPExternalSerializer",
+    "NewReservedFixedIPSpecificSubnetSerializer",
+    "NewReservedFixedIPAnySubnetSerializer",
+    "NewReservedFixedIPSpecificIPAddressSerializer",
+    "NewReservedFixedIPSpecificPortSerializer",
+]
+
+
+class NewReservedFixedIPExternalSerializer(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    type: Required[Literal["external"]]
+    """Must be 'external'"""
+
+    ip_family: Optional[InterfaceIPFamily]
+    """Which subnets should be selected: IPv4, IPv6 or use dual stack."""
+
+    is_vip: bool
+    """If reserved fixed IP is a VIP"""
+
+
+class NewReservedFixedIPSpecificSubnetSerializer(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    subnet_id: Required[str]
+    """Reserved fixed IP will be allocated in this subnet"""
+
+    type: Required[Literal["subnet"]]
+    """Must be 'subnet'."""
+
+    is_vip: bool
+    """If reserved fixed IP is a VIP"""
+
+
+class NewReservedFixedIPAnySubnetSerializer(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    network_id: Required[str]
+    """Reserved fixed IP will be allocated in a subnet of this network"""
+
+    type: Required[Literal["any_subnet"]]
+    """Must be 'any_subnet'."""
+
+    ip_family: Optional[InterfaceIPFamily]
+    """Which subnets should be selected: IPv4, IPv6 or use dual stack."""
+
+    is_vip: bool
+    """If reserved fixed IP is a VIP"""
+
+
+class NewReservedFixedIPSpecificIPAddressSerializer(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    ip_address: Required[str]
+    """Reserved fixed IP will be allocated the given IP address"""
+
+    network_id: Required[str]
+    """Reserved fixed IP will be allocated in a subnet of this network"""
+
+    type: Required[Literal["ip_address"]]
+    """Must be 'ip_address'."""
+
+    is_vip: bool
+    """If reserved fixed IP is a VIP"""
+
+
+class NewReservedFixedIPSpecificPortSerializer(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    port_id: Required[str]
+    """
+    Port ID to make a reserved fixed IP (for example, `vip_port_id` of the Load
+    Balancer entity).
+    """
+
+    type: Required[Literal["port"]]
+    """Must be 'port'."""
+
+
+ReservedFixedIPCreateParams: TypeAlias = Union[
+    NewReservedFixedIPExternalSerializer,
+    NewReservedFixedIPSpecificSubnetSerializer,
+    NewReservedFixedIPAnySubnetSerializer,
+    NewReservedFixedIPSpecificIPAddressSerializer,
+    NewReservedFixedIPSpecificPortSerializer,
+]

gcore/types/cloud/reserved_fixed_ip_list_params.py

@@ -0,0 +1,47 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+__all__ = ["ReservedFixedIPListParams"]
+
+
+class ReservedFixedIPListParams(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    available_only: bool
+    """
+    Set to true if the response should only list IP addresses that are not attached
+    to any instance
+    """
+
+    device_id: str
+    """Filter IPs by device ID it is attached to"""
+
+    external_only: bool
+    """Set to true if the response should only list public IP addresses"""
+
+    internal_only: bool
+    """Set to true if the response should only list private IP addresses"""
+
+    ip_address: str
+    """An IPv4 address to filter results by. Regular expression allowed"""
+
+    limit: int
+    """Limit the number of returned IPs"""
+
+    offset: int
+    """Offset value is used to exclude the first set of records from the result"""
+
+    order_by: str
+    """
+    Ordering reserved fixed IP list result by name, status, updated_at, created_at
+    or fixed_ip_address fields of the reserved fixed IP and directions (status.asc),
+    default is "fixed_ip_address.asc"
+    """
+
+    vip_only: bool
+    """Set to true if the response should only list VIPs"""

gcore/types/cloud/reserved_fixed_ips/__init__.py

@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .candidate_port import CandidatePort as CandidatePort
+from .connected_port import ConnectedPort as ConnectedPort
+from .ip_with_subnet import IPWithSubnet as IPWithSubnet
+from .vip_toggle_params import VipToggleParams as VipToggleParams
+from .candidate_port_list import CandidatePortList as CandidatePortList
+from .connected_port_list import ConnectedPortList as ConnectedPortList
+from .vip_update_connected_ports_params import VipUpdateConnectedPortsParams as VipUpdateConnectedPortsParams
+from .vip_replace_connected_ports_params import VipReplaceConnectedPortsParams as VipReplaceConnectedPortsParams

gcore/types/cloud/reserved_fixed_ips/candidate_port.py

@@ -0,0 +1,26 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+
+from ..network import Network
+from ...._models import BaseModel
+from .ip_with_subnet import IPWithSubnet
+
+__all__ = ["CandidatePort"]
+
+
+class CandidatePort(BaseModel):
+    instance_id: str
+    """ID of the instance that owns the port"""
+
+    instance_name: str
+    """Name of the instance that owns the port"""
+
+    ip_assignments: List[IPWithSubnet]
+    """IP addresses assigned to this port"""
+
+    network: Network
+    """Network details"""
+
+    port_id: str
+    """Port ID that shares VIP"""

gcore/types/cloud/reserved_fixed_ips/candidate_port_list.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+
+from ...._models import BaseModel
+from .candidate_port import CandidatePort
+
+__all__ = ["CandidatePortList"]
+
+
+class CandidatePortList(BaseModel):
+    count: int
+    """Number of objects"""
+
+    results: List[CandidatePort]
+    """Objects"""

gcore/types/cloud/reserved_fixed_ips/connected_port.py

@@ -0,0 +1,26 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+
+from ..network import Network
+from ...._models import BaseModel
+from .ip_with_subnet import IPWithSubnet
+
+__all__ = ["ConnectedPort"]
+
+
+class ConnectedPort(BaseModel):
+    instance_id: str
+    """ID of the instance that owns the port"""
+
+    instance_name: str
+    """Name of the instance that owns the port"""
+
+    ip_assignments: List[IPWithSubnet]
+    """IP addresses assigned to this port"""
+
+    network: Network
+    """Network details"""
+
+    port_id: str
+    """Port ID that shares VIP"""

gcore/types/cloud/reserved_fixed_ips/connected_port_list.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+
+from ...._models import BaseModel
+from .connected_port import ConnectedPort
+
+__all__ = ["ConnectedPortList"]
+
+
+class ConnectedPortList(BaseModel):
+    count: int
+    """Number of objects"""
+
+    results: List[ConnectedPort]
+    """Objects"""

gcore/types/cloud/reserved_fixed_ips/ip_with_subnet.py

@@ -0,0 +1,17 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from ..subnet import Subnet
+from ...._models import BaseModel
+
+__all__ = ["IPWithSubnet"]
+
+
+class IPWithSubnet(BaseModel):
+    ip_address: str
+    """IP address"""
+
+    subnet: Subnet
+    """Subnet details"""
+
+    subnet_id: str
+    """ID of the subnet that allocated the IP"""

gcore/types/cloud/reserved_fixed_ips/vip_replace_connected_ports_params.py

@@ -0,0 +1,17 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import TypedDict
+
+__all__ = ["VipReplaceConnectedPortsParams"]
+
+
+class VipReplaceConnectedPortsParams(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    port_ids: List[str]
+    """List of port IDs that will share one VIP"""

gcore/types/cloud/reserved_fixed_ips/vip_toggle_params.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["VipToggleParams"]
+
+
+class VipToggleParams(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    is_vip: Required[bool]
+    """If reserved fixed IP should be a VIP"""

gcore/types/cloud/reserved_fixed_ips/vip_update_connected_ports_params.py

@@ -0,0 +1,17 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import TypedDict
+
+__all__ = ["VipUpdateConnectedPortsParams"]
+
+
+class VipUpdateConnectedPortsParams(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    port_ids: List[str]
+    """List of port IDs that will share one VIP"""

gcore/types/cloud/route.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from ..._models import BaseModel
+
+__all__ = ["Route"]
+
+
+class Route(BaseModel):
+    destination: str
+    """CIDR of destination IPv4 subnet."""
+
+    nexthop: str
+    """
+    IPv4 address to forward traffic to if it's destination IP matches 'destination'
+    CIDR.
+    """

gcore/types/cloud/secret.py

@@ -0,0 +1,64 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["Secret"]
+
+
+class Secret(BaseModel):
+    id: str
+    """Secret uuid"""
+
+    name: str
+    """Secret name"""
+
+    secret_type: Literal["certificate", "opaque", "passphrase", "private", "public", "symmetric"]
+    """Secret type, base64 encoded.
+
+    symmetric - Used for storing byte arrays such as keys suitable for symmetric
+    encryption; public - Used for storing the public key of an asymmetric keypair;
+    private - Used for storing the private key of an asymmetric keypair;
+    passphrase - Used for storing plain text passphrases; certificate - Used for
+    storing cryptographic certificates such as X.509 certificates; opaque - Used for
+    backwards compatibility with previous versions of the API
+    """
+
+    status: str
+    """Status"""
+
+    algorithm: Optional[str] = None
+    """Metadata provided by a user or system for informational purposes.
+
+    Defaults to None
+    """
+
+    bit_length: Optional[int] = None
+    """Metadata provided by a user or system for informational purposes.
+
+    Value must be greater than zero. Defaults to None
+    """
+
+    content_types: Optional[Dict[str, str]] = None
+    """Describes the content-types that can be used to retrieve the payload.
+
+    The content-type used with symmetric secrets is application/octet-stream
+    """
+
+    created: Optional[datetime] = None
+    """Datetime when the secret was created. The format is 2020-01-01T12:00:00+00:00"""
+
+    expiration: Optional[datetime] = None
+    """Datetime when the secret will expire.
+
+    The format is 2020-01-01T12:00:00+00:00. Defaults to None
+    """
+
+    mode: Optional[str] = None
+    """Metadata provided by a user or system for informational purposes.
+
+    Defaults to None
+    """

gcore/types/cloud/secret_create_params.py

@@ -0,0 +1,66 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["SecretCreateParams"]
+
+
+class SecretCreateParams(TypedDict, total=False):
+    project_id: int
+    """Project ID"""
+
+    region_id: int
+    """Region ID"""
+
+    name: Required[str]
+    """Secret name"""
+
+    payload: Required[str]
+    """Secret payload.
+
+    For HTTPS-terminated load balancing, provide base64 encoded conents of a PKCS12
+    file. The PKCS12 file is the combined TLS certificate, key, and intermediate
+    certificate chain obtained from an external certificate authority. The file can
+    be created via openssl, e.g.'openssl pkcs12 -export -inkey server.key -in
+    server.crt -certfile ca-chain.crt -passout pass: -out server.p12'The key and
+    certificate should be PEM-encoded, and the intermediate certificate chain should
+    be multiple PEM-encoded certs concatenated together
+    """
+
+    payload_content_encoding: Required[Literal["base64"]]
+    """The encoding used for the payload to be able to include it in the JSON request.
+
+    Currently only base64 is supported
+    """
+
+    payload_content_type: Required[str]
+    """The media type for the content of the payload"""
+
+    secret_type: Required[Literal["certificate", "opaque", "passphrase", "private", "public", "symmetric"]]
+    """Secret type.
+
+    symmetric - Used for storing byte arrays such as keys suitable for symmetric
+    encryption; public - Used for storing the public key of an asymmetric keypair;
+    private - Used for storing the private key of an asymmetric keypair;
+    passphrase - Used for storing plain text passphrases; certificate - Used for
+    storing cryptographic certificates such as X.509 certificates; opaque - Used for
+    backwards compatibility with previous versions of the API
+    """
+
+    algorithm: Optional[str]
+    """Metadata provided by a user or system for informational purposes."""
+
+    bit_length: Optional[int]
+    """Metadata provided by a user or system for informational purposes.
+
+    Value must be greater than zero.
+    """
+
+    expiration: Optional[str]
+    """Datetime when the secret will expire."""
+
+    mode: Optional[str]
+    """Metadata provided by a user or system for informational purposes."""

gcore/types/cloud/secret_list_response.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+
+from .secret import Secret
+from ..._models import BaseModel
+
+__all__ = ["SecretListResponse"]
+
+
+class SecretListResponse(BaseModel):
+    count: int
+    """Number of objects"""
+
+    results: List[Secret]
+    """Objects"""

gcore/types/cloud/secret_upload_tls_certificate_params.py

@@ -0,0 +1,39 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from datetime import datetime
+from typing_extensions import Required, Annotated, TypedDict
+
+from ..._utils import PropertyInfo
+
+__all__ = ["SecretUploadTlsCertificateParams", "Payload"]
+
+
+class SecretUploadTlsCertificateParams(TypedDict, total=False):
+    project_id: int
+    """Project ID"""
+
+    region_id: int
+    """Region ID"""
+
+    name: Required[str]
+    """Secret name"""
+
+    payload: Required[Payload]
+    """Secret payload."""
+
+    expiration: Annotated[Union[str, datetime, None], PropertyInfo(format="iso8601")]
+    """Datetime when the secret will expire. Defaults to None"""
+
+
+class Payload(TypedDict, total=False):
+    certificate: Required[str]
+    """SSL certificate in PEM format."""
+
+    certificate_chain: Required[str]
+    """SSL certificate chain of intermediates and root certificates in PEM format."""
+
+    private_key: Required[str]
+    """SSL private key in PEM format."""

gcore/types/cloud/security_group.py

@@ -0,0 +1,45 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from datetime import datetime
+
+from .tag import Tag
+from ..._models import BaseModel
+from .security_group_rule import SecurityGroupRule
+
+__all__ = ["SecurityGroup"]
+
+
+class SecurityGroup(BaseModel):
+    id: str
+    """Security group ID"""
+
+    created_at: datetime
+    """Datetime when the security group was created"""
+
+    name: str
+    """Security group name"""
+
+    project_id: int
+    """Project ID"""
+
+    region: str
+    """Region name"""
+
+    region_id: int
+    """Region ID"""
+
+    revision_number: int
+    """The number of revisions"""
+
+    tags_v2: List[Tag]
+    """Tags for a security group"""
+
+    updated_at: datetime
+    """Datetime when the security group was last updated"""
+
+    description: Optional[str] = None
+    """Security group description"""
+
+    security_group_rules: Optional[List[SecurityGroupRule]] = None
+    """Security group rules"""