hushscript 1.0.0__py3-none-any.whl

hushscript/generated/models/org_audit_entry.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="OrgAuditEntry")
+
+
+@_attrs_define
+class OrgAuditEntry:
+    """
+    Attributes:
+        id (int):
+        actor_user_id (None | str):
+        event (str):
+        detail (None | str):
+        created_at (int):
+    """
+
+    id: int
+    actor_user_id: None | str
+    event: str
+    detail: None | str
+    created_at: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        actor_user_id: None | str
+        actor_user_id = self.actor_user_id
+
+        event = self.event
+
+        detail: None | str
+        detail = self.detail
+
+        created_at = self.created_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "actor_user_id": actor_user_id,
+                "event": event,
+                "detail": detail,
+                "created_at": created_at,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        def _parse_actor_user_id(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        actor_user_id = _parse_actor_user_id(d.pop("actor_user_id"))
+
+        event = d.pop("event")
+
+        def _parse_detail(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        detail = _parse_detail(d.pop("detail"))
+
+        created_at = d.pop("created_at")
+
+        org_audit_entry = cls(
+            id=id,
+            actor_user_id=actor_user_id,
+            event=event,
+            detail=detail,
+            created_at=created_at,
+        )
+
+        org_audit_entry.additional_properties = d
+        return org_audit_entry
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

hushscript/generated/models/org_audit_response.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.org_audit_entry import OrgAuditEntry
+
+
+T = TypeVar("T", bound="OrgAuditResponse")
+
+
+@_attrs_define
+class OrgAuditResponse:
+    """
+    Attributes:
+        entries (list[OrgAuditEntry]):
+        next_cursor (None | str): An opaque token for the next page's cursor parameter, or null on the last page. This
+            API refuses a cursor it did not mint.
+    """
+
+    entries: list[OrgAuditEntry]
+    next_cursor: None | str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        entries = []
+        for entries_item_data in self.entries:
+            entries_item = entries_item_data.to_dict()
+            entries.append(entries_item)
+
+        next_cursor: None | str
+        next_cursor = self.next_cursor
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "entries": entries,
+                "next_cursor": next_cursor,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.org_audit_entry import OrgAuditEntry  # noqa: PLC0415
+
+        d = dict(src_dict)
+        entries = []
+        _entries = d.pop("entries")
+        for entries_item_data in _entries:
+            entries_item = OrgAuditEntry.from_dict(entries_item_data)
+
+            entries.append(entries_item)
+
+        def _parse_next_cursor(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        next_cursor = _parse_next_cursor(d.pop("next_cursor"))
+
+        org_audit_response = cls(
+            entries=entries,
+            next_cursor=next_cursor,
+        )
+
+        org_audit_response.additional_properties = d
+        return org_audit_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

hushscript/generated/models/org_invoice.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="OrgInvoice")
+
+
+@_attrs_define
+class OrgInvoice:
+    """
+    Attributes:
+        id (str):
+        number (None | str):
+        kind (str):
+        sku (str):
+        seconds (int):
+        amount_cents (int):
+        currency (str):
+        payment_reference (str):
+        status (str):
+        po_number (None | str):
+        issued_at (int):
+        paid_at (int | None):
+        created_at (int):
+    """
+
+    id: str
+    number: None | str
+    kind: str
+    sku: str
+    seconds: int
+    amount_cents: int
+    currency: str
+    payment_reference: str
+    status: str
+    po_number: None | str
+    issued_at: int
+    paid_at: int | None
+    created_at: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        number: None | str
+        number = self.number
+
+        kind = self.kind
+
+        sku = self.sku
+
+        seconds = self.seconds
+
+        amount_cents = self.amount_cents
+
+        currency = self.currency
+
+        payment_reference = self.payment_reference
+
+        status = self.status
+
+        po_number: None | str
+        po_number = self.po_number
+
+        issued_at = self.issued_at
+
+        paid_at: int | None
+        paid_at = self.paid_at
+
+        created_at = self.created_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "number": number,
+                "kind": kind,
+                "sku": sku,
+                "seconds": seconds,
+                "amount_cents": amount_cents,
+                "currency": currency,
+                "payment_reference": payment_reference,
+                "status": status,
+                "po_number": po_number,
+                "issued_at": issued_at,
+                "paid_at": paid_at,
+                "created_at": created_at,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        def _parse_number(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        number = _parse_number(d.pop("number"))
+
+        kind = d.pop("kind")
+
+        sku = d.pop("sku")
+
+        seconds = d.pop("seconds")
+
+        amount_cents = d.pop("amount_cents")
+
+        currency = d.pop("currency")
+
+        payment_reference = d.pop("payment_reference")
+
+        status = d.pop("status")
+
+        def _parse_po_number(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        po_number = _parse_po_number(d.pop("po_number"))
+
+        issued_at = d.pop("issued_at")
+
+        def _parse_paid_at(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        paid_at = _parse_paid_at(d.pop("paid_at"))
+
+        created_at = d.pop("created_at")
+
+        org_invoice = cls(
+            id=id,
+            number=number,
+            kind=kind,
+            sku=sku,
+            seconds=seconds,
+            amount_cents=amount_cents,
+            currency=currency,
+            payment_reference=payment_reference,
+            status=status,
+            po_number=po_number,
+            issued_at=issued_at,
+            paid_at=paid_at,
+            created_at=created_at,
+        )
+
+        org_invoice.additional_properties = d
+        return org_invoice
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

hushscript/generated/models/org_invoices_response.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.org_invoice import OrgInvoice
+
+
+T = TypeVar("T", bound="OrgInvoicesResponse")
+
+
+@_attrs_define
+class OrgInvoicesResponse:
+    """
+    Attributes:
+        invoices (list[OrgInvoice]):
+        next_cursor (None | str): An opaque token for the next page's cursor parameter, or null on the last page. This
+            API refuses a cursor it did not mint.
+    """
+
+    invoices: list[OrgInvoice]
+    next_cursor: None | str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        invoices = []
+        for invoices_item_data in self.invoices:
+            invoices_item = invoices_item_data.to_dict()
+            invoices.append(invoices_item)
+
+        next_cursor: None | str
+        next_cursor = self.next_cursor
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "invoices": invoices,
+                "next_cursor": next_cursor,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.org_invoice import OrgInvoice  # noqa: PLC0415
+
+        d = dict(src_dict)
+        invoices = []
+        _invoices = d.pop("invoices")
+        for invoices_item_data in _invoices:
+            invoices_item = OrgInvoice.from_dict(invoices_item_data)
+
+            invoices.append(invoices_item)
+
+        def _parse_next_cursor(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        next_cursor = _parse_next_cursor(d.pop("next_cursor"))
+
+        org_invoices_response = cls(
+            invoices=invoices,
+            next_cursor=next_cursor,
+        )
+
+        org_invoices_response.additional_properties = d
+        return org_invoices_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

hushscript/generated/models/org_ledger_entry.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="OrgLedgerEntry")
+
+
+@_attrs_define
+class OrgLedgerEntry:
+    """
+    Attributes:
+        id (int):
+        delta_seconds (int):
+        kind (str):
+        job_id (None | str):
+        invoice_id (None | str):
+        actor_user_id (None | str):
+        member_email (None | str):
+        note (None | str):
+        created_at (int):
+    """
+
+    id: int
+    delta_seconds: int
+    kind: str
+    job_id: None | str
+    invoice_id: None | str
+    actor_user_id: None | str
+    member_email: None | str
+    note: None | str
+    created_at: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        delta_seconds = self.delta_seconds
+
+        kind = self.kind
+
+        job_id: None | str
+        job_id = self.job_id
+
+        invoice_id: None | str
+        invoice_id = self.invoice_id
+
+        actor_user_id: None | str
+        actor_user_id = self.actor_user_id
+
+        member_email: None | str
+        member_email = self.member_email
+
+        note: None | str
+        note = self.note
+
+        created_at = self.created_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "delta_seconds": delta_seconds,
+                "kind": kind,
+                "job_id": job_id,
+                "invoice_id": invoice_id,
+                "actor_user_id": actor_user_id,
+                "member_email": member_email,
+                "note": note,
+                "created_at": created_at,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        delta_seconds = d.pop("delta_seconds")
+
+        kind = d.pop("kind")
+
+        def _parse_job_id(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        job_id = _parse_job_id(d.pop("job_id"))
+
+        def _parse_invoice_id(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        invoice_id = _parse_invoice_id(d.pop("invoice_id"))
+
+        def _parse_actor_user_id(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        actor_user_id = _parse_actor_user_id(d.pop("actor_user_id"))
+
+        def _parse_member_email(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        member_email = _parse_member_email(d.pop("member_email"))
+
+        def _parse_note(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        note = _parse_note(d.pop("note"))
+
+        created_at = d.pop("created_at")
+
+        org_ledger_entry = cls(
+            id=id,
+            delta_seconds=delta_seconds,
+            kind=kind,
+            job_id=job_id,
+            invoice_id=invoice_id,
+            actor_user_id=actor_user_id,
+            member_email=member_email,
+            note=note,
+            created_at=created_at,
+        )
+
+        org_ledger_entry.additional_properties = d
+        return org_ledger_entry
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

hushscript/generated/models/org_ledger_response.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.org_ledger_entry import OrgLedgerEntry
+
+
+T = TypeVar("T", bound="OrgLedgerResponse")
+
+
+@_attrs_define
+class OrgLedgerResponse:
+    """
+    Attributes:
+        entries (list[OrgLedgerEntry]):
+        next_cursor (None | str): An opaque token for the next page's cursor parameter, or null on the last page. This
+            API refuses a cursor it did not mint.
+    """
+
+    entries: list[OrgLedgerEntry]
+    next_cursor: None | str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        entries = []
+        for entries_item_data in self.entries:
+            entries_item = entries_item_data.to_dict()
+            entries.append(entries_item)
+
+        next_cursor: None | str
+        next_cursor = self.next_cursor
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "entries": entries,
+                "next_cursor": next_cursor,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.org_ledger_entry import OrgLedgerEntry  # noqa: PLC0415
+
+        d = dict(src_dict)
+        entries = []
+        _entries = d.pop("entries")
+        for entries_item_data in _entries:
+            entries_item = OrgLedgerEntry.from_dict(entries_item_data)
+
+            entries.append(entries_item)
+
+        def _parse_next_cursor(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        next_cursor = _parse_next_cursor(d.pop("next_cursor"))
+
+        org_ledger_response = cls(
+            entries=entries,
+            next_cursor=next_cursor,
+        )
+
+        org_ledger_response.additional_properties = d
+        return org_ledger_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties