strongdm 7.1.0__zip → 12.2.0__zip

{strongdm-7.1.0 → strongdm-12.2.0}/strongdm/svc.py

@@ -66,6 +66,16 @@ from .control_panel_pb2 import *
 from .control_panel_pb2_grpc import *
 from .drivers_pb2 import *
 from .drivers_pb2_grpc import *
+from .health_checks_pb2 import *
+from .health_checks_pb2_grpc import *
+from .identity_aliases_pb2 import *
+from .identity_aliases_pb2_grpc import *
+from .identity_aliases_history_pb2 import *
+from .identity_aliases_history_pb2_grpc import *
+from .identity_sets_pb2 import *
+from .identity_sets_pb2_grpc import *
+from .identity_sets_history_pb2 import *
+from .identity_sets_history_pb2_grpc import *
 from .nodes_pb2 import *
 from .nodes_pb2_grpc import *
 from .nodes_history_pb2 import *
@@ -80,6 +90,12 @@ from .peering_group_resources_pb2 import *
 from .peering_group_resources_pb2_grpc import *
 from .peering_groups_pb2 import *
 from .peering_groups_pb2_grpc import *
+from .policies_pb2 import *
+from .policies_pb2_grpc import *
+from .policies_history_pb2 import *
+from .policies_history_pb2_grpc import *
+from .proxy_cluster_keys_pb2 import *
+from .proxy_cluster_keys_pb2_grpc import *
 from .queries_pb2 import *
 from .queries_pb2_grpc import *
 from .remote_identities_pb2 import *
@@ -104,12 +120,12 @@ from .roles_pb2 import *
 from .roles_pb2_grpc import *
 from .roles_history_pb2 import *
 from .roles_history_pb2_grpc import *
-from .secret_store_healths_pb2 import *
-from .secret_store_healths_pb2_grpc import *
 from .secret_store_types_pb2 import *
 from .secret_store_types_pb2_grpc import *
 from .secret_stores_pb2 import *
 from .secret_stores_pb2_grpc import *
+from .secret_store_healths_pb2 import *
+from .secret_store_healths_pb2_grpc import *
 from .secret_stores_history_pb2 import *
 from .secret_stores_history_pb2_grpc import *
 from .workflow_approvers_pb2 import *
@@ -925,8 +941,10 @@ class Accounts:
      Accounts are users that have access to strongDM. There are two types of accounts:
      1. **Users:** humans who are authenticated through username and password or SSO.
      2. **Service Accounts:** machines that are authenticated using a service token.
+     3. **Tokens** are access keys with permissions that can be used for authentication.
     See:
     `strongdm.models.Service`
+    `strongdm.models.Token`
     `strongdm.models.User`
     '''
     def __init__(self, channel, client):
@@ -958,12 +976,14 @@ class Accounts:
             break
 
         resp = models.AccountCreateResponse()
+        resp.access_key = (plumbing_response.access_key)
         resp.account = plumbing.convert_account_to_porcelain(
             plumbing_response.account)
         resp.meta = plumbing.convert_create_response_metadata_to_porcelain(
             plumbing_response.meta)
         resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
             plumbing_response.rate_limit)
+        resp.secret_key = (plumbing_response.secret_key)
         resp.token = (plumbing_response.token)
         return resp
 
@@ -2051,34 +2071,82 @@ class ControlPanel:
         return resp
 
 
-class Nodes:
+class HealthChecks:
     '''
-     Nodes make up the strongDM network, and allow your users to connect securely to your resources. There are two types of nodes:
-     - **Gateways** are the entry points into network. They listen for connection from the strongDM client, and provide access to databases and servers.
-     - **Relays** are used to extend the strongDM network into segmented subnets. They provide access to databases and servers but do not listen for incoming connections.
-    See:
-    `strongdm.models.Gateway`
-    `strongdm.models.Relay`
+     HealthChecks lists the last healthcheck between each node and resource.
+     Note the unconventional capitalization here is to prevent having a collision with GRPC
+    See `strongdm.models.Healthcheck`.
     '''
     def __init__(self, channel, client):
         self.parent = client
-        self.stub = NodesStub(channel)
+        self.stub = HealthChecksStub(channel)
 
-    def create(self, node, timeout=None):
+    def list(self, filter, *args, timeout=None):
         '''
-         Create registers a new Node.
+         List gets a list of Healthchecks matching a given set of criteria.
         '''
-        req = NodeCreateRequest()
+        req = HealthcheckListRequest()
+        req.meta.CopyFrom(ListRequestMetadata())
+        if self.parent.page_limit > 0:
+            req.meta.limit = self.parent.page_limit
+        if self.parent.snapshot_datetime is not None:
+            req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime)
 
-        if node is not None:
-            req.node.CopyFrom(plumbing.convert_node_to_plumbing(node))
+        req.filter = plumbing.quote_filter_args(filter, *args)
+
+        def generator(svc, req):
+            tries = 0
+            while True:
+                try:
+                    plumbing_response = svc.stub.List(
+                        req,
+                        metadata=svc.parent.get_metadata(
+                            'HealthChecks.List', req),
+                        timeout=timeout)
+                except Exception as e:
+                    if self.parent.shouldRetry(tries, e):
+                        tries += 1
+                        self.parent.jitterSleep(tries)
+                        continue
+                    raise plumbing.convert_error_to_porcelain(e) from e
+                tries = 0
+                for plumbing_item in plumbing_response.healthchecks:
+                    yield plumbing.convert_healthcheck_to_porcelain(
+                        plumbing_item)
+                if plumbing_response.meta.next_cursor == '':
+                    break
+                req.meta.cursor = plumbing_response.meta.next_cursor
+
+        return generator(self, req)
+
+
+class IdentityAliases:
+    '''
+     IdentityAliases assign an alias to an account within an IdentitySet.
+     The alias is used as the username when connecting to a identity supported resource.
+    See `strongdm.models.IdentityAlias`.
+    '''
+    def __init__(self, channel, client):
+        self.parent = client
+        self.stub = IdentityAliasesStub(channel)
+
+    def create(self, identity_alias, timeout=None):
+        '''
+         Create registers a new IdentityAlias.
+        '''
+        req = IdentityAliasCreateRequest()
+
+        if identity_alias is not None:
+            req.identity_alias.CopyFrom(
+                plumbing.convert_identity_alias_to_plumbing(identity_alias))
         tries = 0
         plumbing_response = None
         while True:
             try:
                 plumbing_response = self.stub.Create(
                     req,
-                    metadata=self.parent.get_metadata('Nodes.Create', req),
+                    metadata=self.parent.get_metadata('IdentityAliases.Create',
+                                                      req),
                     timeout=timeout)
             except Exception as e:
                 if self.parent.shouldRetry(tries, e):
@@ -2088,20 +2156,20 @@ class Nodes:
                 raise plumbing.convert_error_to_porcelain(e) from e
             break
 
-        resp = models.NodeCreateResponse()
+        resp = models.IdentityAliasCreateResponse()
+        resp.identity_alias = plumbing.convert_identity_alias_to_porcelain(
+            plumbing_response.identity_alias)
         resp.meta = plumbing.convert_create_response_metadata_to_porcelain(
             plumbing_response.meta)
-        resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node)
         resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
             plumbing_response.rate_limit)
-        resp.token = (plumbing_response.token)
         return resp
 
     def get(self, id, timeout=None):
         '''
-         Get reads one Node by ID.
+         Get reads one IdentityAlias by ID.
         '''
-        req = NodeGetRequest()
+        req = IdentityAliasGetRequest()
         if self.parent.snapshot_datetime is not None:
             req.meta.CopyFrom(GetRequestMetadata())
             req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime)
@@ -2113,7 +2181,8 @@ class Nodes:
             try:
                 plumbing_response = self.stub.Get(
                     req,
-                    metadata=self.parent.get_metadata('Nodes.Get', req),
+                    metadata=self.parent.get_metadata('IdentityAliases.Get',
+                                                      req),
                     timeout=timeout)
             except Exception as e:
                 if self.parent.shouldRetry(tries, e):
@@ -2123,29 +2192,32 @@ class Nodes:
                 raise plumbing.convert_error_to_porcelain(e) from e
             break
 
-        resp = models.NodeGetResponse()
+        resp = models.IdentityAliasGetResponse()
+        resp.identity_alias = plumbing.convert_identity_alias_to_porcelain(
+            plumbing_response.identity_alias)
         resp.meta = plumbing.convert_get_response_metadata_to_porcelain(
             plumbing_response.meta)
-        resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node)
         resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
             plumbing_response.rate_limit)
         return resp
 
-    def update(self, node, timeout=None):
+    def update(self, identity_alias, timeout=None):
         '''
-         Update replaces all the fields of a Node by ID.
+         Update replaces all the fields of a IdentityAlias by ID.
         '''
-        req = NodeUpdateRequest()
+        req = IdentityAliasUpdateRequest()
 
-        if node is not None:
-            req.node.CopyFrom(plumbing.convert_node_to_plumbing(node))
+        if identity_alias is not None:
+            req.identity_alias.CopyFrom(
+                plumbing.convert_identity_alias_to_plumbing(identity_alias))
         tries = 0
         plumbing_response = None
         while True:
             try:
                 plumbing_response = self.stub.Update(
                     req,
-                    metadata=self.parent.get_metadata('Nodes.Update', req),
+                    metadata=self.parent.get_metadata('IdentityAliases.Update',
+                                                      req),
                     timeout=timeout)
             except Exception as e:
                 if self.parent.shouldRetry(tries, e):
@@ -2155,19 +2227,20 @@ class Nodes:
                 raise plumbing.convert_error_to_porcelain(e) from e
             break
 
-        resp = models.NodeUpdateResponse()
+        resp = models.IdentityAliasUpdateResponse()
+        resp.identity_alias = plumbing.convert_identity_alias_to_porcelain(
+            plumbing_response.identity_alias)
         resp.meta = plumbing.convert_update_response_metadata_to_porcelain(
             plumbing_response.meta)
-        resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node)
         resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
             plumbing_response.rate_limit)
         return resp
 
     def delete(self, id, timeout=None):
         '''
-         Delete removes a Node by ID.
+         Delete removes a IdentityAlias by ID.
         '''
-        req = NodeDeleteRequest()
+        req = IdentityAliasDeleteRequest()
 
         req.id = (id)
         tries = 0
@@ -2176,7 +2249,8 @@ class Nodes:
             try:
                 plumbing_response = self.stub.Delete(
                     req,
-                    metadata=self.parent.get_metadata('Nodes.Delete', req),
+                    metadata=self.parent.get_metadata('IdentityAliases.Delete',
+                                                      req),
                     timeout=timeout)
             except Exception as e:
                 if self.parent.shouldRetry(tries, e):
@@ -2186,7 +2260,7 @@ class Nodes:
                 raise plumbing.convert_error_to_porcelain(e) from e
             break
 
-        resp = models.NodeDeleteResponse()
+        resp = models.IdentityAliasDeleteResponse()
         resp.meta = plumbing.convert_delete_response_metadata_to_porcelain(
             plumbing_response.meta)
         resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
@@ -2195,9 +2269,9 @@ class Nodes:
 
     def list(self, filter, *args, timeout=None):
         '''
-         List gets a list of Nodes matching a given set of criteria.
+         List gets a list of IdentityAliases matching a given set of criteria.
         '''
-        req = NodeListRequest()
+        req = IdentityAliasListRequest()
         req.meta.CopyFrom(ListRequestMetadata())
         if self.parent.page_limit > 0:
             req.meta.limit = self.parent.page_limit
@@ -2212,7 +2286,8 @@ class Nodes:
                 try:
                     plumbing_response = svc.stub.List(
                         req,
-                        metadata=svc.parent.get_metadata('Nodes.List', req),
+                        metadata=svc.parent.get_metadata(
+                            'IdentityAliases.List', req),
                         timeout=timeout)
                 except Exception as e:
                     if self.parent.shouldRetry(tries, e):
@@ -2221,8 +2296,9 @@ class Nodes:
                         continue
                     raise plumbing.convert_error_to_porcelain(e) from e
                 tries = 0
-                for plumbing_item in plumbing_response.nodes:
-                    yield plumbing.convert_node_to_porcelain(plumbing_item)
+                for plumbing_item in plumbing_response.identity_aliases:
+                    yield plumbing.convert_identity_alias_to_porcelain(
+                        plumbing_item)
                 if plumbing_response.meta.next_cursor == '':
                     break
                 req.meta.cursor = plumbing_response.meta.next_cursor
@@ -2230,41 +2306,41 @@ class Nodes:
         return generator(self, req)
 
 
-class SnapshotNodes:
+class SnapshotIdentityAliases:
     '''
-    SnapshotNodes exposes the read only methods of the Nodes
+    SnapshotIdentityAliases exposes the read only methods of the IdentityAliases
     service for historical queries.
     '''
-    def __init__(self, nodes):
-        self.nodes = nodes
+    def __init__(self, identity_aliases):
+        self.identity_aliases = identity_aliases
 
     def get(self, id, timeout=None):
         '''
-         Get reads one Node by ID.
+         Get reads one IdentityAlias by ID.
         '''
-        return self.nodes.get(id, timeout=timeout)
+        return self.identity_aliases.get(id, timeout=timeout)
 
     def list(self, filter, *args, timeout=None):
         '''
-         List gets a list of Nodes matching a given set of criteria.
+         List gets a list of IdentityAliases matching a given set of criteria.
         '''
-        return self.nodes.list(filter, *args, timeout=timeout)
+        return self.identity_aliases.list(filter, *args, timeout=timeout)
 
 
-class NodesHistory:
+class IdentityAliasesHistory:
     '''
-     NodesHistory records all changes to the state of a Node.
-    See `strongdm.models.NodeHistory`.
+     IdentityAliasesHistory records all changes to the state of a IdentityAlias.
+    See `strongdm.models.IdentityAliasHistory`.
     '''
     def __init__(self, channel, client):
         self.parent = client
-        self.stub = NodesHistoryStub(channel)
+        self.stub = IdentityAliasesHistoryStub(channel)
 
     def list(self, filter, *args, timeout=None):
         '''
-         List gets a list of NodeHistory records matching a given set of criteria.
+         List gets a list of IdentityAliasHistory records matching a given set of criteria.
         '''
-        req = NodeHistoryListRequest()
+        req = IdentityAliasHistoryListRequest()
         req.meta.CopyFrom(ListRequestMetadata())
         if self.parent.page_limit > 0:
             req.meta.limit = self.parent.page_limit
@@ -2280,7 +2356,7 @@ class NodesHistory:
                     plumbing_response = svc.stub.List(
                         req,
                         metadata=svc.parent.get_metadata(
-                            'NodesHistory.List', req),
+                            'IdentityAliasesHistory.List', req),
                         timeout=timeout)
                 except Exception as e:
                     if self.parent.shouldRetry(tries, e):
@@ -2290,7 +2366,7 @@ class NodesHistory:
                     raise plumbing.convert_error_to_porcelain(e) from e
                 tries = 0
                 for plumbing_item in plumbing_response.history:
-                    yield plumbing.convert_node_history_to_porcelain(
+                    yield plumbing.convert_identity_alias_history_to_porcelain(
                         plumbing_item)
                 if plumbing_response.meta.next_cursor == '':
                     break
@@ -2299,81 +2375,68 @@ class NodesHistory:
         return generator(self, req)
 
 
-class OrganizationHistory:
+class IdentitySets:
     '''
-     OrganizationHistory records all changes to the state of an Organization.
-    See `strongdm.models.OrganizationHistoryRecord`.
+     A IdentitySet is a named grouping of Identity Aliases for Accounts.
+     An Account's relationship to a IdentitySet is defined via IdentityAlias objects.
+    See `strongdm.models.IdentitySet`.
     '''
     def __init__(self, channel, client):
         self.parent = client
-        self.stub = OrganizationHistoryStub(channel)
+        self.stub = IdentitySetsStub(channel)
 
-    def list(self, filter, *args, timeout=None):
+    def create(self, identity_set, timeout=None):
         '''
-         List gets a list of OrganizationHistory records matching a given set of criteria.
+         Create registers a new IdentitySet.
         '''
-        req = OrganizationHistoryListRequest()
-        req.meta.CopyFrom(ListRequestMetadata())
-        if self.parent.page_limit > 0:
-            req.meta.limit = self.parent.page_limit
-        if self.parent.snapshot_datetime is not None:
-            req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime)
-
-        req.filter = plumbing.quote_filter_args(filter, *args)
-
-        def generator(svc, req):
-            tries = 0
-            while True:
-                try:
-                    plumbing_response = svc.stub.List(
-                        req,
-                        metadata=svc.parent.get_metadata(
-                            'OrganizationHistory.List', req),
-                        timeout=timeout)
-                except Exception as e:
-                    if self.parent.shouldRetry(tries, e):
-                        tries += 1
-                        self.parent.jitterSleep(tries)
-                        continue
-                    raise plumbing.convert_error_to_porcelain(e) from e
-                tries = 0
-                for plumbing_item in plumbing_response.history:
-                    yield plumbing.convert_organization_history_record_to_porcelain(
-                        plumbing_item)
-                if plumbing_response.meta.next_cursor == '':
-                    break
-                req.meta.cursor = plumbing_response.meta.next_cursor
-
-        return generator(self, req)
+        req = IdentitySetCreateRequest()
 
+        if identity_set is not None:
+            req.identity_set.CopyFrom(
+                plumbing.convert_identity_set_to_plumbing(identity_set))
+        tries = 0
+        plumbing_response = None
+        while True:
+            try:
+                plumbing_response = self.stub.Create(
+                    req,
+                    metadata=self.parent.get_metadata('IdentitySets.Create',
+                                                      req),
+                    timeout=timeout)
+            except Exception as e:
+                if self.parent.shouldRetry(tries, e):
+                    tries += 1
+                    self.parent.jitterSleep(tries)
+                    continue
+                raise plumbing.convert_error_to_porcelain(e) from e
+            break
 
-class PeeringGroupNodes:
-    '''
-     PeeringGroupNodes provides the building blocks necessary to obtain attach a node to a peering group.
-    See `strongdm.models.PeeringGroupNode`.
-    '''
-    def __init__(self, channel, client):
-        self.parent = client
-        self.stub = PeeringGroupNodesStub(channel)
+        resp = models.IdentitySetCreateResponse()
+        resp.identity_set = plumbing.convert_identity_set_to_porcelain(
+            plumbing_response.identity_set)
+        resp.meta = plumbing.convert_create_response_metadata_to_porcelain(
+            plumbing_response.meta)
+        resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
+            plumbing_response.rate_limit)
+        return resp
 
-    def create(self, peering_group_node, timeout=None):
+    def get(self, id, timeout=None):
         '''
-         Create attaches a Node to a PeeringGroup
+         Get reads one IdentitySet by ID.
         '''
-        req = PeeringGroupNodeCreateRequest()
+        req = IdentitySetGetRequest()
+        if self.parent.snapshot_datetime is not None:
+            req.meta.CopyFrom(GetRequestMetadata())
+            req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime)
 
-        if peering_group_node is not None:
-            req.peering_group_node.CopyFrom(
-                plumbing.convert_peering_group_node_to_plumbing(
-                    peering_group_node))
+        req.id = (id)
         tries = 0
         plumbing_response = None
         while True:
             try:
-                plumbing_response = self.stub.Create(
+                plumbing_response = self.stub.Get(
                     req,
-                    metadata=self.parent.get_metadata(
-                        'PeeringGroupNodes.Create', req),
+                    metadata=self.parent.get_metadata('IdentitySets.Get', req),
                     timeout=timeout)
             except Exception as e:
                 if self.parent.shouldRetry(tries, e):
@@ -2383,30 +2446,32 @@ class PeeringGroupNodes:
                 raise plumbing.convert_error_to_porcelain(e) from e
             break
 
-        resp = models.PeeringGroupNodeCreateResponse()
-        resp.meta = plumbing.convert_create_response_metadata_to_porcelain(
+        resp = models.IdentitySetGetResponse()
+        resp.identity_set = plumbing.convert_identity_set_to_porcelain(
+            plumbing_response.identity_set)
+        resp.meta = plumbing.convert_get_response_metadata_to_porcelain(
             plumbing_response.meta)
-        resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain(
-            plumbing_response.peering_group_node)
         resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
             plumbing_response.rate_limit)
         return resp
 
-    def delete(self, id, timeout=None):
+    def update(self, identity_set, timeout=None):
         '''
-         Delete detaches a Node to a PeeringGroup.
+         Update replaces all the fields of a IdentitySet by ID.
         '''
-        req = PeeringGroupNodeDeleteRequest()
+        req = IdentitySetUpdateRequest()
 
-        req.id = (id)
+        if identity_set is not None:
+            req.identity_set.CopyFrom(
+                plumbing.convert_identity_set_to_plumbing(identity_set))
         tries = 0
         plumbing_response = None
         while True:
             try:
-                plumbing_response = self.stub.Delete(
+                plumbing_response = self.stub.Update(
                     req,
-                    metadata=self.parent.get_metadata(
-                        'PeeringGroupNodes.Delete', req),
+                    metadata=self.parent.get_metadata('IdentitySets.Update',
+                                                      req),
                     timeout=timeout)
             except Exception as e:
                 if self.parent.shouldRetry(tries, e):
@@ -2416,30 +2481,29 @@ class PeeringGroupNodes:
                 raise plumbing.convert_error_to_porcelain(e) from e
             break
 
-        resp = models.PeeringGroupNodeDeleteResponse()
-        resp.meta = plumbing.convert_delete_response_metadata_to_porcelain(
+        resp = models.IdentitySetUpdateResponse()
+        resp.identity_set = plumbing.convert_identity_set_to_porcelain(
+            plumbing_response.identity_set)
+        resp.meta = plumbing.convert_update_response_metadata_to_porcelain(
             plumbing_response.meta)
         resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
             plumbing_response.rate_limit)
         return resp
 
-    def get(self, id, timeout=None):
+    def delete(self, id, timeout=None):
         '''
-         Get reads the information of one peering group to node attachment.
+         Delete removes a IdentitySet by ID.
         '''
-        req = PeeringGroupNodeGetRequest()
-        if self.parent.snapshot_datetime is not None:
-            req.meta.CopyFrom(GetRequestMetadata())
-            req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime)
+        req = IdentitySetDeleteRequest()
 
         req.id = (id)
         tries = 0
         plumbing_response = None
         while True:
             try:
-                plumbing_response = self.stub.Get(
+                plumbing_response = self.stub.Delete(
                     req,
-                    metadata=self.parent.get_metadata('PeeringGroupNodes.Get',
+                    metadata=self.parent.get_metadata('IdentitySets.Delete',
                                                       req),
                     timeout=timeout)
             except Exception as e:
@@ -2450,20 +2514,18 @@ class PeeringGroupNodes:
                 raise plumbing.convert_error_to_porcelain(e) from e
             break
 
-        resp = models.PeeringGroupNodeGetResponse()
-        resp.meta = plumbing.convert_get_response_metadata_to_porcelain(
+        resp = models.IdentitySetDeleteResponse()
+        resp.meta = plumbing.convert_delete_response_metadata_to_porcelain(
             plumbing_response.meta)
-        resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain(
-            plumbing_response.peering_group_node)
         resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
             plumbing_response.rate_limit)
         return resp
 
     def list(self, filter, *args, timeout=None):
         '''
-         List gets a list of peering group node attachments.
+         List gets a list of IdentitySets matching a given set of criteria.
         '''
-        req = PeeringGroupNodeListRequest()
+        req = IdentitySetListRequest()
         req.meta.CopyFrom(ListRequestMetadata())
         if self.parent.page_limit > 0:
             req.meta.limit = self.parent.page_limit
@@ -2479,7 +2541,7 @@ class PeeringGroupNodes:
                     plumbing_response = svc.stub.List(
                         req,
                         metadata=svc.parent.get_metadata(
-                            'PeeringGroupNodes.List', req),
+                            'IdentitySets.List', req),
                         timeout=timeout)
                 except Exception as e:
                     if self.parent.shouldRetry(tries, e):
@@ -2488,8 +2550,8 @@ class PeeringGroupNodes:
                         continue
                     raise plumbing.convert_error_to_porcelain(e) from e
                 tries = 0
-                for plumbing_item in plumbing_response.peering_group_nodes:
-                    yield plumbing.convert_peering_group_node_to_porcelain(
+                for plumbing_item in plumbing_response.identity_sets:
+                    yield plumbing.convert_identity_set_to_porcelain(
                         plumbing_item)
                 if plumbing_response.meta.next_cursor == '':
                     break
@@ -2498,33 +2560,734 @@ class PeeringGroupNodes:
         return generator(self, req)
 
 
-class PeeringGroupPeers:
+class SnapshotIdentitySets:
     '''
-     PeeringGroupPeers provides the building blocks necessary to link two peering groups.
-    See `strongdm.models.PeeringGroupPeer`.
+    SnapshotIdentitySets exposes the read only methods of the IdentitySets
+    service for historical queries.
+    '''
+    def __init__(self, identity_sets):
+        self.identity_sets = identity_sets
+
+    def get(self, id, timeout=None):
+        '''
+         Get reads one IdentitySet by ID.
+        '''
+        return self.identity_sets.get(id, timeout=timeout)
+
+    def list(self, filter, *args, timeout=None):
+        '''
+         List gets a list of IdentitySets matching a given set of criteria.
+        '''
+        return self.identity_sets.list(filter, *args, timeout=timeout)
+
+
+class IdentitySetsHistory:
+    '''
+     IdentitySetsHistory records all changes to the state of a IdentitySet.
+    See `strongdm.models.IdentitySetHistory`.
     '''
     def __init__(self, channel, client):
         self.parent = client
-        self.stub = PeeringGroupPeersStub(channel)
+        self.stub = IdentitySetsHistoryStub(channel)
 
-    def create(self, peering_group_peer, timeout=None):
+    def list(self, filter, *args, timeout=None):
         '''
-         Create links two peering groups.
+         List gets a list of IdentitySetHistory records matching a given set of criteria.
         '''
-        req = PeeringGroupPeerCreateRequest()
+        req = IdentitySetHistoryListRequest()
+        req.meta.CopyFrom(ListRequestMetadata())
+        if self.parent.page_limit > 0:
+            req.meta.limit = self.parent.page_limit
+        if self.parent.snapshot_datetime is not None:
+            req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime)
 
-        if peering_group_peer is not None:
-            req.peering_group_peer.CopyFrom(
-                plumbing.convert_peering_group_peer_to_plumbing(
-                    peering_group_peer))
-        tries = 0
-        plumbing_response = None
+        req.filter = plumbing.quote_filter_args(filter, *args)
+
+        def generator(svc, req):
+            tries = 0
+            while True:
+                try:
+                    plumbing_response = svc.stub.List(
+                        req,
+                        metadata=svc.parent.get_metadata(
+                            'IdentitySetsHistory.List', req),
+                        timeout=timeout)
+                except Exception as e:
+                    if self.parent.shouldRetry(tries, e):
+                        tries += 1
+                        self.parent.jitterSleep(tries)
+                        continue
+                    raise plumbing.convert_error_to_porcelain(e) from e
+                tries = 0
+                for plumbing_item in plumbing_response.history:
+                    yield plumbing.convert_identity_set_history_to_porcelain(
+                        plumbing_item)
+                if plumbing_response.meta.next_cursor == '':
+                    break
+                req.meta.cursor = plumbing_response.meta.next_cursor
+
+        return generator(self, req)
+
+
+class Nodes:
+    '''
+     Nodes make up the strongDM network, and allow your users to connect securely to your resources. There are two types of nodes:
+     - **Gateways** are the entry points into network. They listen for connection from the strongDM client, and provide access to databases and servers.
+     - **Relays** are used to extend the strongDM network into segmented subnets. They provide access to databases and servers but do not listen for incoming connections.
+    See:
+    `strongdm.models.Gateway`
+    `strongdm.models.ProxyCluster`
+    `strongdm.models.Relay`
+    '''
+    def __init__(self, channel, client):
+        self.parent = client
+        self.stub = NodesStub(channel)
+
+    def create(self, node, timeout=None):
+        '''
+         Create registers a new Node.
+        '''
+        req = NodeCreateRequest()
+
+        if node is not None:
+            req.node.CopyFrom(plumbing.convert_node_to_plumbing(node))
+        tries = 0
+        plumbing_response = None
+        while True:
+            try:
+                plumbing_response = self.stub.Create(
+                    req,
+                    metadata=self.parent.get_metadata('Nodes.Create', req),
+                    timeout=timeout)
+            except Exception as e:
+                if self.parent.shouldRetry(tries, e):
+                    tries += 1
+                    self.parent.jitterSleep(tries)
+                    continue
+                raise plumbing.convert_error_to_porcelain(e) from e
+            break
+
+        resp = models.NodeCreateResponse()
+        resp.meta = plumbing.convert_create_response_metadata_to_porcelain(
+            plumbing_response.meta)
+        resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node)
+        resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
+            plumbing_response.rate_limit)
+        resp.token = (plumbing_response.token)
+        return resp
+
+    def get(self, id, timeout=None):
+        '''
+         Get reads one Node by ID.
+        '''
+        req = NodeGetRequest()
+        if self.parent.snapshot_datetime is not None:
+            req.meta.CopyFrom(GetRequestMetadata())
+            req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime)
+
+        req.id = (id)
+        tries = 0
+        plumbing_response = None
+        while True:
+            try:
+                plumbing_response = self.stub.Get(
+                    req,
+                    metadata=self.parent.get_metadata('Nodes.Get', req),
+                    timeout=timeout)
+            except Exception as e:
+                if self.parent.shouldRetry(tries, e):
+                    tries += 1
+                    self.parent.jitterSleep(tries)
+                    continue
+                raise plumbing.convert_error_to_porcelain(e) from e
+            break
+
+        resp = models.NodeGetResponse()
+        resp.meta = plumbing.convert_get_response_metadata_to_porcelain(
+            plumbing_response.meta)
+        resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node)
+        resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
+            plumbing_response.rate_limit)
+        return resp
+
+    def update(self, node, timeout=None):
+        '''
+         Update replaces all the fields of a Node by ID.
+        '''
+        req = NodeUpdateRequest()
+
+        if node is not None:
+            req.node.CopyFrom(plumbing.convert_node_to_plumbing(node))
+        tries = 0
+        plumbing_response = None
+        while True:
+            try:
+                plumbing_response = self.stub.Update(
+                    req,
+                    metadata=self.parent.get_metadata('Nodes.Update', req),
+                    timeout=timeout)
+            except Exception as e:
+                if self.parent.shouldRetry(tries, e):
+                    tries += 1
+                    self.parent.jitterSleep(tries)
+                    continue
+                raise plumbing.convert_error_to_porcelain(e) from e
+            break
+
+        resp = models.NodeUpdateResponse()
+        resp.meta = plumbing.convert_update_response_metadata_to_porcelain(
+            plumbing_response.meta)
+        resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node)
+        resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
+            plumbing_response.rate_limit)
+        return resp
+
+    def delete(self, id, timeout=None):
+        '''
+         Delete removes a Node by ID.
+        '''
+        req = NodeDeleteRequest()
+
+        req.id = (id)
+        tries = 0
+        plumbing_response = None
+        while True:
+            try:
+                plumbing_response = self.stub.Delete(
+                    req,
+                    metadata=self.parent.get_metadata('Nodes.Delete', req),
+                    timeout=timeout)
+            except Exception as e:
+                if self.parent.shouldRetry(tries, e):
+                    tries += 1
+                    self.parent.jitterSleep(tries)
+                    continue
+                raise plumbing.convert_error_to_porcelain(e) from e
+            break
+
+        resp = models.NodeDeleteResponse()
+        resp.meta = plumbing.convert_delete_response_metadata_to_porcelain(
+            plumbing_response.meta)
+        resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
+            plumbing_response.rate_limit)
+        return resp
+
+    def list(self, filter, *args, timeout=None):
+        '''
+         List gets a list of Nodes matching a given set of criteria.
+        '''
+        req = NodeListRequest()
+        req.meta.CopyFrom(ListRequestMetadata())
+        if self.parent.page_limit > 0:
+            req.meta.limit = self.parent.page_limit
+        if self.parent.snapshot_datetime is not None:
+            req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime)
+
+        req.filter = plumbing.quote_filter_args(filter, *args)
+
+        def generator(svc, req):
+            tries = 0
+            while True:
+                try:
+                    plumbing_response = svc.stub.List(
+                        req,
+                        metadata=svc.parent.get_metadata('Nodes.List', req),
+                        timeout=timeout)
+                except Exception as e:
+                    if self.parent.shouldRetry(tries, e):
+                        tries += 1
+                        self.parent.jitterSleep(tries)
+                        continue
+                    raise plumbing.convert_error_to_porcelain(e) from e
+                tries = 0
+                for plumbing_item in plumbing_response.nodes:
+                    yield plumbing.convert_node_to_porcelain(plumbing_item)
+                if plumbing_response.meta.next_cursor == '':
+                    break
+                req.meta.cursor = plumbing_response.meta.next_cursor
+
+        return generator(self, req)
+
+
+class SnapshotNodes:
+    '''
+    SnapshotNodes exposes the read only methods of the Nodes
+    service for historical queries.
+    '''
+    def __init__(self, nodes):
+        self.nodes = nodes
+
+    def get(self, id, timeout=None):
+        '''
+         Get reads one Node by ID.
+        '''
+        return self.nodes.get(id, timeout=timeout)
+
+    def list(self, filter, *args, timeout=None):
+        '''
+         List gets a list of Nodes matching a given set of criteria.
+        '''
+        return self.nodes.list(filter, *args, timeout=timeout)
+
+
+class NodesHistory:
+    '''
+     NodesHistory records all changes to the state of a Node.
+    See `strongdm.models.NodeHistory`.
+    '''
+    def __init__(self, channel, client):
+        self.parent = client
+        self.stub = NodesHistoryStub(channel)
+
+    def list(self, filter, *args, timeout=None):
+        '''
+         List gets a list of NodeHistory records matching a given set of criteria.
+        '''
+        req = NodeHistoryListRequest()
+        req.meta.CopyFrom(ListRequestMetadata())
+        if self.parent.page_limit > 0:
+            req.meta.limit = self.parent.page_limit
+        if self.parent.snapshot_datetime is not None:
+            req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime)
+
+        req.filter = plumbing.quote_filter_args(filter, *args)
+
+        def generator(svc, req):
+            tries = 0
+            while True:
+                try:
+                    plumbing_response = svc.stub.List(
+                        req,
+                        metadata=svc.parent.get_metadata(
+                            'NodesHistory.List', req),
+                        timeout=timeout)
+                except Exception as e:
+                    if self.parent.shouldRetry(tries, e):
+                        tries += 1
+                        self.parent.jitterSleep(tries)
+                        continue
+                    raise plumbing.convert_error_to_porcelain(e) from e
+                tries = 0
+                for plumbing_item in plumbing_response.history:
+                    yield plumbing.convert_node_history_to_porcelain(
+                        plumbing_item)
+                if plumbing_response.meta.next_cursor == '':
+                    break
+                req.meta.cursor = plumbing_response.meta.next_cursor
+
+        return generator(self, req)
+
+
+class OrganizationHistory:
+    '''
+     OrganizationHistory records all changes to the state of an Organization.
+    See `strongdm.models.OrganizationHistoryRecord`.
+    '''
+    def __init__(self, channel, client):
+        self.parent = client
+        self.stub = OrganizationHistoryStub(channel)
+
+    def list(self, filter, *args, timeout=None):
+        '''
+         List gets a list of OrganizationHistory records matching a given set of criteria.
+        '''
+        req = OrganizationHistoryListRequest()
+        req.meta.CopyFrom(ListRequestMetadata())
+        if self.parent.page_limit > 0:
+            req.meta.limit = self.parent.page_limit
+        if self.parent.snapshot_datetime is not None:
+            req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime)
+
+        req.filter = plumbing.quote_filter_args(filter, *args)
+
+        def generator(svc, req):
+            tries = 0
+            while True:
+                try:
+                    plumbing_response = svc.stub.List(
+                        req,
+                        metadata=svc.parent.get_metadata(
+                            'OrganizationHistory.List', req),
+                        timeout=timeout)
+                except Exception as e:
+                    if self.parent.shouldRetry(tries, e):
+                        tries += 1
+                        self.parent.jitterSleep(tries)
+                        continue
+                    raise plumbing.convert_error_to_porcelain(e) from e
+                tries = 0
+                for plumbing_item in plumbing_response.history:
+                    yield plumbing.convert_organization_history_record_to_porcelain(
+                        plumbing_item)
+                if plumbing_response.meta.next_cursor == '':
+                    break
+                req.meta.cursor = plumbing_response.meta.next_cursor
+
+        return generator(self, req)
+
+
+class PeeringGroupNodes:
+    '''
+     PeeringGroupNodes provides the building blocks necessary to obtain attach a node to a peering group.
+    See `strongdm.models.PeeringGroupNode`.
+    '''
+    def __init__(self, channel, client):
+        self.parent = client
+        self.stub = PeeringGroupNodesStub(channel)
+
+    def create(self, peering_group_node, timeout=None):
+        '''
+         Create attaches a Node to a PeeringGroup
+        '''
+        req = PeeringGroupNodeCreateRequest()
+
+        if peering_group_node is not None:
+            req.peering_group_node.CopyFrom(
+                plumbing.convert_peering_group_node_to_plumbing(
+                    peering_group_node))
+        tries = 0
+        plumbing_response = None
+        while True:
+            try:
+                plumbing_response = self.stub.Create(
+                    req,
+                    metadata=self.parent.get_metadata(
+                        'PeeringGroupNodes.Create', req),
+                    timeout=timeout)
+            except Exception as e:
+                if self.parent.shouldRetry(tries, e):
+                    tries += 1
+                    self.parent.jitterSleep(tries)
+                    continue
+                raise plumbing.convert_error_to_porcelain(e) from e
+            break
+
+        resp = models.PeeringGroupNodeCreateResponse()
+        resp.meta = plumbing.convert_create_response_metadata_to_porcelain(
+            plumbing_response.meta)
+        resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain(
+            plumbing_response.peering_group_node)
+        resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
+            plumbing_response.rate_limit)
+        return resp
+
+    def delete(self, id, timeout=None):
+        '''
+         Delete detaches a Node to a PeeringGroup.
+        '''
+        req = PeeringGroupNodeDeleteRequest()
+
+        req.id = (id)
+        tries = 0
+        plumbing_response = None
+        while True:
+            try:
+                plumbing_response = self.stub.Delete(
+                    req,
+                    metadata=self.parent.get_metadata(
+                        'PeeringGroupNodes.Delete', req),
+                    timeout=timeout)
+            except Exception as e:
+                if self.parent.shouldRetry(tries, e):
+                    tries += 1
+                    self.parent.jitterSleep(tries)
+                    continue
+                raise plumbing.convert_error_to_porcelain(e) from e
+            break
+
+        resp = models.PeeringGroupNodeDeleteResponse()
+        resp.meta = plumbing.convert_delete_response_metadata_to_porcelain(
+            plumbing_response.meta)
+        resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
+            plumbing_response.rate_limit)
+        return resp
+
+    def get(self, id, timeout=None):
+        '''
+         Get reads the information of one peering group to node attachment.
+        '''
+        req = PeeringGroupNodeGetRequest()
+        if self.parent.snapshot_datetime is not None:
+            req.meta.CopyFrom(GetRequestMetadata())
+            req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime)
+
+        req.id = (id)
+        tries = 0
+        plumbing_response = None
+        while True:
+            try:
+                plumbing_response = self.stub.Get(
+                    req,
+                    metadata=self.parent.get_metadata('PeeringGroupNodes.Get',
+                                                      req),
+                    timeout=timeout)
+            except Exception as e:
+                if self.parent.shouldRetry(tries, e):
+                    tries += 1
+                    self.parent.jitterSleep(tries)
+                    continue
+                raise plumbing.convert_error_to_porcelain(e) from e
+            break
+
+        resp = models.PeeringGroupNodeGetResponse()
+        resp.meta = plumbing.convert_get_response_metadata_to_porcelain(
+            plumbing_response.meta)
+        resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain(
+            plumbing_response.peering_group_node)
+        resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
+            plumbing_response.rate_limit)
+        return resp
+
+    def list(self, filter, *args, timeout=None):
+        '''
+         List gets a list of peering group node attachments.
+        '''
+        req = PeeringGroupNodeListRequest()
+        req.meta.CopyFrom(ListRequestMetadata())
+        if self.parent.page_limit > 0:
+            req.meta.limit = self.parent.page_limit
+        if self.parent.snapshot_datetime is not None:
+            req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime)
+
+        req.filter = plumbing.quote_filter_args(filter, *args)
+
+        def generator(svc, req):
+            tries = 0
+            while True:
+                try:
+                    plumbing_response = svc.stub.List(
+                        req,
+                        metadata=svc.parent.get_metadata(
+                            'PeeringGroupNodes.List', req),
+                        timeout=timeout)
+                except Exception as e:
+                    if self.parent.shouldRetry(tries, e):
+                        tries += 1
+                        self.parent.jitterSleep(tries)
+                        continue
+                    raise plumbing.convert_error_to_porcelain(e) from e
+                tries = 0
+                for plumbing_item in plumbing_response.peering_group_nodes:
+                    yield plumbing.convert_peering_group_node_to_porcelain(
+                        plumbing_item)
+                if plumbing_response.meta.next_cursor == '':
+                    break
+                req.meta.cursor = plumbing_response.meta.next_cursor
+
+        return generator(self, req)
+
+
+class PeeringGroupPeers:
+    '''
+     PeeringGroupPeers provides the building blocks necessary to link two peering groups.
+    See `strongdm.models.PeeringGroupPeer`.
+    '''
+    def __init__(self, channel, client):
+        self.parent = client
+        self.stub = PeeringGroupPeersStub(channel)
+
+    def create(self, peering_group_peer, timeout=None):
+        '''
+         Create links two peering groups.
+        '''
+        req = PeeringGroupPeerCreateRequest()
+
+        if peering_group_peer is not None:
+            req.peering_group_peer.CopyFrom(
+                plumbing.convert_peering_group_peer_to_plumbing(
+                    peering_group_peer))
+        tries = 0
+        plumbing_response = None
+        while True:
+            try:
+                plumbing_response = self.stub.Create(
+                    req,
+                    metadata=self.parent.get_metadata(
+                        'PeeringGroupPeers.Create', req),
+                    timeout=timeout)
+            except Exception as e:
+                if self.parent.shouldRetry(tries, e):
+                    tries += 1
+                    self.parent.jitterSleep(tries)
+                    continue
+                raise plumbing.convert_error_to_porcelain(e) from e
+            break
+
+        resp = models.PeeringGroupPeerCreateResponse()
+        resp.meta = plumbing.convert_create_response_metadata_to_porcelain(
+            plumbing_response.meta)
+        resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain(
+            plumbing_response.peering_group_peer)
+        resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
+            plumbing_response.rate_limit)
+        return resp
+
+    def delete(self, id, timeout=None):
+        '''
+         Delete unlinks two peering groups.
+        '''
+        req = PeeringGroupPeerDeleteRequest()
+
+        req.id = (id)
+        tries = 0
+        plumbing_response = None
+        while True:
+            try:
+                plumbing_response = self.stub.Delete(
+                    req,
+                    metadata=self.parent.get_metadata(
+                        'PeeringGroupPeers.Delete', req),
+                    timeout=timeout)
+            except Exception as e:
+                if self.parent.shouldRetry(tries, e):
+                    tries += 1
+                    self.parent.jitterSleep(tries)
+                    continue
+                raise plumbing.convert_error_to_porcelain(e) from e
+            break
+
+        resp = models.PeeringGroupPeerDeleteResponse()
+        resp.meta = plumbing.convert_delete_response_metadata_to_porcelain(
+            plumbing_response.meta)
+        resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
+            plumbing_response.rate_limit)
+        return resp
+
+    def get(self, id, timeout=None):
+        '''
+         Get reads the information of one peering group link.
+        '''
+        req = PeeringGroupPeerGetRequest()
+        if self.parent.snapshot_datetime is not None:
+            req.meta.CopyFrom(GetRequestMetadata())
+            req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime)
+
+        req.id = (id)
+        tries = 0
+        plumbing_response = None
+        while True:
+            try:
+                plumbing_response = self.stub.Get(
+                    req,
+                    metadata=self.parent.get_metadata('PeeringGroupPeers.Get',
+                                                      req),
+                    timeout=timeout)
+            except Exception as e:
+                if self.parent.shouldRetry(tries, e):
+                    tries += 1
+                    self.parent.jitterSleep(tries)
+                    continue
+                raise plumbing.convert_error_to_porcelain(e) from e
+            break
+
+        resp = models.PeeringGroupPeerGetResponse()
+        resp.meta = plumbing.convert_get_response_metadata_to_porcelain(
+            plumbing_response.meta)
+        resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain(
+            plumbing_response.peering_group_peer)
+        resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
+            plumbing_response.rate_limit)
+        return resp
+
+    def list(self, filter, *args, timeout=None):
+        '''
+         List gets a list of peering group links.
+        '''
+        req = PeeringGroupPeerListRequest()
+        req.meta.CopyFrom(ListRequestMetadata())
+        if self.parent.page_limit > 0:
+            req.meta.limit = self.parent.page_limit
+        if self.parent.snapshot_datetime is not None:
+            req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime)
+
+        req.filter = plumbing.quote_filter_args(filter, *args)
+
+        def generator(svc, req):
+            tries = 0
+            while True:
+                try:
+                    plumbing_response = svc.stub.List(
+                        req,
+                        metadata=svc.parent.get_metadata(
+                            'PeeringGroupPeers.List', req),
+                        timeout=timeout)
+                except Exception as e:
+                    if self.parent.shouldRetry(tries, e):
+                        tries += 1
+                        self.parent.jitterSleep(tries)
+                        continue
+                    raise plumbing.convert_error_to_porcelain(e) from e
+                tries = 0
+                for plumbing_item in plumbing_response.peering_group_peers:
+                    yield plumbing.convert_peering_group_peer_to_porcelain(
+                        plumbing_item)
+                if plumbing_response.meta.next_cursor == '':
+                    break
+                req.meta.cursor = plumbing_response.meta.next_cursor
+
+        return generator(self, req)
+
+
+class PeeringGroupResources:
+    '''
+     PeeringGroupResources provides the building blocks necessary to obtain attach a resource to a peering group.
+    See `strongdm.models.PeeringGroupResource`.
+    '''
+    def __init__(self, channel, client):
+        self.parent = client
+        self.stub = PeeringGroupResourcesStub(channel)
+
+    def create(self, peering_group_resource, timeout=None):
+        '''
+         Create attaches a Resource to a PeeringGroup
+        '''
+        req = PeeringGroupResourceCreateRequest()
+
+        if peering_group_resource is not None:
+            req.peering_group_resource.CopyFrom(
+                plumbing.convert_peering_group_resource_to_plumbing(
+                    peering_group_resource))
+        tries = 0
+        plumbing_response = None
+        while True:
+            try:
+                plumbing_response = self.stub.Create(
+                    req,
+                    metadata=self.parent.get_metadata(
+                        'PeeringGroupResources.Create', req),
+                    timeout=timeout)
+            except Exception as e:
+                if self.parent.shouldRetry(tries, e):
+                    tries += 1
+                    self.parent.jitterSleep(tries)
+                    continue
+                raise plumbing.convert_error_to_porcelain(e) from e
+            break
+
+        resp = models.PeeringGroupResourceCreateResponse()
+        resp.meta = plumbing.convert_create_response_metadata_to_porcelain(
+            plumbing_response.meta)
+        resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain(
+            plumbing_response.peering_group_resource)
+        resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
+            plumbing_response.rate_limit)
+        return resp
+
+    def delete(self, id, timeout=None):
+        '''
+         Delete detaches a Resource to a PeeringGroup
+        '''
+        req = PeeringGroupResourceDeleteRequest()
+
+        req.id = (id)
+        tries = 0
+        plumbing_response = None
         while True:
             try:
-                plumbing_response = self.stub.Create(
+                plumbing_response = self.stub.Delete(
                     req,
                     metadata=self.parent.get_metadata(
-                        'PeeringGroupPeers.Create', req),
+                        'PeeringGroupResources.Delete', req),
                     timeout=timeout)
             except Exception as e:
                 if self.parent.shouldRetry(tries, e):
@@ -2534,20 +3297,137 @@ class PeeringGroupPeers:
                 raise plumbing.convert_error_to_porcelain(e) from e
             break
 
-        resp = models.PeeringGroupPeerCreateResponse()
+        resp = models.PeeringGroupResourceDeleteResponse()
+        resp.meta = plumbing.convert_delete_response_metadata_to_porcelain(
+            plumbing_response.meta)
+        resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
+            plumbing_response.rate_limit)
+        return resp
+
+    def get(self, id, timeout=None):
+        '''
+         Get reads the information of one peering group to resource attachment.
+        '''
+        req = PeeringGroupResourceGetRequest()
+        if self.parent.snapshot_datetime is not None:
+            req.meta.CopyFrom(GetRequestMetadata())
+            req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime)
+
+        req.id = (id)
+        tries = 0
+        plumbing_response = None
+        while True:
+            try:
+                plumbing_response = self.stub.Get(
+                    req,
+                    metadata=self.parent.get_metadata(
+                        'PeeringGroupResources.Get', req),
+                    timeout=timeout)
+            except Exception as e:
+                if self.parent.shouldRetry(tries, e):
+                    tries += 1
+                    self.parent.jitterSleep(tries)
+                    continue
+                raise plumbing.convert_error_to_porcelain(e) from e
+            break
+
+        resp = models.PeeringGroupResourceGetResponse()
+        resp.meta = plumbing.convert_get_response_metadata_to_porcelain(
+            plumbing_response.meta)
+        resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain(
+            plumbing_response.peering_group_resource)
+        resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
+            plumbing_response.rate_limit)
+        return resp
+
+    def list(self, filter, *args, timeout=None):
+        '''
+         List gets a list of peering group resource attachments.
+        '''
+        req = PeeringGroupResourceListRequest()
+        req.meta.CopyFrom(ListRequestMetadata())
+        if self.parent.page_limit > 0:
+            req.meta.limit = self.parent.page_limit
+        if self.parent.snapshot_datetime is not None:
+            req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime)
+
+        req.filter = plumbing.quote_filter_args(filter, *args)
+
+        def generator(svc, req):
+            tries = 0
+            while True:
+                try:
+                    plumbing_response = svc.stub.List(
+                        req,
+                        metadata=svc.parent.get_metadata(
+                            'PeeringGroupResources.List', req),
+                        timeout=timeout)
+                except Exception as e:
+                    if self.parent.shouldRetry(tries, e):
+                        tries += 1
+                        self.parent.jitterSleep(tries)
+                        continue
+                    raise plumbing.convert_error_to_porcelain(e) from e
+                tries = 0
+                for plumbing_item in plumbing_response.peering_group_resources:
+                    yield plumbing.convert_peering_group_resource_to_porcelain(
+                        plumbing_item)
+                if plumbing_response.meta.next_cursor == '':
+                    break
+                req.meta.cursor = plumbing_response.meta.next_cursor
+
+        return generator(self, req)
+
+
+class PeeringGroups:
+    '''
+     PeeringGroups provides the building blocks necessary to obtain explicit network topology and routing.
+    See `strongdm.models.PeeringGroup`.
+    '''
+    def __init__(self, channel, client):
+        self.parent = client
+        self.stub = PeeringGroupsStub(channel)
+
+    def create(self, peering_group, timeout=None):
+        '''
+         Create registers a new PeeringGroup.
+        '''
+        req = PeeringGroupCreateRequest()
+
+        if peering_group is not None:
+            req.peering_group.CopyFrom(
+                plumbing.convert_peering_group_to_plumbing(peering_group))
+        tries = 0
+        plumbing_response = None
+        while True:
+            try:
+                plumbing_response = self.stub.Create(
+                    req,
+                    metadata=self.parent.get_metadata('PeeringGroups.Create',
+                                                      req),
+                    timeout=timeout)
+            except Exception as e:
+                if self.parent.shouldRetry(tries, e):
+                    tries += 1
+                    self.parent.jitterSleep(tries)
+                    continue
+                raise plumbing.convert_error_to_porcelain(e) from e
+            break
+
+        resp = models.PeeringGroupCreateResponse()
         resp.meta = plumbing.convert_create_response_metadata_to_porcelain(
             plumbing_response.meta)
-        resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain(
-            plumbing_response.peering_group_peer)
+        resp.peering_group = plumbing.convert_peering_group_to_porcelain(
+            plumbing_response.peering_group)
         resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
             plumbing_response.rate_limit)
         return resp
 
     def delete(self, id, timeout=None):
         '''
-         Delete unlinks two peering groups.
+         Delete removes a PeeringGroup by ID.
         '''
-        req = PeeringGroupPeerDeleteRequest()
+        req = PeeringGroupDeleteRequest()
 
         req.id = (id)
         tries = 0
@@ -2556,8 +3436,8 @@ class PeeringGroupPeers:
             try:
                 plumbing_response = self.stub.Delete(
                     req,
-                    metadata=self.parent.get_metadata(
-                        'PeeringGroupPeers.Delete', req),
+                    metadata=self.parent.get_metadata('PeeringGroups.Delete',
+                                                      req),
                     timeout=timeout)
             except Exception as e:
                 if self.parent.shouldRetry(tries, e):
@@ -2567,7 +3447,7 @@ class PeeringGroupPeers:
                 raise plumbing.convert_error_to_porcelain(e) from e
             break
 
-        resp = models.PeeringGroupPeerDeleteResponse()
+        resp = models.PeeringGroupDeleteResponse()
         resp.meta = plumbing.convert_delete_response_metadata_to_porcelain(
             plumbing_response.meta)
         resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
@@ -2576,9 +3456,9 @@ class PeeringGroupPeers:
 
     def get(self, id, timeout=None):
         '''
-         Get reads the information of one peering group link.
+         Get reads one PeeringGroup by ID. It will load all its dependencies.
         '''
-        req = PeeringGroupPeerGetRequest()
+        req = PeeringGroupGetRequest()
         if self.parent.snapshot_datetime is not None:
             req.meta.CopyFrom(GetRequestMetadata())
             req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime)
@@ -2590,7 +3470,7 @@ class PeeringGroupPeers:
             try:
                 plumbing_response = self.stub.Get(
                     req,
-                    metadata=self.parent.get_metadata('PeeringGroupPeers.Get',
+                    metadata=self.parent.get_metadata('PeeringGroups.Get',
                                                       req),
                     timeout=timeout)
             except Exception as e:
@@ -2601,20 +3481,20 @@ class PeeringGroupPeers:
                 raise plumbing.convert_error_to_porcelain(e) from e
             break
 
-        resp = models.PeeringGroupPeerGetResponse()
+        resp = models.PeeringGroupGetResponse()
         resp.meta = plumbing.convert_get_response_metadata_to_porcelain(
             plumbing_response.meta)
-        resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain(
-            plumbing_response.peering_group_peer)
+        resp.peering_group = plumbing.convert_peering_group_to_porcelain(
+            plumbing_response.peering_group)
         resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
             plumbing_response.rate_limit)
         return resp
 
     def list(self, filter, *args, timeout=None):
         '''
-         List gets a list of peering group links.
+         List gets a list of Peering Groups.
         '''
-        req = PeeringGroupPeerListRequest()
+        req = PeeringGroupListRequest()
         req.meta.CopyFrom(ListRequestMetadata())
         if self.parent.page_limit > 0:
             req.meta.limit = self.parent.page_limit
@@ -2630,7 +3510,7 @@ class PeeringGroupPeers:
                     plumbing_response = svc.stub.List(
                         req,
                         metadata=svc.parent.get_metadata(
-                            'PeeringGroupPeers.List', req),
+                            'PeeringGroups.List', req),
                         timeout=timeout)
                 except Exception as e:
                     if self.parent.shouldRetry(tries, e):
@@ -2639,8 +3519,8 @@ class PeeringGroupPeers:
                         continue
                     raise plumbing.convert_error_to_porcelain(e) from e
                 tries = 0
-                for plumbing_item in plumbing_response.peering_group_peers:
-                    yield plumbing.convert_peering_group_peer_to_porcelain(
+                for plumbing_item in plumbing_response.peering_groups:
+                    yield plumbing.convert_peering_group_to_porcelain(
                         plumbing_item)
                 if plumbing_response.meta.next_cursor == '':
                     break
@@ -2649,33 +3529,31 @@ class PeeringGroupPeers:
         return generator(self, req)
 
 
-class PeeringGroupResources:
+class Policies:
     '''
-     PeeringGroupResources provides the building blocks necessary to obtain attach a resource to a peering group.
-    See `strongdm.models.PeeringGroupResource`.
+     Policies are the collection of one or more statements that enforce fine-grained access
+     control for the users of an organization.
+    See `strongdm.models.Policy`.
     '''
     def __init__(self, channel, client):
         self.parent = client
-        self.stub = PeeringGroupResourcesStub(channel)
+        self.stub = PoliciesStub(channel)
 
-    def create(self, peering_group_resource, timeout=None):
+    def create(self, policy, timeout=None):
         '''
-         Create attaches a Resource to a PeeringGroup
+         Create creates a new Policy.
         '''
-        req = PeeringGroupResourceCreateRequest()
+        req = PolicyCreateRequest()
 
-        if peering_group_resource is not None:
-            req.peering_group_resource.CopyFrom(
-                plumbing.convert_peering_group_resource_to_plumbing(
-                    peering_group_resource))
+        if policy is not None:
+            req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy))
         tries = 0
         plumbing_response = None
         while True:
             try:
                 plumbing_response = self.stub.Create(
                     req,
-                    metadata=self.parent.get_metadata(
-                        'PeeringGroupResources.Create', req),
+                    metadata=self.parent.get_metadata('Policies.Create', req),
                     timeout=timeout)
             except Exception as e:
                 if self.parent.shouldRetry(tries, e):
@@ -2685,20 +3563,18 @@ class PeeringGroupResources:
                 raise plumbing.convert_error_to_porcelain(e) from e
             break
 
-        resp = models.PeeringGroupResourceCreateResponse()
-        resp.meta = plumbing.convert_create_response_metadata_to_porcelain(
-            plumbing_response.meta)
-        resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain(
-            plumbing_response.peering_group_resource)
+        resp = models.PolicyCreateResponse()
+        resp.policy = plumbing.convert_policy_to_porcelain(
+            plumbing_response.policy)
         resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
             plumbing_response.rate_limit)
         return resp
 
     def delete(self, id, timeout=None):
         '''
-         Delete detaches a Resource to a PeeringGroup
+         Delete removes a Policy by ID.
         '''
-        req = PeeringGroupResourceDeleteRequest()
+        req = PolicyDeleteRequest()
 
         req.id = (id)
         tries = 0
@@ -2707,8 +3583,7 @@ class PeeringGroupResources:
             try:
                 plumbing_response = self.stub.Delete(
                     req,
-                    metadata=self.parent.get_metadata(
-                        'PeeringGroupResources.Delete', req),
+                    metadata=self.parent.get_metadata('Policies.Delete', req),
                     timeout=timeout)
             except Exception as e:
                 if self.parent.shouldRetry(tries, e):
@@ -2718,18 +3593,47 @@ class PeeringGroupResources:
                 raise plumbing.convert_error_to_porcelain(e) from e
             break
 
-        resp = models.PeeringGroupResourceDeleteResponse()
-        resp.meta = plumbing.convert_delete_response_metadata_to_porcelain(
-            plumbing_response.meta)
+        resp = models.PolicyDeleteResponse()
+        resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
+            plumbing_response.rate_limit)
+        return resp
+
+    def update(self, policy, timeout=None):
+        '''
+         Update replaces all the fields of a Policy by ID.
+        '''
+        req = PolicyUpdateRequest()
+
+        if policy is not None:
+            req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy))
+        tries = 0
+        plumbing_response = None
+        while True:
+            try:
+                plumbing_response = self.stub.Update(
+                    req,
+                    metadata=self.parent.get_metadata('Policies.Update', req),
+                    timeout=timeout)
+            except Exception as e:
+                if self.parent.shouldRetry(tries, e):
+                    tries += 1
+                    self.parent.jitterSleep(tries)
+                    continue
+                raise plumbing.convert_error_to_porcelain(e) from e
+            break
+
+        resp = models.PolicyUpdateResponse()
+        resp.policy = plumbing.convert_policy_to_porcelain(
+            plumbing_response.policy)
         resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
             plumbing_response.rate_limit)
         return resp
 
     def get(self, id, timeout=None):
         '''
-         Get reads the information of one peering group to resource attachment.
+         Get reads one Policy by ID.
         '''
-        req = PeeringGroupResourceGetRequest()
+        req = PolicyGetRequest()
         if self.parent.snapshot_datetime is not None:
             req.meta.CopyFrom(GetRequestMetadata())
             req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime)
@@ -2741,8 +3645,7 @@ class PeeringGroupResources:
             try:
                 plumbing_response = self.stub.Get(
                     req,
-                    metadata=self.parent.get_metadata(
-                        'PeeringGroupResources.Get', req),
+                    metadata=self.parent.get_metadata('Policies.Get', req),
                     timeout=timeout)
             except Exception as e:
                 if self.parent.shouldRetry(tries, e):
@@ -2752,20 +3655,87 @@ class PeeringGroupResources:
                 raise plumbing.convert_error_to_porcelain(e) from e
             break
 
-        resp = models.PeeringGroupResourceGetResponse()
-        resp.meta = plumbing.convert_get_response_metadata_to_porcelain(
-            plumbing_response.meta)
-        resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain(
-            plumbing_response.peering_group_resource)
-        resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
-            plumbing_response.rate_limit)
-        return resp
+        resp = models.PolicyGetResponse()
+        resp.meta = plumbing.convert_get_response_metadata_to_porcelain(
+            plumbing_response.meta)
+        resp.policy = plumbing.convert_policy_to_porcelain(
+            plumbing_response.policy)
+        resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
+            plumbing_response.rate_limit)
+        return resp
+
+    def list(self, filter, *args, timeout=None):
+        '''
+         List gets a list of Policy matching a given set of criteria
+        '''
+        req = PolicyListRequest()
+        req.meta.CopyFrom(ListRequestMetadata())
+        if self.parent.page_limit > 0:
+            req.meta.limit = self.parent.page_limit
+        if self.parent.snapshot_datetime is not None:
+            req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime)
+
+        req.filter = plumbing.quote_filter_args(filter, *args)
+
+        def generator(svc, req):
+            tries = 0
+            while True:
+                try:
+                    plumbing_response = svc.stub.List(
+                        req,
+                        metadata=svc.parent.get_metadata('Policies.List', req),
+                        timeout=timeout)
+                except Exception as e:
+                    if self.parent.shouldRetry(tries, e):
+                        tries += 1
+                        self.parent.jitterSleep(tries)
+                        continue
+                    raise plumbing.convert_error_to_porcelain(e) from e
+                tries = 0
+                for plumbing_item in plumbing_response.policies:
+                    yield plumbing.convert_policy_to_porcelain(plumbing_item)
+                if plumbing_response.meta.next_cursor == '':
+                    break
+                req.meta.cursor = plumbing_response.meta.next_cursor
+
+        return generator(self, req)
+
+
+class SnapshotPolicies:
+    '''
+    SnapshotPolicies exposes the read only methods of the Policies
+    service for historical queries.
+    '''
+    def __init__(self, policies):
+        self.policies = policies
+
+    def get(self, id, timeout=None):
+        '''
+         Get reads one Policy by ID.
+        '''
+        return self.policies.get(id, timeout=timeout)
 
     def list(self, filter, *args, timeout=None):
         '''
-         List gets a list of peering group resource attachments.
+         List gets a list of Policy matching a given set of criteria
         '''
-        req = PeeringGroupResourceListRequest()
+        return self.policies.list(filter, *args, timeout=timeout)
+
+
+class PoliciesHistory:
+    '''
+     PoliciesHistory records all changes to the state of a Policy.
+    See `strongdm.models.PolicyHistory`.
+    '''
+    def __init__(self, channel, client):
+        self.parent = client
+        self.stub = PoliciesHistoryStub(channel)
+
+    def list(self, filter, *args, timeout=None):
+        '''
+         List gets a list of PolicyHistory records matching a given set of criteria.
+        '''
+        req = PoliciesHistoryListRequest()
         req.meta.CopyFrom(ListRequestMetadata())
         if self.parent.page_limit > 0:
             req.meta.limit = self.parent.page_limit
@@ -2781,7 +3751,7 @@ class PeeringGroupResources:
                     plumbing_response = svc.stub.List(
                         req,
                         metadata=svc.parent.get_metadata(
-                            'PeeringGroupResources.List', req),
+                            'PoliciesHistory.List', req),
                         timeout=timeout)
                 except Exception as e:
                     if self.parent.shouldRetry(tries, e):
@@ -2790,8 +3760,8 @@ class PeeringGroupResources:
                         continue
                     raise plumbing.convert_error_to_porcelain(e) from e
                 tries = 0
-                for plumbing_item in plumbing_response.peering_group_resources:
-                    yield plumbing.convert_peering_group_resource_to_porcelain(
+                for plumbing_item in plumbing_response.history:
+                    yield plumbing.convert_policy_history_to_porcelain(
                         plumbing_item)
                 if plumbing_response.meta.next_cursor == '':
                     break
@@ -2800,32 +3770,35 @@ class PeeringGroupResources:
         return generator(self, req)
 
 
-class PeeringGroups:
+class ProxyClusterKeys:
     '''
-     PeeringGroups provides the building blocks necessary to obtain explicit network topology and routing.
-    See `strongdm.models.PeeringGroup`.
+     Proxy Cluster Keys are authentication keys for all proxies within a cluster.
+     The proxies within a cluster share the same key. One cluster can have
+     multiple keys in order to facilitate key rotation.
+    See `strongdm.models.ProxyClusterKey`.
     '''
     def __init__(self, channel, client):
         self.parent = client
-        self.stub = PeeringGroupsStub(channel)
+        self.stub = ProxyClusterKeysStub(channel)
 
-    def create(self, peering_group, timeout=None):
+    def create(self, proxy_cluster_key, timeout=None):
         '''
-         Create registers a new PeeringGroup.
+         Create registers a new ProxyClusterKey.
         '''
-        req = PeeringGroupCreateRequest()
+        req = ProxyClusterKeyCreateRequest()
 
-        if peering_group is not None:
-            req.peering_group.CopyFrom(
-                plumbing.convert_peering_group_to_plumbing(peering_group))
+        if proxy_cluster_key is not None:
+            req.proxy_cluster_key.CopyFrom(
+                plumbing.convert_proxy_cluster_key_to_plumbing(
+                    proxy_cluster_key))
         tries = 0
         plumbing_response = None
         while True:
             try:
                 plumbing_response = self.stub.Create(
                     req,
-                    metadata=self.parent.get_metadata('PeeringGroups.Create',
-                                                      req),
+                    metadata=self.parent.get_metadata(
+                        'ProxyClusterKeys.Create', req),
                     timeout=timeout)
             except Exception as e:
                 if self.parent.shouldRetry(tries, e):
@@ -2835,29 +3808,33 @@ class PeeringGroups:
                 raise plumbing.convert_error_to_porcelain(e) from e
             break
 
-        resp = models.PeeringGroupCreateResponse()
+        resp = models.ProxyClusterKeyCreateResponse()
         resp.meta = plumbing.convert_create_response_metadata_to_porcelain(
             plumbing_response.meta)
-        resp.peering_group = plumbing.convert_peering_group_to_porcelain(
-            plumbing_response.peering_group)
+        resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain(
+            plumbing_response.proxy_cluster_key)
         resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
             plumbing_response.rate_limit)
+        resp.secret_key = (plumbing_response.secret_key)
         return resp
 
-    def delete(self, id, timeout=None):
+    def get(self, id, timeout=None):
         '''
-         Delete removes a PeeringGroup by ID.
+         Get reads one ProxyClusterKey by ID.
         '''
-        req = PeeringGroupDeleteRequest()
+        req = ProxyClusterKeyGetRequest()
+        if self.parent.snapshot_datetime is not None:
+            req.meta.CopyFrom(GetRequestMetadata())
+            req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime)
 
         req.id = (id)
         tries = 0
         plumbing_response = None
         while True:
             try:
-                plumbing_response = self.stub.Delete(
+                plumbing_response = self.stub.Get(
                     req,
-                    metadata=self.parent.get_metadata('PeeringGroups.Delete',
+                    metadata=self.parent.get_metadata('ProxyClusterKeys.Get',
                                                       req),
                     timeout=timeout)
             except Exception as e:
@@ -2868,31 +3845,30 @@ class PeeringGroups:
                 raise plumbing.convert_error_to_porcelain(e) from e
             break
 
-        resp = models.PeeringGroupDeleteResponse()
-        resp.meta = plumbing.convert_delete_response_metadata_to_porcelain(
+        resp = models.ProxyClusterKeyGetResponse()
+        resp.meta = plumbing.convert_get_response_metadata_to_porcelain(
             plumbing_response.meta)
+        resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain(
+            plumbing_response.proxy_cluster_key)
         resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
             plumbing_response.rate_limit)
         return resp
 
-    def get(self, id, timeout=None):
+    def delete(self, id, timeout=None):
         '''
-         Get reads one PeeringGroup by ID. It will load all its dependencies.
+         Delete removes a ProxyClusterKey by ID.
         '''
-        req = PeeringGroupGetRequest()
-        if self.parent.snapshot_datetime is not None:
-            req.meta.CopyFrom(GetRequestMetadata())
-            req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime)
+        req = ProxyClusterKeyDeleteRequest()
 
         req.id = (id)
         tries = 0
         plumbing_response = None
         while True:
             try:
-                plumbing_response = self.stub.Get(
+                plumbing_response = self.stub.Delete(
                     req,
-                    metadata=self.parent.get_metadata('PeeringGroups.Get',
-                                                      req),
+                    metadata=self.parent.get_metadata(
+                        'ProxyClusterKeys.Delete', req),
                     timeout=timeout)
             except Exception as e:
                 if self.parent.shouldRetry(tries, e):
@@ -2902,20 +3878,18 @@ class PeeringGroups:
                 raise plumbing.convert_error_to_porcelain(e) from e
             break
 
-        resp = models.PeeringGroupGetResponse()
-        resp.meta = plumbing.convert_get_response_metadata_to_porcelain(
+        resp = models.ProxyClusterKeyDeleteResponse()
+        resp.meta = plumbing.convert_delete_response_metadata_to_porcelain(
             plumbing_response.meta)
-        resp.peering_group = plumbing.convert_peering_group_to_porcelain(
-            plumbing_response.peering_group)
         resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
             plumbing_response.rate_limit)
         return resp
 
     def list(self, filter, *args, timeout=None):
         '''
