feat: add ForwardingRequest, Secret, Team, ManagedAccount resources + ManualConnect

Critical SDK sync — 4 entirely missing resources and 1 missing sub-resource:
- ForwardingRequest: POST /forwarding_requests, GET /forwarding_requests/{id}
- Secret: Full CRUD (/secrets)
- Team: Retrieve, create, encryption key, MLE public keys
- ManagedAccount: List, retrieve, transactions
- Entity ManualConnect: sub-resource for manual account linking

All resources wired into the Method client.

Author: Mack

method/method.py

@@ -12,6 +12,10 @@
 from method.resources.Events import EventResource
 from method.resources.CardProduct import CardProductResource
 from method.resources.Opal import OpalResource
+from method.resources.ForwardingRequests import ForwardingRequestResource
+from method.resources.Secrets import SecretResource
+from method.resources.Teams import TeamResource
+from method.resources.ManagedAccounts import ManagedAccountResource
 
 class Method:
     accounts: AccountResource
@@ -26,6 +30,10 @@ class Method:
     simulate: SimulateResource
     card_products: CardProductResource
     opal: OpalResource
+    forwarding_requests: ForwardingRequestResource
+    secrets: SecretResource
+    teams: TeamResource
+    managed_accounts: ManagedAccountResource
 
     def __init__(self, opts: ConfigurationOpts = None, **kwargs: ConfigurationOpts):
         _opts: ConfigurationOpts = {**(opts or {}), **kwargs}  # type: ignore
@@ -43,6 +51,10 @@ def __init__(self, opts: ConfigurationOpts = None, **kwargs: ConfigurationOpts):
         self.simulate = SimulateResource(config)
         self.card_products = CardProductResource(config)
         self.opal = OpalResource(config)
+        self.forwarding_requests = ForwardingRequestResource(config)
+        self.secrets = SecretResource(config)
+        self.teams = TeamResource(config)
+        self.managed_accounts = ManagedAccountResource(config)
 
     def ping(self) -> MethodResponse[PingResponse]:
         return self.healthcheck.retrieve()

method/resources/Entities/Entity.py

@@ -14,6 +14,7 @@
 from method.resources.Entities.Sensitive import EntitySensitiveResource
 from method.resources.Entities.Subscriptions import EntitySubscriptionsResource
 from method.resources.Entities.VerificationSessions import EntityVerificationSessionResource
+from method.resources.Entities.ManualConnect import EntityManualConnectResource
 
 
 class EntityCreateOpts(TypedDict):
@@ -116,6 +117,7 @@ class EntitySubResources:
     sensitive: EntitySensitiveResource
     subscriptions: EntitySubscriptionsResource
     verification_sessions: EntityVerificationSessionResource
+    manual_connect: EntityManualConnectResource
 
     def __init__(self, _id: str, config: Configuration):
         self.attributes = EntityAttributesResource(config.add_path(_id))
@@ -127,6 +129,7 @@ def __init__(self, _id: str, config: Configuration):
         self.sensitive = EntitySensitiveResource(config.add_path(_id))
         self.subscriptions = EntitySubscriptionsResource(config.add_path(_id))
         self.verification_sessions = EntityVerificationSessionResource(config.add_path(_id))
+        self.manual_connect = EntityManualConnectResource(config.add_path(_id))
 
 
 class EntityResource(Resource):

method/resources/Entities/ManualConnect.py

@@ -0,0 +1,55 @@
+from typing import TypedDict, Optional, List, Literal
+
+from method.resource import MethodResponse, Resource, RequestOpts
+from method.configuration import Configuration
+
+
+class ManualConnectNarrativeCode(TypedDict):
+    code: Optional[str]
+    description: Optional[str]
+
+
+class ManualConnectTradeline(TypedDict):
+    type_code: Optional[str]
+    portfolio_type_code: Optional[str]
+    designator_code: Optional[str]
+    number: Optional[str]
+    creditor_name: Optional[str]
+    creditor_code: Optional[str]
+    balance: Optional[int]
+    highest_balance: Optional[int]
+    credit_limit: Optional[int]
+    term: Optional[int]
+    next_payment_minimum_amount: Optional[int]
+    last_payment_amount: Optional[int]
+    payment_history: Optional[List[str]]
+    past_due_amount: Optional[int]
+    delinquency_charge_off_amount: Optional[int]
+    opened_at: Optional[str]
+    closed_at: Optional[str]
+    last_activity_date: Optional[str]
+    reported_date: Optional[str]
+    next_payment_due_date: Optional[str]
+    last_payment_date: Optional[str]
+    delinquency_first_start_date: Optional[str]
+    narrative_codes: Optional[List[ManualConnectNarrativeCode]]
+    external_id: Optional[str]
+
+
+ManualConnectBureauLiterals = Literal['equifax', 'transunion']
+
+
+class ManualConnectCreateOpts(TypedDict):
+    bureau: ManualConnectBureauLiterals
+    tradelines: List[ManualConnectTradeline]
+
+
+class EntityManualConnectResource(Resource):
+    def __init__(self, config: Configuration):
+        super(EntityManualConnectResource, self).__init__(config.add_path('manual_connect'))
+
+    def retrieve(self, _id: str) -> MethodResponse:
+        return super(EntityManualConnectResource, self)._get_with_id(_id)
+
+    def create(self, opts: ManualConnectCreateOpts, request_opts: Optional[RequestOpts] = None) -> MethodResponse:
+        return super(EntityManualConnectResource, self)._create(opts, request_opts=request_opts)

