gcore 0.1.0a1__py3-none-any.whl

gcore/types/cloud/security_group_copy_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__ = ["SecurityGroupCopyParams"]
+
+
+class SecurityGroupCopyParams(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    name: Required[str]
+    """Name."""

gcore/types/cloud/security_group_create_params.py

@@ -0,0 +1,94 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, List, Iterable, Optional
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["SecurityGroupCreateParams", "SecurityGroup", "SecurityGroupSecurityGroupRule"]
+
+
+class SecurityGroupCreateParams(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    security_group: Required[SecurityGroup]
+    """Security group"""
+
+    instances: List[str]
+    """List of instances"""
+
+
+class SecurityGroupSecurityGroupRule(TypedDict, total=False):
+    description: str
+    """Rule description"""
+
+    direction: Literal["egress", "ingress"]
+    """
+    Ingress or egress, which is the direction in which the security group is applied
+    """
+
+    ethertype: Literal["IPv4", "IPv6"]
+    """Ether type"""
+
+    port_range_max: Optional[int]
+    """The maximum port number in the range that is matched by the security group rule"""
+
+    port_range_min: Optional[int]
+    """The minimum port number in the range that is matched by the security group rule"""
+
+    protocol: Literal[
+        "ah",
+        "any",
+        "dccp",
+        "egp",
+        "esp",
+        "gre",
+        "icmp",
+        "igmp",
+        "ipencap",
+        "ipip",
+        "ipv6-encap",
+        "ipv6-frag",
+        "ipv6-icmp",
+        "ipv6-nonxt",
+        "ipv6-opts",
+        "ipv6-route",
+        "ospf",
+        "pgm",
+        "rsvp",
+        "sctp",
+        "tcp",
+        "udp",
+        "udplite",
+        "vrrp",
+    ]
+    """Protocol"""
+
+    remote_group_id: str
+    """The remote group UUID to associate with this security group"""
+
+    remote_ip_prefix: Optional[str]
+    """The remote IP prefix that is matched by this security group rule"""
+
+
+class SecurityGroup(TypedDict, total=False):
+    name: Required[str]
+    """Security group name"""
+
+    description: Optional[str]
+    """Security group description"""
+
+    security_group_rules: Iterable[SecurityGroupSecurityGroupRule]
+    """Security group rules"""
+
+    tags: Dict[str, object]
+    """Key-value tags to associate with the resource.
+
+    A tag is a key-value pair that can be associated with a resource, enabling
+    efficient filtering and grouping for better organization and management. Some
+    tags are read-only and cannot be modified by the user. Tags are also integrated
+    with cost reports, allowing cost data to be filtered based on tag keys or
+    values.
+    """

gcore/types/cloud/security_group_list_params.py

@@ -0,0 +1,30 @@
+# 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__ = ["SecurityGroupListParams"]
+
+
+class SecurityGroupListParams(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    limit: int
+    """Limit the number of returned limit request entities."""
+
+    offset: int
+    """Offset value is used to exclude the first set of records from the result."""
+
+    tag_key: List[str]
+    """Filter by tag keys."""
+
+    tag_key_value: str
+    """Filter by tag key-value pairs.
+
+    Must be a valid JSON string. curl -G --data-urlencode "tag_key_value={"key":
+    "value"}" --url "http://localhost:1111/v1/securitygroups/1/1"
+    """

gcore/types/cloud/security_group_rule.py

@@ -0,0 +1,83 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["SecurityGroupRule"]
+
+
+class SecurityGroupRule(BaseModel):
+    id: str
+    """The ID of the security group rule"""
+
+    created_at: datetime
+    """Datetime when the rule was created"""
+
+    direction: Literal["egress", "ingress"]
+    """
+    Ingress or egress, which is the direction in which the security group rule is
+    applied
+    """
+
+    revision_number: int
+    """The revision number of the resource"""
+
+    security_group_id: str
+    """The security group ID to associate with this security group rule"""
+
+    updated_at: datetime
+    """Datetime when the rule was last updated"""
+
+    description: Optional[str] = None
+    """Rule description"""
+
+    ethertype: Optional[Literal["IPv4", "IPv6"]] = None
+    """
+    Must be IPv4 or IPv6, and addresses represented in CIDR must match the ingress
+    or egress rules.
+    """
+
+    port_range_max: Optional[int] = None
+    """The maximum port number in the range that is matched by the security group rule"""
+
+    port_range_min: Optional[int] = None
+    """The minimum port number in the range that is matched by the security group rule"""
+
+    protocol: Optional[
+        Literal[
+            "ah",
+            "any",
+            "dccp",
+            "egp",
+            "esp",
+            "gre",
+            "icmp",
+            "igmp",
+            "ipencap",
+            "ipip",
+            "ipv6-encap",
+            "ipv6-frag",
+            "ipv6-icmp",
+            "ipv6-nonxt",
+            "ipv6-opts",
+            "ipv6-route",
+            "ospf",
+            "pgm",
+            "rsvp",
+            "sctp",
+            "tcp",
+            "udp",
+            "udplite",
+            "vrrp",
+        ]
+    ] = None
+    """Protocol"""
+
+    remote_group_id: Optional[str] = None
+    """The remote group UUID to associate with this security group rule"""
+
+    remote_ip_prefix: Optional[str] = None
+    """The remote IP prefix that is matched by this security group rule"""

gcore/types/cloud/security_group_update_params.py

@@ -0,0 +1,83 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Iterable, Optional
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["SecurityGroupUpdateParams", "ChangedRule"]
+
+
+class SecurityGroupUpdateParams(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    changed_rules: Iterable[ChangedRule]
+    """List of rules to create or delete"""
+
+    name: str
+    """Name"""
+
+
+class ChangedRule(TypedDict, total=False):
+    action: Required[Literal["create", "delete"]]
+    """Action for a rule"""
+
+    description: str
+    """Security grpup rule description"""
+
+    direction: Literal["egress", "ingress"]
+    """
+    Ingress or egress, which is the direction in which the security group rule is
+    applied
+    """
+
+    ethertype: Optional[Literal["IPv4", "IPv6"]]
+    """
+    Must be IPv4 or IPv6, and addresses represented in CIDR must match the ingress
+    or egress rules.
+    """
+
+    port_range_max: int
+    """The maximum port number in the range that is matched by the security group rule"""
+
+    port_range_min: int
+    """The minimum port number in the range that is matched by the security group rule"""
+
+    protocol: Literal[
+        "ah",
+        "any",
+        "dccp",
+        "egp",
+        "esp",
+        "gre",
+        "icmp",
+        "igmp",
+        "ipencap",
+        "ipip",
+        "ipv6-encap",
+        "ipv6-frag",
+        "ipv6-icmp",
+        "ipv6-nonxt",
+        "ipv6-opts",
+        "ipv6-route",
+        "ospf",
+        "pgm",
+        "rsvp",
+        "sctp",
+        "tcp",
+        "udp",
+        "udplite",
+        "vrrp",
+    ]
+    """Protocol"""
+
+    remote_group_id: Optional[str]
+    """The remote group UUID to associate with this security group rule"""
+
+    remote_ip_prefix: Optional[str]
+    """The remote IP prefix that is matched by this security group rule"""
+
+    security_group_rule_id: Optional[str]
+    """UUID of rule to be deleted. Required for action 'delete' only"""

gcore/types/cloud/security_groups/__init__.py

@@ -0,0 +1,6 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .rule_create_params import RuleCreateParams as RuleCreateParams
+from .rule_replace_params import RuleReplaceParams as RuleReplaceParams

gcore/types/cloud/security_groups/rule_create_params.py

@@ -0,0 +1,65 @@
+# 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, TypedDict
+
+__all__ = ["RuleCreateParams"]
+
+
+class RuleCreateParams(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    description: str
+    """Rule description"""
+
+    direction: Literal["egress", "ingress"]
+    """
+    Ingress or egress, which is the direction in which the security group is applied
+    """
+
+    ethertype: Literal["IPv4", "IPv6"]
+    """Ether type"""
+
+    port_range_max: Optional[int]
+    """The maximum port number in the range that is matched by the security group rule"""
+
+    port_range_min: Optional[int]
+    """The minimum port number in the range that is matched by the security group rule"""
+
+    protocol: Literal[
+        "ah",
+        "any",
+        "dccp",
+        "egp",
+        "esp",
+        "gre",
+        "icmp",
+        "igmp",
+        "ipencap",
+        "ipip",
+        "ipv6-encap",
+        "ipv6-frag",
+        "ipv6-icmp",
+        "ipv6-nonxt",
+        "ipv6-opts",
+        "ipv6-route",
+        "ospf",
+        "pgm",
+        "rsvp",
+        "sctp",
+        "tcp",
+        "udp",
+        "udplite",
+        "vrrp",
+    ]
+    """Protocol"""
+
+    remote_group_id: str
+    """The remote group UUID to associate with this security group"""
+
+    remote_ip_prefix: Optional[str]
+    """The remote IP prefix that is matched by this security group rule"""

gcore/types/cloud/security_groups/rule_replace_params.py

@@ -0,0 +1,72 @@
+# 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__ = ["RuleReplaceParams"]
+
+
+class RuleReplaceParams(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    direction: Required[Literal["egress", "ingress"]]
+    """
+    Ingress or egress, which is the direction in which the security group rule is
+    applied
+    """
+
+    security_group_id: Required[str]
+    """Parent security group of this rule"""
+
+    description: str
+    """Rule description"""
+
+    ethertype: Optional[Literal["IPv4", "IPv6"]]
+    """
+    Must be IPv4 or IPv6, and addresses represented in CIDR must match the ingress
+    or egress rules.
+    """
+
+    port_range_max: Optional[int]
+    """The maximum port number in the range that is matched by the security group rule"""
+
+    port_range_min: Optional[int]
+    """The minimum port number in the range that is matched by the security group rule"""
+
+    protocol: Literal[
+        "ah",
+        "any",
+        "dccp",
+        "egp",
+        "esp",
+        "gre",
+        "icmp",
+        "igmp",
+        "ipencap",
+        "ipip",
+        "ipv6-encap",
+        "ipv6-frag",
+        "ipv6-icmp",
+        "ipv6-nonxt",
+        "ipv6-opts",
+        "ipv6-route",
+        "ospf",
+        "pgm",
+        "rsvp",
+        "sctp",
+        "tcp",
+        "udp",
+        "udplite",
+        "vrrp",
+    ]
+    """Protocol"""
+
+    remote_group_id: Optional[str]
+    """The remote group UUID to associate with this security group rule"""
+
+    remote_ip_prefix: Optional[str]
+    """The remote IP prefix that is matched by this security group rule"""

gcore/types/cloud/session_persistence.py

@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from ..._models import BaseModel
+from .lb_session_persistence_type import LbSessionPersistenceType
+
+__all__ = ["SessionPersistence"]
+
+
+class SessionPersistence(BaseModel):
+    type: LbSessionPersistenceType
+    """Session persistence type"""
+
+    cookie_name: Optional[str] = None
+    """Should be set if app cookie or http cookie is used"""
+
+    persistence_granularity: Optional[str] = None
+    """Subnet mask if source_ip is used. For UDP ports only"""
+
+    persistence_timeout: Optional[int] = None
+    """Session persistence timeout. For UDP ports only"""

gcore/types/cloud/ssh_key.py

@@ -0,0 +1,39 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["SSHKey"]
+
+
+class SSHKey(BaseModel):
+    id: str
+    """SSH key ID"""
+
+    created_at: Optional[datetime] = None
+    """SSH key creation time"""
+
+    fingerprint: str
+    """Fingerprint"""
+
+    name: str
+    """SSH key name"""
+
+    project_id: Optional[int] = None
+    """Project ID"""
+
+    public_key: str
+    """The public part of an SSH key is the shareable portion of an SSH key pair.
+
+    It can be safely sent to servers or services to grant access. It does not
+    contain sensitive information.
+    """
+
+    shared_in_project: bool
+    """SSH key will be visible to all users in the project"""
+
+    state: Literal["ACTIVE", "DELETING"]
+    """SSH key state"""

gcore/types/cloud/ssh_key_create_params.py

@@ -0,0 +1,31 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["SSHKeyCreateParams"]
+
+
+class SSHKeyCreateParams(TypedDict, total=False):
+    project_id: int
+    """Project ID"""
+
+    name: Required[str]
+    """SSH key name"""
+
+    public_key: str
+    """The public part of an SSH key is the shareable portion of an SSH key pair.
+
+    It can be safely sent to servers or services to grant access. It does not
+    contain sensitive information.
+
+    - If you’re uploading your own key, provide the public part here (usually found
+      in a file like `id_ed25519.pub`).
+    - If you want the platform to generate an Ed25519 key pair for you, leave this
+      field empty — the system will return the private key in the response **once
+      only**.
+    """
+
+    shared_in_project: bool
+    """SSH key is shared with all users in the project"""

gcore/types/cloud/ssh_key_created.py

@@ -0,0 +1,53 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["SSHKeyCreated"]
+
+
+class SSHKeyCreated(BaseModel):
+    id: str
+    """SSH key ID"""
+
+    created_at: datetime
+    """SSH key creation time"""
+
+    fingerprint: str
+    """Fingerprint"""
+
+    name: str
+    """SSH key name"""
+
+    private_key: Optional[str] = None
+    """The private part of an SSH key is the confidential portion of the key pair.
+
+    It should never be shared or exposed. This key is used to prove your identity
+    when connecting to a server.
+
+    If you omit the `public_key`, the platform will generate a key for you. The
+    private_key will be returned **once** in the API response. Be sure to save it
+    securely, as it cannot be retrieved again later.
+
+    Best practice: Save the private key to a secure location on your machine (e.g.,
+    `~/.ssh/id_ed25519`) and set the file permissions to be readable only by you.
+    """
+
+    project_id: int
+    """Project ID"""
+
+    public_key: str
+    """The public part of an SSH key is the shareable portion of an SSH key pair.
+
+    It can be safely sent to servers or services to grant access. It does not
+    contain sensitive information.
+    """
+
+    shared_in_project: bool
+    """SSH key will be visible to all users in the project"""
+
+    state: Literal["ACTIVE", "DELETING"]
+    """SSH key state"""

gcore/types/cloud/ssh_key_list_params.py

@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["SSHKeyListParams"]
+
+
+class SSHKeyListParams(TypedDict, total=False):
+    project_id: int
+    """Project ID"""
+
+    limit: int
+    """Maximum number of SSH keys to return"""
+
+    offset: int
+    """Offset for pagination"""
+
+    order_by: Literal["created_at.asc", "created_at.desc", "name.asc", "name.desc"]
+    """Sort order for the SSH keys"""

gcore/types/cloud/ssh_key_update_params.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["SSHKeyUpdateParams"]
+
+
+class SSHKeyUpdateParams(TypedDict, total=False):
+    project_id: int
+    """Project ID"""
+
+    shared_in_project: Required[bool]
+    """Share your ssh key with all users in the project"""