-         List gets a list of Peering Groups.
+         List gets a list of ProxyClusterKeys matching a given set of criteria.
         '''
-        req = PeeringGroupListRequest()
+        req = ProxyClusterKeyListRequest()
         req.meta.CopyFrom(ListRequestMetadata())
         if self.parent.page_limit > 0:
             req.meta.limit = self.parent.page_limit
@@ -2931,7 +3905,7 @@ class PeeringGroups:
                     plumbing_response = svc.stub.List(
                         req,
                         metadata=svc.parent.get_metadata(
-                            'PeeringGroups.List', req),
+                            'ProxyClusterKeys.List', req),
                         timeout=timeout)
                 except Exception as e:
                     if self.parent.shouldRetry(tries, e):
@@ -2940,8 +3914,8 @@ class PeeringGroups:
                         continue
                     raise plumbing.convert_error_to_porcelain(e) from e
                 tries = 0
-                for plumbing_item in plumbing_response.peering_groups:
-                    yield plumbing.convert_peering_group_to_porcelain(
+                for plumbing_item in plumbing_response.proxy_cluster_keys:
+                    yield plumbing.convert_proxy_cluster_key_to_porcelain(
                         plumbing_item)
                 if plumbing_response.meta.next_cursor == '':
                     break
@@ -2950,6 +3924,27 @@ class PeeringGroups:
         return generator(self, req)
 
 
+class SnapshotProxyClusterKeys:
+    '''
+    SnapshotProxyClusterKeys exposes the read only methods of the ProxyClusterKeys
+    service for historical queries.
+    '''
+    def __init__(self, proxy_cluster_keys):
+        self.proxy_cluster_keys = proxy_cluster_keys
+
+    def get(self, id, timeout=None):
+        '''
+         Get reads one ProxyClusterKey by ID.
+        '''
+        return self.proxy_cluster_keys.get(id, timeout=timeout)
+
+    def list(self, filter, *args, timeout=None):
+        '''
+         List gets a list of ProxyClusterKeys matching a given set of criteria.
+        '''
+        return self.proxy_cluster_keys.list(filter, *args, timeout=timeout)
+
+
 class Queries:
     '''
      A Query is a record of a single client request to a resource, such as a SQL query.
@@ -3472,11 +4467,13 @@ class Resources:
     `strongdm.models.AmazonMQAMQP091`
     `strongdm.models.Athena`
     `strongdm.models.AuroraMysql`
+    `strongdm.models.AuroraMysqlIAM`
     `strongdm.models.AuroraPostgres`
     `strongdm.models.AuroraPostgresIAM`
     `strongdm.models.AWS`
     `strongdm.models.AWSConsole`
     `strongdm.models.AWSConsoleStaticKeyPair`
+    `strongdm.models.AWSInstanceProfile`
     `strongdm.models.Azure`
     `strongdm.models.AzureCertificate`
     `strongdm.models.AzureMysql`
@@ -3487,6 +4484,8 @@ class Resources:
     `strongdm.models.Citus`
     `strongdm.models.Clustrix`
     `strongdm.models.Cockroach`
+    `strongdm.models.CouchbaseDatabase`
+    `strongdm.models.CouchbaseWebUI`
     `strongdm.models.DB2I`
     `strongdm.models.DB2LUW`
     `strongdm.models.DocumentDBHost`
@@ -3496,6 +4495,8 @@ class Resources:
     `strongdm.models.Elastic`
     `strongdm.models.ElasticacheRedis`
     `strongdm.models.GCP`
+    `strongdm.models.GCPConsole`
+    `strongdm.models.GCPWIF`
     `strongdm.models.GoogleGKE`
     `strongdm.models.GoogleGKEUserImpersonation`
     `strongdm.models.Greenplum`
@@ -3539,6 +4540,7 @@ class Resources:
     `strongdm.models.SSH`
     `strongdm.models.SSHCert`
     `strongdm.models.SSHCustomerKey`
+    `strongdm.models.SSHPassword`
     `strongdm.models.Sybase`
     `strongdm.models.SybaseIQ`
     `strongdm.models.Teradata`
@@ -4215,85 +5217,6 @@ class RolesHistory:
         return generator(self, req)
 
 
-class SecretStoreHealths:
-    '''
-     SecretStoreHealths exposes health states for secret stores.
-    See `strongdm.models.SecretStoreHealth`.
-    '''
-    def __init__(self, channel, client):
-        self.parent = client
-        self.stub = SecretStoreHealthsStub(channel)
-
-    def list(self, filter, *args, timeout=None):
-        '''
-         List reports the health status of node to secret store pairs.
-        '''
-        req = SecretStoreHealthListRequest()
-        req.meta.CopyFrom(ListRequestMetadata())
-        if self.parent.page_limit > 0:
-            req.meta.limit = self.parent.page_limit
-        if self.parent.snapshot_datetime is not None:
-            req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime)
-
-        req.filter = plumbing.quote_filter_args(filter, *args)
-
-        def generator(svc, req):
-            tries = 0
-            while True:
-                try:
-                    plumbing_response = svc.stub.List(
-                        req,
-                        metadata=svc.parent.get_metadata(
-                            'SecretStoreHealths.List', req),
-                        timeout=timeout)
-                except Exception as e:
-                    if self.parent.shouldRetry(tries, e):
-                        tries += 1
-                        self.parent.jitterSleep(tries)
-                        continue
-                    raise plumbing.convert_error_to_porcelain(e) from e
-                tries = 0
-                for plumbing_item in plumbing_response.secret_store_healths:
-                    yield plumbing.convert_secret_store_health_to_porcelain(
-                        plumbing_item)
-                if plumbing_response.meta.next_cursor == '':
-                    break
-                req.meta.cursor = plumbing_response.meta.next_cursor
-
-        return generator(self, req)
-
-    def healthcheck(self, secret_store_id, timeout=None):
-        '''
-         Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes
-         to propagate across a large network of Nodes. The call will return immediately, and the
-         updated health of the Secret Store can be retrieved via List.
-        '''
-        req = SecretStoreHealthcheckRequest()
-
-        req.secret_store_id = (secret_store_id)
-        tries = 0
-        plumbing_response = None
-        while True:
-            try:
-                plumbing_response = self.stub.Healthcheck(
-                    req,
-                    metadata=self.parent.get_metadata(
-                        'SecretStoreHealths.Healthcheck', req),
-                    timeout=timeout)
-            except Exception as e:
-                if self.parent.shouldRetry(tries, e):
-                    tries += 1
-                    self.parent.jitterSleep(tries)
-                    continue
-                raise plumbing.convert_error_to_porcelain(e) from e
-            break
-
-        resp = models.SecretStoreHealthcheckResponse()
-        resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
-            plumbing_response.rate_limit)
-        return resp
-
-
 class SecretStores:
     '''
      SecretStores are servers where resource secrets (passwords, keys) are stored.
@@ -4308,9 +5231,13 @@ class SecretStores:
     `strongdm.models.DelineaStore`
     `strongdm.models.GCPStore`
     `strongdm.models.GCPCertX509Store`
+    `strongdm.models.KeyfactorSSHStore`
+    `strongdm.models.KeyfactorX509Store`
     `strongdm.models.VaultAppRoleStore`
     `strongdm.models.VaultAppRoleCertSSHStore`
     `strongdm.models.VaultAppRoleCertX509Store`
+    `strongdm.models.VaultAWSEC2Store`
+    `strongdm.models.VaultAWSIAMStore`
     `strongdm.models.VaultTLSStore`
     `strongdm.models.VaultTLSCertSSHStore`
     `strongdm.models.VaultTLSCertX509Store`
@@ -4515,6 +5442,85 @@ class SnapshotSecretStores:
         return self.secret_stores.list(filter, *args, timeout=timeout)
 
 
+class SecretStoreHealths:
+    '''
+     SecretStoreHealths exposes health states for secret stores.
+    See `strongdm.models.SecretStoreHealth`.
+    '''
+    def __init__(self, channel, client):
+        self.parent = client
+        self.stub = SecretStoreHealthsStub(channel)
+
+    def list(self, filter, *args, timeout=None):
+        '''
+         List reports the health status of node to secret store pairs.
+        '''
+        req = SecretStoreHealthListRequest()
+        req.meta.CopyFrom(ListRequestMetadata())
+        if self.parent.page_limit > 0:
+            req.meta.limit = self.parent.page_limit
+        if self.parent.snapshot_datetime is not None:
+            req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime)
+
+        req.filter = plumbing.quote_filter_args(filter, *args)
+
+        def generator(svc, req):
+            tries = 0
+            while True:
+                try:
+                    plumbing_response = svc.stub.List(
+                        req,
+                        metadata=svc.parent.get_metadata(
+                            'SecretStoreHealths.List', req),
+                        timeout=timeout)
+                except Exception as e:
+                    if self.parent.shouldRetry(tries, e):
+                        tries += 1
+                        self.parent.jitterSleep(tries)
+                        continue
+                    raise plumbing.convert_error_to_porcelain(e) from e
+                tries = 0
+                for plumbing_item in plumbing_response.secret_store_healths:
+                    yield plumbing.convert_secret_store_health_to_porcelain(
+                        plumbing_item)
+                if plumbing_response.meta.next_cursor == '':
+                    break
+                req.meta.cursor = plumbing_response.meta.next_cursor
+
+        return generator(self, req)
+
+    def healthcheck(self, secret_store_id, timeout=None):
+        '''
+         Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes
+         to propagate across a large network of Nodes. The call will return immediately, and the
+         updated health of the Secret Store can be retrieved via List.
+        '''
+        req = SecretStoreHealthcheckRequest()
+
+        req.secret_store_id = (secret_store_id)
+        tries = 0
+        plumbing_response = None
+        while True:
+            try:
+                plumbing_response = self.stub.Healthcheck(
+                    req,
+                    metadata=self.parent.get_metadata(
+                        'SecretStoreHealths.Healthcheck', req),
+                    timeout=timeout)
+            except Exception as e:
+                if self.parent.shouldRetry(tries, e):
+                    tries += 1
+                    self.parent.jitterSleep(tries)
+                    continue
+                raise plumbing.convert_error_to_porcelain(e) from e
+            break
+
+        resp = models.SecretStoreHealthcheckResponse()
+        resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain(
+            plumbing_response.rate_limit)
+        return resp
+
+
 class SecretStoresHistory:
     '''
      SecretStoresHistory records all changes to the state of a SecretStore.