method/resources/ForwardingRequests/ForwardingRequest.py

@@ -0,0 +1,68 @@
+from typing import TypedDict, Optional, List, Dict, Any, Literal
+
+from method.resource import MethodResponse, Resource, RequestOpts
+from method.configuration import Configuration
+
+
+ForwardingRequestStatusesLiterals = Literal[
+    'completed',
+    'failed'
+]
+
+
+ForwardingRequestMethodsLiterals = Literal[
+    'GET',
+    'POST',
+    'PUT',
+    'PATCH',
+    'DELETE'
+]
+
+
+class ForwardingRequestDetail(TypedDict):
+    url: str
+    method: ForwardingRequestMethodsLiterals
+    headers: Dict[str, str]
+    body: str
+
+
+class ForwardingResponseDetail(TypedDict):
+    status_code: Optional[int]
+    headers: Dict[str, str]
+    body: Optional[Any]
+
+
+class ForwardingRequestStatusHistory(TypedDict):
+    status: str
+    message: Optional[str]
+
+
+class ForwardingRequest(TypedDict):
+    id: str
+    bindings: Dict[str, str]
+    request: ForwardingRequestDetail
+    response: ForwardingResponseDetail
+    duration_ms: int
+    status: ForwardingRequestStatusesLiterals
+    status_history: List[ForwardingRequestStatusHistory]
+    created_at: str
+
+
+class ForwardingRequestCreateOpts(TypedDict):
+    url: str
+    method: ForwardingRequestMethodsLiterals
+    headers: Dict[str, str]
+    body: str
+    bindings: Dict[str, str]
+    metadata: Optional[Dict[str, Any]]
+
+
+class ForwardingRequestResource(Resource):
+    def __init__(self, config: Configuration):
+        super(ForwardingRequestResource, self).__init__(config.add_path('forwarding_requests'))
+
+    def retrieve(self, _id: str) -> MethodResponse[ForwardingRequest]:
+        return super(ForwardingRequestResource, self)._get_with_id(_id)
+
+    def create(self, opts: ForwardingRequestCreateOpts, request_opts: Optional[RequestOpts] = None) -> MethodResponse[ForwardingRequest]:
+        return super(ForwardingRequestResource, self)._create(opts, request_opts=request_opts)

method/resources/ForwardingRequests/__init__.py

@@ -0,0 +1 @@
+from method.resources.ForwardingRequests.ForwardingRequest import ForwardingRequest, ForwardingRequestResource

method/resources/ManagedAccounts/ManagedAccount.py

@@ -0,0 +1,55 @@
+from typing import TypedDict, Optional, List
+
+from method.resource import MethodResponse, Resource, ResourceListOpts
+from method.configuration import Configuration
+
+
+class ManagedAccountTransaction(TypedDict):
+    id: str
+    managed_account_id: str
+    amount: int
+    type: str
+    status: str
+    description: Optional[str]
+    created_at: str
+    updated_at: str
+
+
+class ManagedAccount(TypedDict):
+    id: str
+    type: str
+    status: str
+    routing_number: Optional[str]
+    account_number: Optional[str]
+    balance: Optional[int]
+    created_at: str
+    updated_at: str
+
+
+class ManagedAccountTransactionsResource(Resource):
+    def __init__(self, config: Configuration):
+        super(ManagedAccountTransactionsResource, self).__init__(config.add_path('transactions'))
+
+    def list(self, params: Optional[ResourceListOpts] = None) -> MethodResponse[List[ManagedAccountTransaction]]:
+        return super(ManagedAccountTransactionsResource, self)._list(params)
+
+
+class ManagedAccountSubResources:
+    transactions: ManagedAccountTransactionsResource
+
+    def __init__(self, _id: str, config: Configuration):
+        self.transactions = ManagedAccountTransactionsResource(config.add_path(_id))
+
+
+class ManagedAccountResource(Resource):
+    def __init__(self, config: Configuration):
+        super(ManagedAccountResource, self).__init__(config.add_path('managed_accounts'))
+
+    def __call__(self, _id: str) -> ManagedAccountSubResources:
+        return ManagedAccountSubResources(_id, self.config)
+
+    def list(self, params: Optional[ResourceListOpts] = None) -> MethodResponse[List[ManagedAccount]]:
+        return super(ManagedAccountResource, self)._list(params)
+
+    def retrieve(self, _id: str) -> MethodResponse[ManagedAccount]:
+        return super(ManagedAccountResource, self)._get_with_id(_id)

method/resources/ManagedAccounts/__init__.py

@@ -0,0 +1 @@
+from method.resources.ManagedAccounts.ManagedAccount import ManagedAccount, ManagedAccountResource

method/resources/Secrets/Secret.py

@@ -0,0 +1,40 @@
+from typing import TypedDict, Optional, List, Dict, Any, Literal
+
+from method.resource import MethodResponse, Resource, RequestOpts, ResourceListOpts
+from method.configuration import Configuration
+
+
+SecretStatusesLiterals = Literal[
+    'active',
+    'deleted'
+]
+
+
+class Secret(TypedDict):
+    id: str
+    metadata: Optional[Dict[str, Any]]
+    status: SecretStatusesLiterals
+    created_at: str
+    updated_at: str
+
+
+class SecretCreateOpts(TypedDict):
+    value: str
+    metadata: Optional[Dict[str, Any]]
+
+
+class SecretResource(Resource):
+    def __init__(self, config: Configuration):
+        super(SecretResource, self).__init__(config.add_path('secrets'))
+
+    def retrieve(self, _id: str) -> MethodResponse[Secret]:
+        return super(SecretResource, self)._get_with_id(_id)
+
+    def list(self, params: Optional[ResourceListOpts] = None) -> MethodResponse[List[Secret]]:
+        return super(SecretResource, self)._list(params)
+
+    def create(self, opts: SecretCreateOpts, request_opts: Optional[RequestOpts] = None) -> MethodResponse[Secret]:
+        return super(SecretResource, self)._create(opts, request_opts=request_opts)
+
+    def delete(self, _id: str) -> MethodResponse[Secret]:
+        return super(SecretResource, self)._delete(_id)

method/resources/Secrets/__init__.py

@@ -0,0 +1 @@
+from method.resources.Secrets.Secret import Secret, SecretResource

method/resources/Teams/Team.py

@@ -0,0 +1,94 @@
+from typing import TypedDict, Optional, List, Dict, Any, Literal
+
+from method.resource import MethodResponse, Resource, RequestOpts
+from method.configuration import Configuration
+
+
+TeamStatusesLiterals = Literal[
+    'active',
+    'verified',
+    'disabled',
+    'pending_disablement'
+]
+
+
+class TeamProduct(TypedDict):
+    type: str
+    enabled: bool
+
+
+class TeamKey(TypedDict):
+    id: str
+    type: Literal['secret', 'public']
+    deleted: bool
+    created_at: str
+    updated_at: str
+    last_used_at: Optional[str]
+
+
+class Team(TypedDict):
+    id: str
+    parent_id: Optional[str]
+    name: str
+    legal_name: str
+    logo: Optional[str]
+    api_version: str
+    status: TeamStatusesLiterals
+    products: List[TeamProduct]
+    keys: List[TeamKey]
+    created_at: str
+    updated_at: str
+
+
+class TeamCreateOpts(TypedDict):
+    name: str
+
+
+class TeamEncryptionKeyOpts(TypedDict):
+    key: str
+
+
+class MLEPublicKey(TypedDict):
+    id: str
+    jwk: Dict[str, Any]
+    created_at: str
+    updated_at: str
+
+
+class MLEPublicKeyCreateOpts(TypedDict):
+    jwk: Dict[str, Any]
+
+
+class TeamPublicKeysResource(Resource):
+    def __init__(self, config: Configuration):
+        super(TeamPublicKeysResource, self).__init__(config.add_path('mle/public_keys'))
+
+    def list(self) -> MethodResponse[List[MLEPublicKey]]:
+        return super(TeamPublicKeysResource, self)._list()
+
+    def retrieve(self, _id: str) -> MethodResponse[MLEPublicKey]:
+        return super(TeamPublicKeysResource, self)._get_with_id(_id)
+
+    def create(self, opts: MLEPublicKeyCreateOpts, request_opts: Optional[RequestOpts] = None) -> MethodResponse[MLEPublicKey]:
+        return super(TeamPublicKeysResource, self)._create(opts, request_opts=request_opts)
+
+    def delete(self, _id: str) -> MethodResponse[MLEPublicKey]:
+        return super(TeamPublicKeysResource, self)._delete(_id)
+
+
+class TeamResource(Resource):
+    public_keys: TeamPublicKeysResource
+
+    def __init__(self, config: Configuration):
+        _config = config.add_path('teams')
+        super(TeamResource, self).__init__(_config)
+        self.public_keys = TeamPublicKeysResource(_config)
+
+    def retrieve(self) -> MethodResponse[Team]:
+        return super(TeamResource, self)._get()
+
+    def create(self, opts: TeamCreateOpts, request_opts: Optional[RequestOpts] = None) -> MethodResponse[Team]:
+        return super(TeamResource, self)._create(opts, request_opts=request_opts)
+
+    def update_encryption_key(self, opts: TeamEncryptionKeyOpts) -> MethodResponse[Team]:
+        return super(TeamResource, self)._create_with_sub_path('default_encryption_key', opts)