@@ -6620,6 +6707,696 @@ Methods with HTTP bindings
+
+
policy/unsafe/unsafe.proto
Top
+
DeleteAttributeRequest
+ WARNING!!
Deleting an Attribute will free up the Attribute name for reuse, which can introduce an access path to existing TDFs containing the deleted Attribute name.
Values under this Attribute will be cascadingly deleted.
Any KAS Grants associated with this Attribute will be cascadingly deleted.
+
+
+
+
+ | Field | Type | Label | Description |
+
+
+
+
+ | id |
+ string |
+ |
+ Required
+UUID of the Attribute |
+
+
+
+ | fqn |
+ string |
+ |
+ Fully Qualified Name (FQN) of Attribute Definition (i.e. https://<namespace>/attr/<attribute name>), normalized to lower case. |
+
+
+
+
+
+
+
+
+
+ DeleteAttributeResponse
+
+
+
+
+
+ | Field | Type | Label | Description |
+
+
+
+
+ | attribute |
+ policy.Attribute |
+ |
+ |
+
+
+
+
+
+
+
+
+
+ DeleteAttributeValueRequest
+ WARNING!!
Deleting an Attribute Value will free up the Attribute Value for reuse, which can introduce an access path to existing TDFs containing the deleted Attribute Value.
Any KAS Grants associated with this Attribute Value will be cascadingly deleted.
+
+
+
+
+ | Field | Type | Label | Description |
+
+
+
+
+ | id |
+ string |
+ |
+ Required
+UUID of the Attribute Value |
+
+
+
+ | fqn |
+ string |
+ |
+ Fully Qualified Name (FQN) of Attribute Value (i.e. https://<namespace>/attr/<attribute name>/value/<value>), normalized to lower case. |
+
+
+
+
+
+
+
+
+
+ DeleteAttributeValueResponse
+
+
+
+
+
+ | Field | Type | Label | Description |
+
+
+
+
+ | value |
+ policy.Value |
+ |
+ |
+
+
+
+
+
+
+
+
+
+ DeleteNamespaceRequest
+ WARNING!!
Deleting a Namespace will free up the Attribute Namespace, Definitions, and Values for reuse, which can introduce an access path to existing TDFs containing the deleted policy.
Definitions and their Values under this Namespace will be cascadingly deleted.
+
+
+
+
+ | Field | Type | Label | Description |
+
+
+
+
+ | id |
+ string |
+ |
+ Required
+UUID of the Namespace |
+
+
+
+ | fqn |
+ string |
+ |
+ Fully Qualified Name (FQN) of Namespace (i.e. https://<namespace>), normalized to lower case. |
+
+
+
+
+
+
+
+
+
+ DeleteNamespaceResponse
+
+
+
+
+
+ | Field | Type | Label | Description |
+
+
+
+
+ | namespace |
+ policy.Namespace |
+ |
+ |
+
+
+
+
+
+
+
+
+
+ ReactivateAttributeRequest
+ WARNING!!
Reactivating an Attribute can potentially open up an access path to existing TDFs containing the Attribute name.
Active state of any Values under this Attribute Definition will NOT be changed.
+
+
+
+
+ | Field | Type | Label | Description |
+
+
+
+
+ | id |
+ string |
+ |
+ |
+
+
+
+
+
+
+
+
+
+ ReactivateAttributeResponse
+
+
+
+
+
+ | Field | Type | Label | Description |
+
+
+
+
+ | attribute |
+ policy.Attribute |
+ |
+ |
+
+
+
+
+
+
+
+
+
+ ReactivateAttributeValueRequest
+ WARNING!!
Reactivating an Attribute Value can potentially open up an access path to existing TDFs containing the Attribute Value.
+
+
+
+
+ | Field | Type | Label | Description |
+
+
+
+
+ | id |
+ string |
+ |
+ |
+
+
+
+
+
+
+
+
+
+ ReactivateAttributeValueResponse
+
+
+
+
+
+ | Field | Type | Label | Description |
+
+
+
+
+ | value |
+ policy.Value |
+ |
+ |
+
+
+
+
+
+
+
+
+
+ ReactivateNamespaceRequest
+ WARNING!!
Reactivating a Namespace can potentially open up an access path to existing TDFs containing any Attributes under the Namespace.
Active state of any Definitions and their Values under this Namespace will NOT be changed.
+
+
+
+
+ | Field | Type | Label | Description |
+
+
+
+
+ | id |
+ string |
+ |
+ |
+
+
+
+
+
+
+
+
+
+ ReactivateNamespaceResponse
+
+
+
+
+
+ | Field | Type | Label | Description |
+
+
+
+
+ | namespace |
+ policy.Namespace |
+ |
+ |
+
+
+
+
+
+
+
+
+
+ UpdateAttributeRequest
+ WARNING!!
Updating an Attribute can have dangerous consequences. Use with caution.
+
+
+
+
+ | Field | Type | Label | Description |
+
+
+
+
+ | id |
+ string |
+ |
+ Required |
+
+
+
+ | name |
+ string |
+ |
+ Optional
+WARNING!!
+Updating the name of an Attribute will retroactively alter access to existing TDFs of the old and new Attribute name. |
+
+
+
+ | rule |
+ policy.AttributeRuleTypeEnum |
+ |
+ WARNING!!
+Updating the rule of an Attribute will retroactively alter access to existing TDFs of the Attribute name. |
+
+
+
+
+
+
+
+
+
+ UpdateAttributeResponse
+
+
+
+
+
+ | Field | Type | Label | Description |
+
+
+
+
+ | attribute |
+ policy.Attribute |
+ |
+ |
+
+
+
+
+
+
+
+
+
+ UpdateAttributeValueRequest
+ WARNING!!
Updating an Attribute Value will retroactively alter access to existing TDFs containing the old and new Attribute Value.
+
+
+
+
+ | Field | Type | Label | Description |
+
+
+
+
+ | id |
+ string |
+ |
+ |
+
+
+
+ | value |
+ string |
+ |
+ |
+
+
+
+
+
+
+
+
+
+ UpdateAttributeValueResponse
+
+
+
+
+
+ | Field | Type | Label | Description |
+
+
+
+
+ | value |
+ policy.Value |
+ |
+ |
+
+
+
+
+
+
+
+
+
+ UpdateNamespaceRequest
+ WARNING!!
Updating the Namespace of an Attribute will retroactively alter access to existing TDFs of the old and new Namespace name.
Existing Attribute Definitions and their Values under the Namespace will now be associated with the new Namespace name.
+
+
+
+
+ | Field | Type | Label | Description |
+
+
+
+
+ | id |
+ string |
+ |
+ Required |
+
+
+
+ | name |
+ string |
+ |
+ |
+
+
+
+
+
+
+
+
+
+ UpdateNamespaceResponse
+
+
+
+
+
+ | Field | Type | Label | Description |
+
+
+
+
+ | namespace |
+ policy.Namespace |
+ |
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ UnsafeService
+ Unsafe Service
/ IN FLIGHT AND NOT YET IMPLEMENTED!
/
+
+
+
+
+
+ Methods with HTTP bindings
+
+
+
+ | Method Name |
+ Method |
+ Pattern |
+ Body |
+
+
+
+
+
+
+
+ | UpdateNamespace |
+ PATCH |
+ /unsafe/namespaces/{id} |
+ |
+
+
+
+
+
+
+ | ReactivateNamespace |
+ POST |
+ /unsafe/namespaces/{id}/reactivate |
+ |
+
+
+
+
+
+
+ | DeleteNamespace |
+ DELETE |
+ /unsafe/namespaces/{id} |
+ |
+
+
+
+
+
+
+ | UpdateAttribute |
+ PATCH |
+ /unsafe/attributes/{id} |
+ |
+
+
+
+
+
+
+ | ReactivateAttribute |
+ POST |
+ /unsafe/attributes/{id}/reactivate |
+ |
+
+
+
+
+
+
+ | DeleteAttribute |
+ DELETE |
+ /unsafe/attributes/{id} |
+ |
+
+
+
+
+
+
+ | UpdateAttributeValue |
+ PATCH |
+ /unsafe/attributes/values/{id} |
+ |
+
+
+
+
+
+
+ | ReactivateAttributeValue |
+ POST |
+ /unsafe/attributes/values/{id}/reactivate |
+ |
+
+
+
+
+
+
+ | DeleteAttributeValue |
+ DELETE |
+ /unsafe/attributes/values/{id} |
+ |
+
+
+
+
+
+
+
+
+
wellknownconfiguration/wellknown_configuration.proto
Top
diff --git a/docs/openapi/policy/attributes/attributes.swagger.json b/docs/openapi/policy/attributes/attributes.swagger.json
index a4b24743c..66ae7a37d 100644
--- a/docs/openapi/policy/attributes/attributes.swagger.json
+++ b/docs/openapi/policy/attributes/attributes.swagger.json
@@ -259,7 +259,7 @@
"200": {
"description": "A successful response.",
"schema": {
- "$ref": "#/definitions/attributesUpdateAttributeValueResponse"
+ "$ref": "#/definitions/policyattributesUpdateAttributeValueResponse"
}
},
"default": {
@@ -553,7 +553,7 @@
"200": {
"description": "A successful response.",
"schema": {
- "$ref": "#/definitions/attributesUpdateAttributeResponse"
+ "$ref": "#/definitions/policyattributesUpdateAttributeResponse"
}
},
"default": {
@@ -773,22 +773,6 @@
}
}
},
- "attributesUpdateAttributeResponse": {
- "type": "object",
- "properties": {
- "attribute": {
- "$ref": "#/definitions/policyAttribute"
- }
- }
- },
- "attributesUpdateAttributeValueResponse": {
- "type": "object",
- "properties": {
- "value": {
- "$ref": "#/definitions/policyValue"
- }
- }
- },
"attributesValueKeyAccessServer": {
"type": "object",
"properties": {
@@ -1179,6 +1163,22 @@
}
}
},
+ "policyattributesUpdateAttributeResponse": {
+ "type": "object",
+ "properties": {
+ "attribute": {
+ "$ref": "#/definitions/policyAttribute"
+ }
+ }
+ },
+ "policyattributesUpdateAttributeValueResponse": {
+ "type": "object",
+ "properties": {
+ "value": {
+ "$ref": "#/definitions/policyValue"
+ }
+ }
+ },
"protobufAny": {
"type": "object",
"properties": {
diff --git a/docs/openapi/policy/namespaces/namespaces.swagger.json b/docs/openapi/policy/namespaces/namespaces.swagger.json
index c864e0ee5..d0d2964be 100644
--- a/docs/openapi/policy/namespaces/namespaces.swagger.json
+++ b/docs/openapi/policy/namespaces/namespaces.swagger.json
@@ -147,7 +147,7 @@
"200": {
"description": "A successful response.",
"schema": {
- "$ref": "#/definitions/namespacesUpdateNamespaceResponse"
+ "$ref": "#/definitions/policynamespacesUpdateNamespaceResponse"
}
},
"default": {
@@ -290,14 +290,6 @@
}
}
},
- "namespacesUpdateNamespaceResponse": {
- "type": "object",
- "properties": {
- "namespace": {
- "$ref": "#/definitions/policyNamespace"
- }
- }
- },
"policyNamespace": {
"type": "object",
"properties": {
@@ -321,6 +313,14 @@
}
}
},
+ "policynamespacesUpdateNamespaceResponse": {
+ "type": "object",
+ "properties": {
+ "namespace": {
+ "$ref": "#/definitions/policyNamespace"
+ }
+ }
+ },
"protobufAny": {
"type": "object",
"properties": {
diff --git a/docs/openapi/policy/unsafe/unsafe.swagger.json b/docs/openapi/policy/unsafe/unsafe.swagger.json
new file mode 100644
index 000000000..a06e83132
--- /dev/null
+++ b/docs/openapi/policy/unsafe/unsafe.swagger.json
@@ -0,0 +1,778 @@
+{
+ "swagger": "2.0",
+ "info": {
+ "title": "policy/unsafe/unsafe.proto",
+ "version": "version not set"
+ },
+ "tags": [
+ {
+ "name": "UnsafeService"
+ }
+ ],
+ "consumes": [
+ "application/json"
+ ],
+ "produces": [
+ "application/json"
+ ],
+ "paths": {
+ "/unsafe/attributes/values/{id}": {
+ "delete": {
+ "operationId": "UnsafeService_DeleteAttributeValue",
+ "responses": {
+ "200": {
+ "description": "A successful response.",
+ "schema": {
+ "$ref": "#/definitions/unsafeDeleteAttributeValueResponse"
+ }
+ },
+ "default": {
+ "description": "An unexpected error response.",
+ "schema": {
+ "$ref": "#/definitions/rpcStatus"
+ }
+ }
+ },
+ "parameters": [
+ {
+ "name": "id",
+ "description": "Required\nUUID of the Attribute Value",
+ "in": "path",
+ "required": true,
+ "type": "string"
+ },
+ {
+ "name": "fqn",
+ "description": "Fully Qualified Name (FQN) of Attribute Value (i.e. https://\u003cnamespace\u003e/attr/\u003cattribute name\u003e/value/\u003cvalue\u003e), normalized to lower case.",
+ "in": "query",
+ "required": false,
+ "type": "string"
+ }
+ ],
+ "tags": [
+ "UnsafeService"
+ ]
+ },
+ "patch": {
+ "summary": "--------------------------------------*\nValue RPCs\n---------------------------------------",
+ "operationId": "UnsafeService_UpdateAttributeValue",
+ "responses": {
+ "200": {
+ "description": "A successful response.",
+ "schema": {
+ "$ref": "#/definitions/policyunsafeUpdateAttributeValueResponse"
+ }
+ },
+ "default": {
+ "description": "An unexpected error response.",
+ "schema": {
+ "$ref": "#/definitions/rpcStatus"
+ }
+ }
+ },
+ "parameters": [
+ {
+ "name": "id",
+ "in": "path",
+ "required": true,
+ "type": "string"
+ },
+ {
+ "name": "value",
+ "in": "query",
+ "required": false,
+ "type": "string"
+ }
+ ],
+ "tags": [
+ "UnsafeService"
+ ]
+ }
+ },
+ "/unsafe/attributes/values/{id}/reactivate": {
+ "post": {
+ "operationId": "UnsafeService_ReactivateAttributeValue",
+ "responses": {
+ "200": {
+ "description": "A successful response.",
+ "schema": {
+ "$ref": "#/definitions/unsafeReactivateAttributeValueResponse"
+ }
+ },
+ "default": {
+ "description": "An unexpected error response.",
+ "schema": {
+ "$ref": "#/definitions/rpcStatus"
+ }
+ }
+ },
+ "parameters": [
+ {
+ "name": "id",
+ "in": "path",
+ "required": true,
+ "type": "string"
+ }
+ ],
+ "tags": [
+ "UnsafeService"
+ ]
+ }
+ },
+ "/unsafe/attributes/{id}": {
+ "delete": {
+ "operationId": "UnsafeService_DeleteAttribute",
+ "responses": {
+ "200": {
+ "description": "A successful response.",
+ "schema": {
+ "$ref": "#/definitions/unsafeDeleteAttributeResponse"
+ }
+ },
+ "default": {
+ "description": "An unexpected error response.",
+ "schema": {
+ "$ref": "#/definitions/rpcStatus"
+ }
+ }
+ },
+ "parameters": [
+ {
+ "name": "id",
+ "description": "Required\nUUID of the Attribute",
+ "in": "path",
+ "required": true,
+ "type": "string"
+ },
+ {
+ "name": "fqn",
+ "description": "Fully Qualified Name (FQN) of Attribute Definition (i.e. https://\u003cnamespace\u003e/attr/\u003cattribute name\u003e), normalized to lower case.",
+ "in": "query",
+ "required": false,
+ "type": "string"
+ }
+ ],
+ "tags": [
+ "UnsafeService"
+ ]
+ },
+ "patch": {
+ "summary": "--------------------------------------*\nAttribute RPCs\n---------------------------------------",
+ "operationId": "UnsafeService_UpdateAttribute",
+ "responses": {
+ "200": {
+ "description": "A successful response.",
+ "schema": {
+ "$ref": "#/definitions/policyunsafeUpdateAttributeResponse"
+ }
+ },
+ "default": {
+ "description": "An unexpected error response.",
+ "schema": {
+ "$ref": "#/definitions/rpcStatus"
+ }
+ }
+ },
+ "parameters": [
+ {
+ "name": "id",
+ "description": "Required",
+ "in": "path",
+ "required": true,
+ "type": "string"
+ },
+ {
+ "name": "name",
+ "description": "Optional\nWARNING!! \nUpdating the name of an Attribute will retroactively alter access to existing TDFs of the old and new Attribute name.",
+ "in": "query",
+ "required": false,
+ "type": "string"
+ },
+ {
+ "name": "rule",
+ "description": "WARNING!! \nUpdating the rule of an Attribute will retroactively alter access to existing TDFs of the Attribute name.",
+ "in": "query",
+ "required": false,
+ "type": "string",
+ "enum": [
+ "ATTRIBUTE_RULE_TYPE_ENUM_UNSPECIFIED",
+ "ATTRIBUTE_RULE_TYPE_ENUM_ALL_OF",
+ "ATTRIBUTE_RULE_TYPE_ENUM_ANY_OF",
+ "ATTRIBUTE_RULE_TYPE_ENUM_HIERARCHY"
+ ],
+ "default": "ATTRIBUTE_RULE_TYPE_ENUM_UNSPECIFIED"
+ }
+ ],
+ "tags": [
+ "UnsafeService"
+ ]
+ }
+ },
+ "/unsafe/attributes/{id}/reactivate": {
+ "post": {
+ "operationId": "UnsafeService_ReactivateAttribute",
+ "responses": {
+ "200": {
+ "description": "A successful response.",
+ "schema": {
+ "$ref": "#/definitions/unsafeReactivateAttributeResponse"
+ }
+ },
+ "default": {
+ "description": "An unexpected error response.",
+ "schema": {
+ "$ref": "#/definitions/rpcStatus"
+ }
+ }
+ },
+ "parameters": [
+ {
+ "name": "id",
+ "in": "path",
+ "required": true,
+ "type": "string"
+ }
+ ],
+ "tags": [
+ "UnsafeService"
+ ]
+ }
+ },
+ "/unsafe/namespaces/{id}": {
+ "delete": {
+ "operationId": "UnsafeService_DeleteNamespace",
+ "responses": {
+ "200": {
+ "description": "A successful response.",
+ "schema": {
+ "$ref": "#/definitions/unsafeDeleteNamespaceResponse"
+ }
+ },
+ "default": {
+ "description": "An unexpected error response.",
+ "schema": {
+ "$ref": "#/definitions/rpcStatus"
+ }
+ }
+ },
+ "parameters": [
+ {
+ "name": "id",
+ "description": "Required\nUUID of the Namespace",
+ "in": "path",
+ "required": true,
+ "type": "string"
+ },
+ {
+ "name": "fqn",
+ "description": "Fully Qualified Name (FQN) of Namespace (i.e. https://\u003cnamespace\u003e), normalized to lower case.",
+ "in": "query",
+ "required": false,
+ "type": "string"
+ }
+ ],
+ "tags": [
+ "UnsafeService"
+ ]
+ },
+ "patch": {
+ "summary": "--------------------------------------*\nNamespace RPCs\n---------------------------------------",
+ "operationId": "UnsafeService_UpdateNamespace",
+ "responses": {
+ "200": {
+ "description": "A successful response.",
+ "schema": {
+ "$ref": "#/definitions/policyunsafeUpdateNamespaceResponse"
+ }
+ },
+ "default": {
+ "description": "An unexpected error response.",
+ "schema": {
+ "$ref": "#/definitions/rpcStatus"
+ }
+ }
+ },
+ "parameters": [
+ {
+ "name": "id",
+ "description": "Required",
+ "in": "path",
+ "required": true,
+ "type": "string"
+ },
+ {
+ "name": "name",
+ "in": "query",
+ "required": false,
+ "type": "string"
+ }
+ ],
+ "tags": [
+ "UnsafeService"
+ ]
+ }
+ },
+ "/unsafe/namespaces/{id}/reactivate": {
+ "post": {
+ "operationId": "UnsafeService_ReactivateNamespace",
+ "responses": {
+ "200": {
+ "description": "A successful response.",
+ "schema": {
+ "$ref": "#/definitions/unsafeReactivateNamespaceResponse"
+ }
+ },
+ "default": {
+ "description": "An unexpected error response.",
+ "schema": {
+ "$ref": "#/definitions/rpcStatus"
+ }
+ }
+ },
+ "parameters": [
+ {
+ "name": "id",
+ "in": "path",
+ "required": true,
+ "type": "string"
+ }
+ ],
+ "tags": [
+ "UnsafeService"
+ ]
+ }
+ }
+ },
+ "definitions": {
+ "ActionStandardAction": {
+ "type": "string",
+ "enum": [
+ "STANDARD_ACTION_UNSPECIFIED",
+ "STANDARD_ACTION_DECRYPT",
+ "STANDARD_ACTION_TRANSMIT"
+ ],
+ "default": "STANDARD_ACTION_UNSPECIFIED",
+ "title": "Standard actions supported by the platform"
+ },
+ "commonMetadata": {
+ "type": "object",
+ "properties": {
+ "createdAt": {
+ "type": "string",
+ "format": "date-time",
+ "title": "created_at set by server (entity who created will recorded in an audit event)"
+ },
+ "updatedAt": {
+ "type": "string",
+ "format": "date-time",
+ "title": "updated_at set by server (entity who updated will recorded in an audit event)"
+ },
+ "labels": {
+ "type": "object",
+ "additionalProperties": {
+ "type": "string"
+ },
+ "title": "optional short description"
+ }
+ },
+ "title": "Struct to uniquely identify a resource with optional additional metadata"
+ },
+ "policyAction": {
+ "type": "object",
+ "properties": {
+ "standard": {
+ "$ref": "#/definitions/ActionStandardAction"
+ },
+ "custom": {
+ "type": "string"
+ }
+ },
+ "title": "An action an entity can take"
+ },
+ "policyAttribute": {
+ "type": "object",
+ "properties": {
+ "id": {
+ "type": "string"
+ },
+ "namespace": {
+ "$ref": "#/definitions/policyNamespace",
+ "title": "namespace of the attribute"
+ },
+ "name": {
+ "type": "string",
+ "title": "attribute name"
+ },
+ "rule": {
+ "$ref": "#/definitions/policyAttributeRuleTypeEnum",
+ "title": "attribute rule enum"
+ },
+ "values": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "$ref": "#/definitions/policyValue"
+ }
+ },
+ "grants": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "$ref": "#/definitions/policyKeyAccessServer"
+ }
+ },
+ "fqn": {
+ "type": "string"
+ },
+ "active": {
+ "type": "boolean",
+ "title": "active by default until explicitly deactivated"
+ },
+ "metadata": {
+ "$ref": "#/definitions/commonMetadata",
+ "title": "Common metadata"
+ }
+ }
+ },
+ "policyAttributeRuleTypeEnum": {
+ "type": "string",
+ "enum": [
+ "ATTRIBUTE_RULE_TYPE_ENUM_UNSPECIFIED",
+ "ATTRIBUTE_RULE_TYPE_ENUM_ALL_OF",
+ "ATTRIBUTE_RULE_TYPE_ENUM_ANY_OF",
+ "ATTRIBUTE_RULE_TYPE_ENUM_HIERARCHY"
+ ],
+ "default": "ATTRIBUTE_RULE_TYPE_ENUM_UNSPECIFIED",
+ "title": "buflint ENUM_VALUE_PREFIX: to make sure that C++ scoping rules aren't violated when users add new enum values to an enum in a given package"
+ },
+ "policyCondition": {
+ "type": "object",
+ "properties": {
+ "subjectExternalSelectorValue": {
+ "type": "string",
+ "title": "a selector for a field value on a flattened Entity Representation (such as from idP/LDAP)"
+ },
+ "operator": {
+ "$ref": "#/definitions/policySubjectMappingOperatorEnum",
+ "title": "the evaluation operator of relation"
+ },
+ "subjectExternalValues": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "title": "list of comparison values for the result of applying the subject_external_selector_value on a flattened Entity Representation (Subject), evaluated by the operator"
+ }
+ },
+ "description": "Example: Subjects with a field selected by the flattened selector \"'.division'\" and a value of \"Accounting\" or \"Marketing\":\n{\n\"subject_external_selector_value\": \"'.division'\",\n\"operator\": \"SUBJECT_MAPPING_OPERATOR_ENUM_IN\",\n\"subject_external_values\" : [\"Accounting\", \"Marketing\"]\n}\n\nExample: Subjects that are not part of the Fantastic Four according to their alias field:\n{\n\"subject_external_selector_value\": \"'.data[0].alias'\",\n\"operator\": \"SUBJECT_MAPPING_OPERATOR_ENUM_NOT_IN\",\n\"subject_external_values\" : [\"mister_fantastic\", \"the_thing\", \"human_torch\", \"invisible_woman\"]\n}",
+ "title": "*\nA Condition defines a rule of \u003cthe value at the flattened 'selector value' location\u003e \u003coperator\u003e \u003csubject external values\u003e"
+ },
+ "policyConditionBooleanTypeEnum": {
+ "type": "string",
+ "enum": [
+ "CONDITION_BOOLEAN_TYPE_ENUM_UNSPECIFIED",
+ "CONDITION_BOOLEAN_TYPE_ENUM_AND",
+ "CONDITION_BOOLEAN_TYPE_ENUM_OR"
+ ],
+ "default": "CONDITION_BOOLEAN_TYPE_ENUM_UNSPECIFIED",
+ "title": "buflint ENUM_VALUE_PREFIX: to make sure that C++ scoping rules aren't violated when users add new enum values to an enum in a given package"
+ },
+ "policyConditionGroup": {
+ "type": "object",
+ "properties": {
+ "conditions": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "$ref": "#/definitions/policyCondition"
+ }
+ },
+ "booleanOperator": {
+ "$ref": "#/definitions/policyConditionBooleanTypeEnum",
+ "title": "the boolean evaluation type across the conditions"
+ }
+ },
+ "title": "A collection of Conditions evaluated by the boolean_operator provided"
+ },
+ "policyKeyAccessServer": {
+ "type": "object",
+ "properties": {
+ "id": {
+ "type": "string"
+ },
+ "uri": {
+ "type": "string",
+ "title": "Address of a KAS instance"
+ },
+ "publicKey": {
+ "$ref": "#/definitions/policyPublicKey"
+ },
+ "metadata": {
+ "$ref": "#/definitions/commonMetadata",
+ "title": "Common metadata"
+ }
+ },
+ "title": "Key Access Server Registry"
+ },
+ "policyNamespace": {
+ "type": "object",
+ "properties": {
+ "id": {
+ "type": "string",
+ "title": "generated uuid in database"
+ },
+ "name": {
+ "type": "string",
+ "title": "used to partition Attribute Definitions, support by namespace AuthN and enable federation"
+ },
+ "fqn": {
+ "type": "string"
+ },
+ "active": {
+ "type": "boolean",
+ "title": "active by default until explicitly deactivated"
+ },
+ "metadata": {
+ "$ref": "#/definitions/commonMetadata"
+ }
+ }
+ },
+ "policyPublicKey": {
+ "type": "object",
+ "properties": {
+ "remote": {
+ "type": "string",
+ "title": "kas public key url - optional since can also be retrieved via public key"
+ },
+ "local": {
+ "type": "string",
+ "title": "public key - optional since can also be retrieved via url"
+ }
+ }
+ },
+ "policySubjectConditionSet": {
+ "type": "object",
+ "properties": {
+ "id": {
+ "type": "string"
+ },
+ "subjectSets": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "$ref": "#/definitions/policySubjectSet"
+ }
+ },
+ "metadata": {
+ "$ref": "#/definitions/commonMetadata"
+ }
+ },
+ "description": "A container for multiple Subject Sets, each containing Condition Groups, each containing Conditions. Multiple Subject Sets in a SubjectConditionSet\nare evaluated with AND logic. As each Subject Mapping has only one Attribute Value, the SubjectConditionSet is reusable across multiple\nSubject Mappings / Attribute Values and is an independent unit."
+ },
+ "policySubjectMapping": {
+ "type": "object",
+ "properties": {
+ "id": {
+ "type": "string"
+ },
+ "attributeValue": {
+ "$ref": "#/definitions/policyValue",
+ "title": "the Attribute Value mapped to; aka: \"The Entity Entitlement Attribute\""
+ },
+ "subjectConditionSet": {
+ "$ref": "#/definitions/policySubjectConditionSet",
+ "title": "the reusable SubjectConditionSet mapped to the given Attribute Value"
+ },
+ "actions": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "$ref": "#/definitions/policyAction"
+ },
+ "title": "The actions permitted by subjects in this mapping"
+ },
+ "metadata": {
+ "$ref": "#/definitions/commonMetadata"
+ }
+ },
+ "description": "Example: Subjects in sets 1 and 2 are entitled attribute value http://wwww.example.org/attr/example/value/one\nwith permitted actions TRANSMIT and DECRYPT\n{\n\"id\": \"someid\",\n\"attribute_value\": {example_one_attribute_value...},\n\"subject_condition_set\": {\"subject_sets\":[{subject_set_1},{subject_set_2}]...},\n\"actions\": [{\"standard\": \"STANDARD_ACTION_DECRYPT\"}\", {\"standard\": \"STANDARD_ACTION_TRANSMIT\"}]\n}",
+ "title": "Subject Mapping: A Policy assigning Subject Set(s) to a permitted attribute value + action(s) combination"
+ },
+ "policySubjectMappingOperatorEnum": {
+ "type": "string",
+ "enum": [
+ "SUBJECT_MAPPING_OPERATOR_ENUM_UNSPECIFIED",
+ "SUBJECT_MAPPING_OPERATOR_ENUM_IN",
+ "SUBJECT_MAPPING_OPERATOR_ENUM_NOT_IN"
+ ],
+ "default": "SUBJECT_MAPPING_OPERATOR_ENUM_UNSPECIFIED",
+ "title": "buflint ENUM_VALUE_PREFIX: to make sure that C++ scoping rules aren't violated when users add new enum values to an enum in a given package"
+ },
+ "policySubjectSet": {
+ "type": "object",
+ "properties": {
+ "conditionGroups": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "$ref": "#/definitions/policyConditionGroup"
+ },
+ "title": "multiple Condition Groups are evaluated with AND logic"
+ }
+ },
+ "title": "A collection of Condition Groups"
+ },
+ "policyValue": {
+ "type": "object",
+ "properties": {
+ "id": {
+ "type": "string",
+ "title": "generated uuid in database"
+ },
+ "attribute": {
+ "$ref": "#/definitions/policyAttribute"
+ },
+ "value": {
+ "type": "string"
+ },
+ "members": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "$ref": "#/definitions/policyValue"
+ },
+ "title": "list of attribute values that this value is related to (attribute group)"
+ },
+ "grants": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "$ref": "#/definitions/policyKeyAccessServer"
+ },
+ "title": "list of key access servers"
+ },
+ "fqn": {
+ "type": "string"
+ },
+ "active": {
+ "type": "boolean",
+ "title": "active by default until explicitly deactivated"
+ },
+ "subjectMappings": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "$ref": "#/definitions/policySubjectMapping"
+ },
+ "title": "subject mapping"
+ },
+ "metadata": {
+ "$ref": "#/definitions/commonMetadata",
+ "title": "Common metadata"
+ }
+ }
+ },
+ "policyunsafeUpdateAttributeResponse": {
+ "type": "object",
+ "properties": {
+ "attribute": {
+ "$ref": "#/definitions/policyAttribute"
+ }
+ }
+ },
+ "policyunsafeUpdateAttributeValueResponse": {
+ "type": "object",
+ "properties": {
+ "value": {
+ "$ref": "#/definitions/policyValue"
+ }
+ }
+ },
+ "policyunsafeUpdateNamespaceResponse": {
+ "type": "object",
+ "properties": {
+ "namespace": {
+ "$ref": "#/definitions/policyNamespace"
+ }
+ }
+ },
+ "protobufAny": {
+ "type": "object",
+ "properties": {
+ "@type": {
+ "type": "string",
+ "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics."
+ }
+ },
+ "additionalProperties": {},
+ "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }"
+ },
+ "rpcStatus": {
+ "type": "object",
+ "properties": {
+ "code": {
+ "type": "integer",
+ "format": "int32"
+ },
+ "message": {
+ "type": "string"
+ },
+ "details": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "$ref": "#/definitions/protobufAny"
+ }
+ }
+ }
+ },
+ "unsafeDeleteAttributeResponse": {
+ "type": "object",
+ "properties": {
+ "attribute": {
+ "$ref": "#/definitions/policyAttribute"
+ }
+ }
+ },
+ "unsafeDeleteAttributeValueResponse": {
+ "type": "object",
+ "properties": {
+ "value": {
+ "$ref": "#/definitions/policyValue"
+ }
+ }
+ },
+ "unsafeDeleteNamespaceResponse": {
+ "type": "object",
+ "properties": {
+ "namespace": {
+ "$ref": "#/definitions/policyNamespace"
+ }
+ }
+ },
+ "unsafeReactivateAttributeResponse": {
+ "type": "object",
+ "properties": {
+ "attribute": {
+ "$ref": "#/definitions/policyAttribute"
+ }
+ }
+ },
+ "unsafeReactivateAttributeValueResponse": {
+ "type": "object",
+ "properties": {
+ "value": {
+ "$ref": "#/definitions/policyValue"
+ }
+ }
+ },
+ "unsafeReactivateNamespaceResponse": {
+ "type": "object",
+ "properties": {
+ "namespace": {
+ "$ref": "#/definitions/policyNamespace"
+ }
+ }
+ }
+ }
+}
diff --git a/protocol/go/policy/unsafe/unsafe.pb.go b/protocol/go/policy/unsafe/unsafe.pb.go
new file mode 100644
index 000000000..212083b27
--- /dev/null
+++ b/protocol/go/policy/unsafe/unsafe.pb.go
@@ -0,0 +1,1529 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// protoc-gen-go v1.33.0
+// protoc (unknown)
+// source: policy/unsafe/unsafe.proto
+
+package unsafe
+
+import (
+ _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate"
+ policy "github.com/opentdf/platform/protocol/go/policy"
+ _ "google.golang.org/genproto/googleapis/api/annotations"
+ protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+ protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+ reflect "reflect"
+ sync "sync"
+)
+
+const (
+ // Verify that this generated code is sufficiently up-to-date.
+ _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+ // Verify that runtime/protoimpl is sufficiently up-to-date.
+ _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+// WARNING!!
+// Updating the Namespace of an Attribute will retroactively alter access to existing TDFs of the old and new Namespace name.
+// Existing Attribute Definitions and their Values under the Namespace will now be associated with the new Namespace name.
+type UpdateNamespaceRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // Required
+ Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+ Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
+}
+
+func (x *UpdateNamespaceRequest) Reset() {
+ *x = UpdateNamespaceRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *UpdateNamespaceRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UpdateNamespaceRequest) ProtoMessage() {}
+
+func (x *UpdateNamespaceRequest) ProtoReflect() protoreflect.Message {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[0]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use UpdateNamespaceRequest.ProtoReflect.Descriptor instead.
+func (*UpdateNamespaceRequest) Descriptor() ([]byte, []int) {
+ return file_policy_unsafe_unsafe_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *UpdateNamespaceRequest) GetId() string {
+ if x != nil {
+ return x.Id
+ }
+ return ""
+}
+
+func (x *UpdateNamespaceRequest) GetName() string {
+ if x != nil {
+ return x.Name
+ }
+ return ""
+}
+
+type UpdateNamespaceResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Namespace *policy.Namespace `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
+}
+
+func (x *UpdateNamespaceResponse) Reset() {
+ *x = UpdateNamespaceResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *UpdateNamespaceResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UpdateNamespaceResponse) ProtoMessage() {}
+
+func (x *UpdateNamespaceResponse) ProtoReflect() protoreflect.Message {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[1]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use UpdateNamespaceResponse.ProtoReflect.Descriptor instead.
+func (*UpdateNamespaceResponse) Descriptor() ([]byte, []int) {
+ return file_policy_unsafe_unsafe_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *UpdateNamespaceResponse) GetNamespace() *policy.Namespace {
+ if x != nil {
+ return x.Namespace
+ }
+ return nil
+}
+
+// WARNING!!
+// Reactivating a Namespace can potentially open up an access path to existing TDFs containing any Attributes under the Namespace.
+// Active state of any Definitions and their Values under this Namespace will NOT be changed.
+type ReactivateNamespaceRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+}
+
+func (x *ReactivateNamespaceRequest) Reset() {
+ *x = ReactivateNamespaceRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[2]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *ReactivateNamespaceRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ReactivateNamespaceRequest) ProtoMessage() {}
+
+func (x *ReactivateNamespaceRequest) ProtoReflect() protoreflect.Message {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[2]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use ReactivateNamespaceRequest.ProtoReflect.Descriptor instead.
+func (*ReactivateNamespaceRequest) Descriptor() ([]byte, []int) {
+ return file_policy_unsafe_unsafe_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *ReactivateNamespaceRequest) GetId() string {
+ if x != nil {
+ return x.Id
+ }
+ return ""
+}
+
+type ReactivateNamespaceResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Namespace *policy.Namespace `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
+}
+
+func (x *ReactivateNamespaceResponse) Reset() {
+ *x = ReactivateNamespaceResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[3]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *ReactivateNamespaceResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ReactivateNamespaceResponse) ProtoMessage() {}
+
+func (x *ReactivateNamespaceResponse) ProtoReflect() protoreflect.Message {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[3]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use ReactivateNamespaceResponse.ProtoReflect.Descriptor instead.
+func (*ReactivateNamespaceResponse) Descriptor() ([]byte, []int) {
+ return file_policy_unsafe_unsafe_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *ReactivateNamespaceResponse) GetNamespace() *policy.Namespace {
+ if x != nil {
+ return x.Namespace
+ }
+ return nil
+}
+
+// WARNING!!
+// Deleting a Namespace will free up the Attribute Namespace, Definitions, and Values for reuse, which can introduce an access path to existing TDFs containing the deleted policy.
+// Definitions and their Values under this Namespace will be cascadingly deleted.
+type DeleteNamespaceRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // Required
+ // UUID of the Namespace
+ Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+ // Fully Qualified Name (FQN) of Namespace (i.e. https://), normalized to lower case.
+ Fqn string `protobuf:"bytes,2,opt,name=fqn,proto3" json:"fqn,omitempty"`
+}
+
+func (x *DeleteNamespaceRequest) Reset() {
+ *x = DeleteNamespaceRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[4]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *DeleteNamespaceRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DeleteNamespaceRequest) ProtoMessage() {}
+
+func (x *DeleteNamespaceRequest) ProtoReflect() protoreflect.Message {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[4]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use DeleteNamespaceRequest.ProtoReflect.Descriptor instead.
+func (*DeleteNamespaceRequest) Descriptor() ([]byte, []int) {
+ return file_policy_unsafe_unsafe_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *DeleteNamespaceRequest) GetId() string {
+ if x != nil {
+ return x.Id
+ }
+ return ""
+}
+
+func (x *DeleteNamespaceRequest) GetFqn() string {
+ if x != nil {
+ return x.Fqn
+ }
+ return ""
+}
+
+type DeleteNamespaceResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Namespace *policy.Namespace `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
+}
+
+func (x *DeleteNamespaceResponse) Reset() {
+ *x = DeleteNamespaceResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[5]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *DeleteNamespaceResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DeleteNamespaceResponse) ProtoMessage() {}
+
+func (x *DeleteNamespaceResponse) ProtoReflect() protoreflect.Message {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[5]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use DeleteNamespaceResponse.ProtoReflect.Descriptor instead.
+func (*DeleteNamespaceResponse) Descriptor() ([]byte, []int) {
+ return file_policy_unsafe_unsafe_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *DeleteNamespaceResponse) GetNamespace() *policy.Namespace {
+ if x != nil {
+ return x.Namespace
+ }
+ return nil
+}
+
+// WARNING!!
+// Updating an Attribute can have dangerous consequences. Use with caution.
+type UpdateAttributeRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // Required
+ Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+ // Optional
+ // WARNING!!
+ // Updating the name of an Attribute will retroactively alter access to existing TDFs of the old and new Attribute name.
+ Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
+ // WARNING!!
+ // Updating the rule of an Attribute will retroactively alter access to existing TDFs of the Attribute name.
+ Rule policy.AttributeRuleTypeEnum `protobuf:"varint,3,opt,name=rule,proto3,enum=policy.AttributeRuleTypeEnum" json:"rule,omitempty"`
+}
+
+func (x *UpdateAttributeRequest) Reset() {
+ *x = UpdateAttributeRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[6]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *UpdateAttributeRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UpdateAttributeRequest) ProtoMessage() {}
+
+func (x *UpdateAttributeRequest) ProtoReflect() protoreflect.Message {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[6]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use UpdateAttributeRequest.ProtoReflect.Descriptor instead.
+func (*UpdateAttributeRequest) Descriptor() ([]byte, []int) {
+ return file_policy_unsafe_unsafe_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *UpdateAttributeRequest) GetId() string {
+ if x != nil {
+ return x.Id
+ }
+ return ""
+}
+
+func (x *UpdateAttributeRequest) GetName() string {
+ if x != nil {
+ return x.Name
+ }
+ return ""
+}
+
+func (x *UpdateAttributeRequest) GetRule() policy.AttributeRuleTypeEnum {
+ if x != nil {
+ return x.Rule
+ }
+ return policy.AttributeRuleTypeEnum(0)
+}
+
+type UpdateAttributeResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Attribute *policy.Attribute `protobuf:"bytes,1,opt,name=attribute,proto3" json:"attribute,omitempty"`
+}
+
+func (x *UpdateAttributeResponse) Reset() {
+ *x = UpdateAttributeResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[7]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *UpdateAttributeResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UpdateAttributeResponse) ProtoMessage() {}
+
+func (x *UpdateAttributeResponse) ProtoReflect() protoreflect.Message {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[7]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use UpdateAttributeResponse.ProtoReflect.Descriptor instead.
+func (*UpdateAttributeResponse) Descriptor() ([]byte, []int) {
+ return file_policy_unsafe_unsafe_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *UpdateAttributeResponse) GetAttribute() *policy.Attribute {
+ if x != nil {
+ return x.Attribute
+ }
+ return nil
+}
+
+// WARNING!!
+// Reactivating an Attribute can potentially open up an access path to existing TDFs containing the Attribute name.
+// Active state of any Values under this Attribute Definition will NOT be changed.
+type ReactivateAttributeRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+}
+
+func (x *ReactivateAttributeRequest) Reset() {
+ *x = ReactivateAttributeRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[8]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *ReactivateAttributeRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ReactivateAttributeRequest) ProtoMessage() {}
+
+func (x *ReactivateAttributeRequest) ProtoReflect() protoreflect.Message {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[8]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use ReactivateAttributeRequest.ProtoReflect.Descriptor instead.
+func (*ReactivateAttributeRequest) Descriptor() ([]byte, []int) {
+ return file_policy_unsafe_unsafe_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *ReactivateAttributeRequest) GetId() string {
+ if x != nil {
+ return x.Id
+ }
+ return ""
+}
+
+type ReactivateAttributeResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Attribute *policy.Attribute `protobuf:"bytes,1,opt,name=attribute,proto3" json:"attribute,omitempty"`
+}
+
+func (x *ReactivateAttributeResponse) Reset() {
+ *x = ReactivateAttributeResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[9]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *ReactivateAttributeResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ReactivateAttributeResponse) ProtoMessage() {}
+
+func (x *ReactivateAttributeResponse) ProtoReflect() protoreflect.Message {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[9]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use ReactivateAttributeResponse.ProtoReflect.Descriptor instead.
+func (*ReactivateAttributeResponse) Descriptor() ([]byte, []int) {
+ return file_policy_unsafe_unsafe_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *ReactivateAttributeResponse) GetAttribute() *policy.Attribute {
+ if x != nil {
+ return x.Attribute
+ }
+ return nil
+}
+
+// WARNING!!
+// Deleting an Attribute will free up the Attribute name for reuse, which can introduce an access path to existing TDFs containing the deleted Attribute name.
+// Values under this Attribute will be cascadingly deleted.
+// Any KAS Grants associated with this Attribute will be cascadingly deleted.
+type DeleteAttributeRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // Required
+ // UUID of the Attribute
+ Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+ // Fully Qualified Name (FQN) of Attribute Definition (i.e. https:///attr/), normalized to lower case.
+ Fqn string `protobuf:"bytes,2,opt,name=fqn,proto3" json:"fqn,omitempty"`
+}
+
+func (x *DeleteAttributeRequest) Reset() {
+ *x = DeleteAttributeRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[10]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *DeleteAttributeRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DeleteAttributeRequest) ProtoMessage() {}
+
+func (x *DeleteAttributeRequest) ProtoReflect() protoreflect.Message {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[10]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use DeleteAttributeRequest.ProtoReflect.Descriptor instead.
+func (*DeleteAttributeRequest) Descriptor() ([]byte, []int) {
+ return file_policy_unsafe_unsafe_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *DeleteAttributeRequest) GetId() string {
+ if x != nil {
+ return x.Id
+ }
+ return ""
+}
+
+func (x *DeleteAttributeRequest) GetFqn() string {
+ if x != nil {
+ return x.Fqn
+ }
+ return ""
+}
+
+type DeleteAttributeResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Attribute *policy.Attribute `protobuf:"bytes,1,opt,name=attribute,proto3" json:"attribute,omitempty"`
+}
+
+func (x *DeleteAttributeResponse) Reset() {
+ *x = DeleteAttributeResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[11]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *DeleteAttributeResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DeleteAttributeResponse) ProtoMessage() {}
+
+func (x *DeleteAttributeResponse) ProtoReflect() protoreflect.Message {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[11]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use DeleteAttributeResponse.ProtoReflect.Descriptor instead.
+func (*DeleteAttributeResponse) Descriptor() ([]byte, []int) {
+ return file_policy_unsafe_unsafe_proto_rawDescGZIP(), []int{11}
+}
+
+func (x *DeleteAttributeResponse) GetAttribute() *policy.Attribute {
+ if x != nil {
+ return x.Attribute
+ }
+ return nil
+}
+
+// WARNING!!
+// Updating an Attribute Value will retroactively alter access to existing TDFs containing the old and new Attribute Value.
+type UpdateAttributeValueRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+ Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (x *UpdateAttributeValueRequest) Reset() {
+ *x = UpdateAttributeValueRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[12]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *UpdateAttributeValueRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UpdateAttributeValueRequest) ProtoMessage() {}
+
+func (x *UpdateAttributeValueRequest) ProtoReflect() protoreflect.Message {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[12]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use UpdateAttributeValueRequest.ProtoReflect.Descriptor instead.
+func (*UpdateAttributeValueRequest) Descriptor() ([]byte, []int) {
+ return file_policy_unsafe_unsafe_proto_rawDescGZIP(), []int{12}
+}
+
+func (x *UpdateAttributeValueRequest) GetId() string {
+ if x != nil {
+ return x.Id
+ }
+ return ""
+}
+
+func (x *UpdateAttributeValueRequest) GetValue() string {
+ if x != nil {
+ return x.Value
+ }
+ return ""
+}
+
+type UpdateAttributeValueResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Value *policy.Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (x *UpdateAttributeValueResponse) Reset() {
+ *x = UpdateAttributeValueResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[13]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *UpdateAttributeValueResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UpdateAttributeValueResponse) ProtoMessage() {}
+
+func (x *UpdateAttributeValueResponse) ProtoReflect() protoreflect.Message {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[13]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use UpdateAttributeValueResponse.ProtoReflect.Descriptor instead.
+func (*UpdateAttributeValueResponse) Descriptor() ([]byte, []int) {
+ return file_policy_unsafe_unsafe_proto_rawDescGZIP(), []int{13}
+}
+
+func (x *UpdateAttributeValueResponse) GetValue() *policy.Value {
+ if x != nil {
+ return x.Value
+ }
+ return nil
+}
+
+// WARNING!!
+// Reactivating an Attribute Value can potentially open up an access path to existing TDFs containing the Attribute Value.
+type ReactivateAttributeValueRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+}
+
+func (x *ReactivateAttributeValueRequest) Reset() {
+ *x = ReactivateAttributeValueRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[14]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *ReactivateAttributeValueRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ReactivateAttributeValueRequest) ProtoMessage() {}
+
+func (x *ReactivateAttributeValueRequest) ProtoReflect() protoreflect.Message {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[14]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use ReactivateAttributeValueRequest.ProtoReflect.Descriptor instead.
+func (*ReactivateAttributeValueRequest) Descriptor() ([]byte, []int) {
+ return file_policy_unsafe_unsafe_proto_rawDescGZIP(), []int{14}
+}
+
+func (x *ReactivateAttributeValueRequest) GetId() string {
+ if x != nil {
+ return x.Id
+ }
+ return ""
+}
+
+type ReactivateAttributeValueResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Value *policy.Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (x *ReactivateAttributeValueResponse) Reset() {
+ *x = ReactivateAttributeValueResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[15]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *ReactivateAttributeValueResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ReactivateAttributeValueResponse) ProtoMessage() {}
+
+func (x *ReactivateAttributeValueResponse) ProtoReflect() protoreflect.Message {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[15]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use ReactivateAttributeValueResponse.ProtoReflect.Descriptor instead.
+func (*ReactivateAttributeValueResponse) Descriptor() ([]byte, []int) {
+ return file_policy_unsafe_unsafe_proto_rawDescGZIP(), []int{15}
+}
+
+func (x *ReactivateAttributeValueResponse) GetValue() *policy.Value {
+ if x != nil {
+ return x.Value
+ }
+ return nil
+}
+
+// WARNING!!
+// Deleting an Attribute Value will free up the Attribute Value for reuse, which can introduce an access path to existing TDFs containing the deleted Attribute Value.
+// Any KAS Grants associated with this Attribute Value will be cascadingly deleted.
+type DeleteAttributeValueRequest struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // Required
+ // UUID of the Attribute Value
+ Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+ // Fully Qualified Name (FQN) of Attribute Value (i.e. https:///attr//value/), normalized to lower case.
+ Fqn string `protobuf:"bytes,2,opt,name=fqn,proto3" json:"fqn,omitempty"`
+}
+
+func (x *DeleteAttributeValueRequest) Reset() {
+ *x = DeleteAttributeValueRequest{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[16]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *DeleteAttributeValueRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DeleteAttributeValueRequest) ProtoMessage() {}
+
+func (x *DeleteAttributeValueRequest) ProtoReflect() protoreflect.Message {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[16]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use DeleteAttributeValueRequest.ProtoReflect.Descriptor instead.
+func (*DeleteAttributeValueRequest) Descriptor() ([]byte, []int) {
+ return file_policy_unsafe_unsafe_proto_rawDescGZIP(), []int{16}
+}
+
+func (x *DeleteAttributeValueRequest) GetId() string {
+ if x != nil {
+ return x.Id
+ }
+ return ""
+}
+
+func (x *DeleteAttributeValueRequest) GetFqn() string {
+ if x != nil {
+ return x.Fqn
+ }
+ return ""
+}
+
+type DeleteAttributeValueResponse struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ Value *policy.Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (x *DeleteAttributeValueResponse) Reset() {
+ *x = DeleteAttributeValueResponse{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[17]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *DeleteAttributeValueResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DeleteAttributeValueResponse) ProtoMessage() {}
+
+func (x *DeleteAttributeValueResponse) ProtoReflect() protoreflect.Message {
+ mi := &file_policy_unsafe_unsafe_proto_msgTypes[17]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use DeleteAttributeValueResponse.ProtoReflect.Descriptor instead.
+func (*DeleteAttributeValueResponse) Descriptor() ([]byte, []int) {
+ return file_policy_unsafe_unsafe_proto_rawDescGZIP(), []int{17}
+}
+
+func (x *DeleteAttributeValueResponse) GetValue() *policy.Value {
+ if x != nil {
+ return x.Value
+ }
+ return nil
+}
+
+var File_policy_unsafe_unsafe_proto protoreflect.FileDescriptor
+
+var file_policy_unsafe_unsafe_proto_rawDesc = []byte{
+ 0x0a, 0x1a, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2f, 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x2f,
+ 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0d, 0x70, 0x6f,
+ 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x1a, 0x1b, 0x62, 0x75, 0x66,
+ 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61,
+ 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+ 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+ 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x14, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2f, 0x6f,
+ 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xdf, 0x02, 0x0a,
+ 0x16, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65,
+ 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x16, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20,
+ 0x01, 0x28, 0x09, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, 0x12,
+ 0xac, 0x02, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x97,
+ 0x02, 0xba, 0x48, 0x93, 0x02, 0xba, 0x01, 0x8a, 0x02, 0x0a, 0x15, 0x6e, 0x61, 0x6d, 0x65, 0x73,
+ 0x70, 0x61, 0x63, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74,
+ 0x12, 0xb3, 0x01, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, 0x6e, 0x61, 0x6d,
+ 0x65, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x6c, 0x70,
+ 0x68, 0x61, 0x6e, 0x75, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
+ 0x2c, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x20, 0x68, 0x79, 0x70, 0x68, 0x65,
+ 0x6e, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x63, 0x6f, 0x72,
+ 0x65, 0x73, 0x20, 0x62, 0x75, 0x74, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68,
+ 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x6c, 0x61, 0x73, 0x74, 0x20,
+ 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x73,
+ 0x74, 0x6f, 0x72, 0x65, 0x64, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20,
+ 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x6e, 0x6f, 0x72,
+ 0x6d, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x6c, 0x6f, 0x77, 0x65, 0x72,
+ 0x20, 0x63, 0x61, 0x73, 0x65, 0x2e, 0x1a, 0x3b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x6d, 0x61, 0x74,
+ 0x63, 0x68, 0x65, 0x73, 0x28, 0x27, 0x5e, 0x5b, 0x61, 0x2d, 0x7a, 0x41, 0x2d, 0x5a, 0x30, 0x2d,
+ 0x39, 0x5d, 0x28, 0x3f, 0x3a, 0x5b, 0x61, 0x2d, 0x7a, 0x41, 0x2d, 0x5a, 0x30, 0x2d, 0x39, 0x5f,
+ 0x2d, 0x5d, 0x2a, 0x5b, 0x61, 0x2d, 0x7a, 0x41, 0x2d, 0x5a, 0x30, 0x2d, 0x39, 0x5d, 0x29, 0x3f,
+ 0x24, 0x27, 0x29, 0x72, 0x03, 0x18, 0xfd, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x4a,
+ 0x0a, 0x17, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63,
+ 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x09, 0x6e, 0x61, 0x6d,
+ 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x70,
+ 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52,
+ 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x22, 0x34, 0x0a, 0x1a, 0x52, 0x65,
+ 0x61, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63,
+ 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x16, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01,
+ 0x20, 0x01, 0x28, 0x09, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64,
+ 0x22, 0x4e, 0x0a, 0x1b, 0x52, 0x65, 0x61, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4e, 0x61,
+ 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
+ 0x2f, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01,
+ 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x4e, 0x61, 0x6d, 0x65,
+ 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65,
+ 0x22, 0x4a, 0x0a, 0x16, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70,
+ 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x16, 0x0a, 0x02, 0x69, 0x64,
+ 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02,
+ 0x69, 0x64, 0x12, 0x18, 0x0a, 0x03, 0x66, 0x71, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42,
+ 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x03, 0x66, 0x71, 0x6e, 0x22, 0x4a, 0x0a, 0x17,
+ 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52,
+ 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73,
+ 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x70, 0x6f, 0x6c,
+ 0x69, 0x63, 0x79, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x09, 0x6e,
+ 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x22, 0x9c, 0x03, 0x0a, 0x16, 0x55, 0x70, 0x64,
+ 0x61, 0x74, 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75,
+ 0x65, 0x73, 0x74, 0x12, 0x16, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42,
+ 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, 0x12, 0xac, 0x02, 0x0a, 0x04,
+ 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x97, 0x02, 0xba, 0x48, 0x93,
+ 0x02, 0xba, 0x01, 0x8a, 0x02, 0x0a, 0x15, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65,
+ 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, 0xb3, 0x01, 0x41,
+ 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6d, 0x75,
+ 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x6e, 0x75,
+ 0x6d, 0x65, 0x72, 0x69, 0x63, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2c, 0x20, 0x61, 0x6c,
+ 0x6c, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x20, 0x68, 0x79, 0x70, 0x68, 0x65, 0x6e, 0x73, 0x20, 0x61,
+ 0x6e, 0x64, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x73, 0x20, 0x62,
+ 0x75, 0x74, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69,
+ 0x72, 0x73, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x6c, 0x61, 0x73, 0x74, 0x20, 0x63, 0x68, 0x61, 0x72,
+ 0x61, 0x63, 0x74, 0x65, 0x72, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x65,
+ 0x64, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65,
+ 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69,
+ 0x7a, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x6c, 0x6f, 0x77, 0x65, 0x72, 0x20, 0x63, 0x61, 0x73,
+ 0x65, 0x2e, 0x1a, 0x3b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73,
+ 0x28, 0x27, 0x5e, 0x5b, 0x61, 0x2d, 0x7a, 0x41, 0x2d, 0x5a, 0x30, 0x2d, 0x39, 0x5d, 0x28, 0x3f,
+ 0x3a, 0x5b, 0x61, 0x2d, 0x7a, 0x41, 0x2d, 0x5a, 0x30, 0x2d, 0x39, 0x5f, 0x2d, 0x5d, 0x2a, 0x5b,
+ 0x61, 0x2d, 0x7a, 0x41, 0x2d, 0x5a, 0x30, 0x2d, 0x39, 0x5d, 0x29, 0x3f, 0x24, 0x27, 0x29, 0x72,
+ 0x03, 0x18, 0xfd, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x3b, 0x0a, 0x04, 0x72, 0x75,
+ 0x6c, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x70, 0x6f, 0x6c, 0x69, 0x63,
+ 0x79, 0x2e, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54,
+ 0x79, 0x70, 0x65, 0x45, 0x6e, 0x75, 0x6d, 0x42, 0x08, 0xba, 0x48, 0x05, 0x82, 0x01, 0x02, 0x10,
+ 0x01, 0x52, 0x04, 0x72, 0x75, 0x6c, 0x65, 0x22, 0x4a, 0x0a, 0x17, 0x55, 0x70, 0x64, 0x61, 0x74,
+ 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+ 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x09, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x18,
+ 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x41,
+ 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x52, 0x09, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62,
+ 0x75, 0x74, 0x65, 0x22, 0x34, 0x0a, 0x1a, 0x52, 0x65, 0x61, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74,
+ 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+ 0x74, 0x12, 0x16, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x06, 0xba,
+ 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, 0x22, 0x4e, 0x0a, 0x1b, 0x52, 0x65, 0x61,
+ 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65,
+ 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x09, 0x61, 0x74, 0x74, 0x72,
+ 0x69, 0x62, 0x75, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x70, 0x6f,
+ 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x52, 0x09,
+ 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x22, 0x4a, 0x0a, 0x16, 0x44, 0x65, 0x6c,
+ 0x65, 0x74, 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75,
+ 0x65, 0x73, 0x74, 0x12, 0x16, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42,
+ 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, 0x12, 0x18, 0x0a, 0x03, 0x66,
+ 0x71, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01,
+ 0x52, 0x03, 0x66, 0x71, 0x6e, 0x22, 0x4a, 0x0a, 0x17, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x41,
+ 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+ 0x12, 0x2f, 0x0a, 0x09, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x18, 0x01, 0x20,
+ 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x41, 0x74, 0x74,
+ 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x52, 0x09, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74,
+ 0x65, 0x22, 0xdf, 0x02, 0x0a, 0x1b, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x41, 0x74, 0x74, 0x72,
+ 0x69, 0x62, 0x75, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+ 0x74, 0x12, 0x16, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x06, 0xba,
+ 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, 0x12, 0xa7, 0x02, 0x0a, 0x05, 0x76, 0x61,
+ 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x90, 0x02, 0xba, 0x48, 0x8c, 0x02,
+ 0xba, 0x01, 0x83, 0x02, 0x0a, 0x0c, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6d,
+ 0x61, 0x74, 0x12, 0xb5, 0x01, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x20, 0x56,
+ 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, 0x6e, 0x20,
+ 0x61, 0x6c, 0x70, 0x68, 0x61, 0x6e, 0x75, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x20, 0x73, 0x74, 0x72,
+ 0x69, 0x6e, 0x67, 0x2c, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x20, 0x68, 0x79,
+ 0x70, 0x68, 0x65, 0x6e, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x73,
+ 0x63, 0x6f, 0x72, 0x65, 0x73, 0x20, 0x62, 0x75, 0x74, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x61, 0x73,
+ 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x6c, 0x61,
+ 0x73, 0x74, 0x20, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x2e, 0x20, 0x54, 0x68,
+ 0x65, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x64, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75,
+ 0x74, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65,
+ 0x20, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x6c,
+ 0x6f, 0x77, 0x65, 0x72, 0x20, 0x63, 0x61, 0x73, 0x65, 0x2e, 0x1a, 0x3b, 0x74, 0x68, 0x69, 0x73,
+ 0x2e, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x28, 0x27, 0x5e, 0x5b, 0x61, 0x2d, 0x7a, 0x41,
+ 0x2d, 0x5a, 0x30, 0x2d, 0x39, 0x5d, 0x28, 0x3f, 0x3a, 0x5b, 0x61, 0x2d, 0x7a, 0x41, 0x2d, 0x5a,
+ 0x30, 0x2d, 0x39, 0x5f, 0x2d, 0x5d, 0x2a, 0x5b, 0x61, 0x2d, 0x7a, 0x41, 0x2d, 0x5a, 0x30, 0x2d,
+ 0x39, 0x5d, 0x29, 0x3f, 0x24, 0x27, 0x29, 0x72, 0x03, 0x18, 0xfd, 0x01, 0x52, 0x05, 0x76, 0x61,
+ 0x6c, 0x75, 0x65, 0x22, 0x43, 0x0a, 0x1c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x41, 0x74, 0x74,
+ 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f,
+ 0x6e, 0x73, 0x65, 0x12, 0x23, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01,
+ 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x56, 0x61, 0x6c, 0x75,
+ 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x39, 0x0a, 0x1f, 0x52, 0x65, 0x61, 0x63,
+ 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x56,
+ 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x16, 0x0a, 0x02, 0x69,
+ 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52,
+ 0x02, 0x69, 0x64, 0x22, 0x47, 0x0a, 0x20, 0x52, 0x65, 0x61, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74,
+ 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52,
+ 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x23, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
+ 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e,
+ 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x4f, 0x0a, 0x1b,
+ 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x56,
+ 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x16, 0x0a, 0x02, 0x69,
+ 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52,
+ 0x02, 0x69, 0x64, 0x12, 0x18, 0x0a, 0x03, 0x66, 0x71, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
+ 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x03, 0x66, 0x71, 0x6e, 0x22, 0x43, 0x0a,
+ 0x1c, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65,
+ 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x23, 0x0a,
+ 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x70,
+ 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c,
+ 0x75, 0x65, 0x32, 0xba, 0x0a, 0x0a, 0x0d, 0x55, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x53, 0x65, 0x72,
+ 0x76, 0x69, 0x63, 0x65, 0x12, 0x81, 0x01, 0x0a, 0x0f, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4e,
+ 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x25, 0x2e, 0x70, 0x6f, 0x6c, 0x69, 0x63,
+ 0x79, 0x2e, 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4e,
+ 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+ 0x26, 0x2e, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x2e,
+ 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52,
+ 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x19, 0x32,
+ 0x17, 0x2f, 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61,
+ 0x63, 0x65, 0x73, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0x98, 0x01, 0x0a, 0x13, 0x52, 0x65, 0x61,
+ 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65,
+ 0x12, 0x29, 0x2e, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65,
+ 0x2e, 0x52, 0x65, 0x61, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73,
+ 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x70, 0x6f,
+ 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x2e, 0x52, 0x65, 0x61, 0x63,
+ 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52,
+ 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x24, 0x22,
+ 0x22, 0x2f, 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61,
+ 0x63, 0x65, 0x73, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x2f, 0x72, 0x65, 0x61, 0x63, 0x74, 0x69, 0x76,
+ 0x61, 0x74, 0x65, 0x12, 0x81, 0x01, 0x0a, 0x0f, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4e, 0x61,
+ 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x25, 0x2e, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79,
+ 0x2e, 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4e, 0x61,
+ 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26,
+ 0x2e, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x2e, 0x44,
+ 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65,
+ 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x19, 0x2a, 0x17,
+ 0x2f, 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63,
+ 0x65, 0x73, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0x81, 0x01, 0x0a, 0x0f, 0x55, 0x70, 0x64, 0x61,
+ 0x74, 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x12, 0x25, 0x2e, 0x70, 0x6f,
+ 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x2e, 0x55, 0x70, 0x64, 0x61,
+ 0x74, 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
+ 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x75, 0x6e, 0x73, 0x61,
+ 0x66, 0x65, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75,
+ 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1f, 0x82, 0xd3, 0xe4, 0x93,
+ 0x02, 0x19, 0x32, 0x17, 0x2f, 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x2f, 0x61, 0x74, 0x74, 0x72,
+ 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0x98, 0x01, 0x0a, 0x13,
+ 0x52, 0x65, 0x61, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62,
+ 0x75, 0x74, 0x65, 0x12, 0x29, 0x2e, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x75, 0x6e, 0x73,
+ 0x61, 0x66, 0x65, 0x2e, 0x52, 0x65, 0x61, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x41, 0x74,
+ 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a,
+ 0x2e, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x2e, 0x52,
+ 0x65, 0x61, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75,
+ 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2a, 0x82, 0xd3, 0xe4, 0x93,
+ 0x02, 0x24, 0x22, 0x22, 0x2f, 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x2f, 0x61, 0x74, 0x74, 0x72,
+ 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x2f, 0x72, 0x65, 0x61, 0x63,
+ 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x12, 0x81, 0x01, 0x0a, 0x0f, 0x44, 0x65, 0x6c, 0x65, 0x74,
+ 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x12, 0x25, 0x2e, 0x70, 0x6f, 0x6c,
+ 0x69, 0x63, 0x79, 0x2e, 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74,
+ 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+ 0x74, 0x1a, 0x26, 0x2e, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x75, 0x6e, 0x73, 0x61, 0x66,
+ 0x65, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74,
+ 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1f, 0x82, 0xd3, 0xe4, 0x93, 0x02,
+ 0x19, 0x2a, 0x17, 0x2f, 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x2f, 0x61, 0x74, 0x74, 0x72, 0x69,
+ 0x62, 0x75, 0x74, 0x65, 0x73, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0x97, 0x01, 0x0a, 0x14, 0x55,
+ 0x70, 0x64, 0x61, 0x74, 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x56, 0x61,
+ 0x6c, 0x75, 0x65, 0x12, 0x2a, 0x2e, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x75, 0x6e, 0x73,
+ 0x61, 0x66, 0x65, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62,
+ 0x75, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+ 0x2b, 0x2e, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x2e,
+ 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x56,
+ 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0x82, 0xd3,
+ 0xe4, 0x93, 0x02, 0x20, 0x32, 0x1e, 0x2f, 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x2f, 0x61, 0x74,
+ 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x2f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x2f,
+ 0x7b, 0x69, 0x64, 0x7d, 0x12, 0xae, 0x01, 0x0a, 0x18, 0x52, 0x65, 0x61, 0x63, 0x74, 0x69, 0x76,
+ 0x61, 0x74, 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75,
+ 0x65, 0x12, 0x2e, 0x2e, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x75, 0x6e, 0x73, 0x61, 0x66,
+ 0x65, 0x2e, 0x52, 0x65, 0x61, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x41, 0x74, 0x74, 0x72,
+ 0x69, 0x62, 0x75, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+ 0x74, 0x1a, 0x2f, 0x2e, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x75, 0x6e, 0x73, 0x61, 0x66,
+ 0x65, 0x2e, 0x52, 0x65, 0x61, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x41, 0x74, 0x74, 0x72,
+ 0x69, 0x62, 0x75, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+ 0x73, 0x65, 0x22, 0x31, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2b, 0x22, 0x29, 0x2f, 0x75, 0x6e, 0x73,
+ 0x61, 0x66, 0x65, 0x2f, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x2f, 0x76,
+ 0x61, 0x6c, 0x75, 0x65, 0x73, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x2f, 0x72, 0x65, 0x61, 0x63, 0x74,
+ 0x69, 0x76, 0x61, 0x74, 0x65, 0x12, 0x97, 0x01, 0x0a, 0x14, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65,
+ 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x2a,
+ 0x2e, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x2e, 0x44,
+ 0x65, 0x6c, 0x65, 0x74, 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x56, 0x61,
+ 0x6c, 0x75, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x70, 0x6f, 0x6c,
+ 0x69, 0x63, 0x79, 0x2e, 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74,
+ 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52,
+ 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x20, 0x2a,
+ 0x1e, 0x2f, 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x2f, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75,
+ 0x74, 0x65, 0x73, 0x2f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x42,
+ 0xac, 0x01, 0x0a, 0x11, 0x63, 0x6f, 0x6d, 0x2e, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x75,
+ 0x6e, 0x73, 0x61, 0x66, 0x65, 0x42, 0x0b, 0x55, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x50, 0x72, 0x6f,
+ 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d,
+ 0x2f, 0x6f, 0x70, 0x65, 0x6e, 0x74, 0x64, 0x66, 0x2f, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72,
+ 0x6d, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x67, 0x6f, 0x2f, 0x70, 0x6f,
+ 0x6c, 0x69, 0x63, 0x79, 0x2f, 0x75, 0x6e, 0x73, 0x61, 0x66, 0x65, 0xa2, 0x02, 0x03, 0x50, 0x55,
+ 0x58, 0xaa, 0x02, 0x0d, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x55, 0x6e, 0x73, 0x61, 0x66,
+ 0x65, 0xca, 0x02, 0x0d, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x5c, 0x55, 0x6e, 0x73, 0x61, 0x66,
+ 0x65, 0xe2, 0x02, 0x19, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x5c, 0x55, 0x6e, 0x73, 0x61, 0x66,
+ 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0e,
+ 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x3a, 0x3a, 0x55, 0x6e, 0x73, 0x61, 0x66, 0x65, 0x62, 0x06,
+ 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+ file_policy_unsafe_unsafe_proto_rawDescOnce sync.Once
+ file_policy_unsafe_unsafe_proto_rawDescData = file_policy_unsafe_unsafe_proto_rawDesc
+)
+
+func file_policy_unsafe_unsafe_proto_rawDescGZIP() []byte {
+ file_policy_unsafe_unsafe_proto_rawDescOnce.Do(func() {
+ file_policy_unsafe_unsafe_proto_rawDescData = protoimpl.X.CompressGZIP(file_policy_unsafe_unsafe_proto_rawDescData)
+ })
+ return file_policy_unsafe_unsafe_proto_rawDescData
+}
+
+var file_policy_unsafe_unsafe_proto_msgTypes = make([]protoimpl.MessageInfo, 18)
+var file_policy_unsafe_unsafe_proto_goTypes = []interface{}{
+ (*UpdateNamespaceRequest)(nil), // 0: policy.unsafe.UpdateNamespaceRequest
+ (*UpdateNamespaceResponse)(nil), // 1: policy.unsafe.UpdateNamespaceResponse
+ (*ReactivateNamespaceRequest)(nil), // 2: policy.unsafe.ReactivateNamespaceRequest
+ (*ReactivateNamespaceResponse)(nil), // 3: policy.unsafe.ReactivateNamespaceResponse
+ (*DeleteNamespaceRequest)(nil), // 4: policy.unsafe.DeleteNamespaceRequest
+ (*DeleteNamespaceResponse)(nil), // 5: policy.unsafe.DeleteNamespaceResponse
+ (*UpdateAttributeRequest)(nil), // 6: policy.unsafe.UpdateAttributeRequest
+ (*UpdateAttributeResponse)(nil), // 7: policy.unsafe.UpdateAttributeResponse
+ (*ReactivateAttributeRequest)(nil), // 8: policy.unsafe.ReactivateAttributeRequest
+ (*ReactivateAttributeResponse)(nil), // 9: policy.unsafe.ReactivateAttributeResponse
+ (*DeleteAttributeRequest)(nil), // 10: policy.unsafe.DeleteAttributeRequest
+ (*DeleteAttributeResponse)(nil), // 11: policy.unsafe.DeleteAttributeResponse
+ (*UpdateAttributeValueRequest)(nil), // 12: policy.unsafe.UpdateAttributeValueRequest
+ (*UpdateAttributeValueResponse)(nil), // 13: policy.unsafe.UpdateAttributeValueResponse
+ (*ReactivateAttributeValueRequest)(nil), // 14: policy.unsafe.ReactivateAttributeValueRequest
+ (*ReactivateAttributeValueResponse)(nil), // 15: policy.unsafe.ReactivateAttributeValueResponse
+ (*DeleteAttributeValueRequest)(nil), // 16: policy.unsafe.DeleteAttributeValueRequest
+ (*DeleteAttributeValueResponse)(nil), // 17: policy.unsafe.DeleteAttributeValueResponse
+ (*policy.Namespace)(nil), // 18: policy.Namespace
+ (policy.AttributeRuleTypeEnum)(0), // 19: policy.AttributeRuleTypeEnum
+ (*policy.Attribute)(nil), // 20: policy.Attribute
+ (*policy.Value)(nil), // 21: policy.Value
+}
+var file_policy_unsafe_unsafe_proto_depIdxs = []int32{
+ 18, // 0: policy.unsafe.UpdateNamespaceResponse.namespace:type_name -> policy.Namespace
+ 18, // 1: policy.unsafe.ReactivateNamespaceResponse.namespace:type_name -> policy.Namespace
+ 18, // 2: policy.unsafe.DeleteNamespaceResponse.namespace:type_name -> policy.Namespace
+ 19, // 3: policy.unsafe.UpdateAttributeRequest.rule:type_name -> policy.AttributeRuleTypeEnum
+ 20, // 4: policy.unsafe.UpdateAttributeResponse.attribute:type_name -> policy.Attribute
+ 20, // 5: policy.unsafe.ReactivateAttributeResponse.attribute:type_name -> policy.Attribute
+ 20, // 6: policy.unsafe.DeleteAttributeResponse.attribute:type_name -> policy.Attribute
+ 21, // 7: policy.unsafe.UpdateAttributeValueResponse.value:type_name -> policy.Value
+ 21, // 8: policy.unsafe.ReactivateAttributeValueResponse.value:type_name -> policy.Value
+ 21, // 9: policy.unsafe.DeleteAttributeValueResponse.value:type_name -> policy.Value
+ 0, // 10: policy.unsafe.UnsafeService.UpdateNamespace:input_type -> policy.unsafe.UpdateNamespaceRequest
+ 2, // 11: policy.unsafe.UnsafeService.ReactivateNamespace:input_type -> policy.unsafe.ReactivateNamespaceRequest
+ 4, // 12: policy.unsafe.UnsafeService.DeleteNamespace:input_type -> policy.unsafe.DeleteNamespaceRequest
+ 6, // 13: policy.unsafe.UnsafeService.UpdateAttribute:input_type -> policy.unsafe.UpdateAttributeRequest
+ 8, // 14: policy.unsafe.UnsafeService.ReactivateAttribute:input_type -> policy.unsafe.ReactivateAttributeRequest
+ 10, // 15: policy.unsafe.UnsafeService.DeleteAttribute:input_type -> policy.unsafe.DeleteAttributeRequest
+ 12, // 16: policy.unsafe.UnsafeService.UpdateAttributeValue:input_type -> policy.unsafe.UpdateAttributeValueRequest
+ 14, // 17: policy.unsafe.UnsafeService.ReactivateAttributeValue:input_type -> policy.unsafe.ReactivateAttributeValueRequest
+ 16, // 18: policy.unsafe.UnsafeService.DeleteAttributeValue:input_type -> policy.unsafe.DeleteAttributeValueRequest
+ 1, // 19: policy.unsafe.UnsafeService.UpdateNamespace:output_type -> policy.unsafe.UpdateNamespaceResponse
+ 3, // 20: policy.unsafe.UnsafeService.ReactivateNamespace:output_type -> policy.unsafe.ReactivateNamespaceResponse
+ 5, // 21: policy.unsafe.UnsafeService.DeleteNamespace:output_type -> policy.unsafe.DeleteNamespaceResponse
+ 7, // 22: policy.unsafe.UnsafeService.UpdateAttribute:output_type -> policy.unsafe.UpdateAttributeResponse
+ 9, // 23: policy.unsafe.UnsafeService.ReactivateAttribute:output_type -> policy.unsafe.ReactivateAttributeResponse
+ 11, // 24: policy.unsafe.UnsafeService.DeleteAttribute:output_type -> policy.unsafe.DeleteAttributeResponse
+ 13, // 25: policy.unsafe.UnsafeService.UpdateAttributeValue:output_type -> policy.unsafe.UpdateAttributeValueResponse
+ 15, // 26: policy.unsafe.UnsafeService.ReactivateAttributeValue:output_type -> policy.unsafe.ReactivateAttributeValueResponse
+ 17, // 27: policy.unsafe.UnsafeService.DeleteAttributeValue:output_type -> policy.unsafe.DeleteAttributeValueResponse
+ 19, // [19:28] is the sub-list for method output_type
+ 10, // [10:19] is the sub-list for method input_type
+ 10, // [10:10] is the sub-list for extension type_name
+ 10, // [10:10] is the sub-list for extension extendee
+ 0, // [0:10] is the sub-list for field type_name
+}
+
+func init() { file_policy_unsafe_unsafe_proto_init() }
+func file_policy_unsafe_unsafe_proto_init() {
+ if File_policy_unsafe_unsafe_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_policy_unsafe_unsafe_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*UpdateNamespaceRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_policy_unsafe_unsafe_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*UpdateNamespaceResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_policy_unsafe_unsafe_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*ReactivateNamespaceRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_policy_unsafe_unsafe_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*ReactivateNamespaceResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_policy_unsafe_unsafe_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*DeleteNamespaceRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_policy_unsafe_unsafe_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*DeleteNamespaceResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_policy_unsafe_unsafe_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*UpdateAttributeRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_policy_unsafe_unsafe_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*UpdateAttributeResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_policy_unsafe_unsafe_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*ReactivateAttributeRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_policy_unsafe_unsafe_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*ReactivateAttributeResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_policy_unsafe_unsafe_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*DeleteAttributeRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_policy_unsafe_unsafe_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*DeleteAttributeResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_policy_unsafe_unsafe_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*UpdateAttributeValueRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_policy_unsafe_unsafe_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*UpdateAttributeValueResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_policy_unsafe_unsafe_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*ReactivateAttributeValueRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_policy_unsafe_unsafe_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*ReactivateAttributeValueResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_policy_unsafe_unsafe_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*DeleteAttributeValueRequest); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_policy_unsafe_unsafe_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*DeleteAttributeValueResponse); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ }
+ type x struct{}
+ out := protoimpl.TypeBuilder{
+ File: protoimpl.DescBuilder{
+ GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+ RawDescriptor: file_policy_unsafe_unsafe_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 18,
+ NumExtensions: 0,
+ NumServices: 1,
+ },
+ GoTypes: file_policy_unsafe_unsafe_proto_goTypes,
+ DependencyIndexes: file_policy_unsafe_unsafe_proto_depIdxs,
+ MessageInfos: file_policy_unsafe_unsafe_proto_msgTypes,
+ }.Build()
+ File_policy_unsafe_unsafe_proto = out.File
+ file_policy_unsafe_unsafe_proto_rawDesc = nil
+ file_policy_unsafe_unsafe_proto_goTypes = nil
+ file_policy_unsafe_unsafe_proto_depIdxs = nil
+}
diff --git a/protocol/go/policy/unsafe/unsafe.pb.gw.go b/protocol/go/policy/unsafe/unsafe.pb.gw.go
new file mode 100644
index 000000000..a13439fe3
--- /dev/null
+++ b/protocol/go/policy/unsafe/unsafe.pb.gw.go
@@ -0,0 +1,1121 @@
+// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
+// source: policy/unsafe/unsafe.proto
+
+/*
+Package unsafe is a reverse proxy.
+
+It translates gRPC into RESTful JSON APIs.
+*/
+package unsafe
+
+import (
+ "context"
+ "io"
+ "net/http"
+
+ "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
+ "github.com/grpc-ecosystem/grpc-gateway/v2/utilities"
+ "google.golang.org/grpc"
+ "google.golang.org/grpc/codes"
+ "google.golang.org/grpc/grpclog"
+ "google.golang.org/grpc/metadata"
+ "google.golang.org/grpc/status"
+ "google.golang.org/protobuf/proto"
+)
+
+// Suppress "imported and not used" errors
+var _ codes.Code
+var _ io.Reader
+var _ status.Status
+var _ = runtime.String
+var _ = utilities.NewDoubleArray
+var _ = metadata.Join
+
+var (
+ filter_UnsafeService_UpdateNamespace_0 = &utilities.DoubleArray{Encoding: map[string]int{"id": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
+)
+
+func request_UnsafeService_UpdateNamespace_0(ctx context.Context, marshaler runtime.Marshaler, client UnsafeServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+ var protoReq UpdateNamespaceRequest
+ var metadata runtime.ServerMetadata
+
+ var (
+ val string
+ ok bool
+ err error
+ _ = err
+ )
+
+ val, ok = pathParams["id"]
+ if !ok {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
+ }
+
+ protoReq.Id, err = runtime.String(val)
+ if err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
+ }
+
+ if err := req.ParseForm(); err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+ }
+ if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_UnsafeService_UpdateNamespace_0); err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+ }
+
+ msg, err := client.UpdateNamespace(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+ return msg, metadata, err
+
+}
+
+func local_request_UnsafeService_UpdateNamespace_0(ctx context.Context, marshaler runtime.Marshaler, server UnsafeServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+ var protoReq UpdateNamespaceRequest
+ var metadata runtime.ServerMetadata
+
+ var (
+ val string
+ ok bool
+ err error
+ _ = err
+ )
+
+ val, ok = pathParams["id"]
+ if !ok {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
+ }
+
+ protoReq.Id, err = runtime.String(val)
+ if err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
+ }
+
+ if err := req.ParseForm(); err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+ }
+ if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_UnsafeService_UpdateNamespace_0); err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+ }
+
+ msg, err := server.UpdateNamespace(ctx, &protoReq)
+ return msg, metadata, err
+
+}
+
+func request_UnsafeService_ReactivateNamespace_0(ctx context.Context, marshaler runtime.Marshaler, client UnsafeServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+ var protoReq ReactivateNamespaceRequest
+ var metadata runtime.ServerMetadata
+
+ var (
+ val string
+ ok bool
+ err error
+ _ = err
+ )
+
+ val, ok = pathParams["id"]
+ if !ok {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
+ }
+
+ protoReq.Id, err = runtime.String(val)
+ if err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
+ }
+
+ msg, err := client.ReactivateNamespace(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+ return msg, metadata, err
+
+}
+
+func local_request_UnsafeService_ReactivateNamespace_0(ctx context.Context, marshaler runtime.Marshaler, server UnsafeServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+ var protoReq ReactivateNamespaceRequest
+ var metadata runtime.ServerMetadata
+
+ var (
+ val string
+ ok bool
+ err error
+ _ = err
+ )
+
+ val, ok = pathParams["id"]
+ if !ok {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
+ }
+
+ protoReq.Id, err = runtime.String(val)
+ if err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
+ }
+
+ msg, err := server.ReactivateNamespace(ctx, &protoReq)
+ return msg, metadata, err
+
+}
+
+var (
+ filter_UnsafeService_DeleteNamespace_0 = &utilities.DoubleArray{Encoding: map[string]int{"id": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
+)
+
+func request_UnsafeService_DeleteNamespace_0(ctx context.Context, marshaler runtime.Marshaler, client UnsafeServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+ var protoReq DeleteNamespaceRequest
+ var metadata runtime.ServerMetadata
+
+ var (
+ val string
+ ok bool
+ err error
+ _ = err
+ )
+
+ val, ok = pathParams["id"]
+ if !ok {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
+ }
+
+ protoReq.Id, err = runtime.String(val)
+ if err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
+ }
+
+ if err := req.ParseForm(); err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+ }
+ if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_UnsafeService_DeleteNamespace_0); err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+ }
+
+ msg, err := client.DeleteNamespace(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+ return msg, metadata, err
+
+}
+
+func local_request_UnsafeService_DeleteNamespace_0(ctx context.Context, marshaler runtime.Marshaler, server UnsafeServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+ var protoReq DeleteNamespaceRequest
+ var metadata runtime.ServerMetadata
+
+ var (
+ val string
+ ok bool
+ err error
+ _ = err
+ )
+
+ val, ok = pathParams["id"]
+ if !ok {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
+ }
+
+ protoReq.Id, err = runtime.String(val)
+ if err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
+ }
+
+ if err := req.ParseForm(); err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+ }
+ if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_UnsafeService_DeleteNamespace_0); err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+ }
+
+ msg, err := server.DeleteNamespace(ctx, &protoReq)
+ return msg, metadata, err
+
+}
+
+var (
+ filter_UnsafeService_UpdateAttribute_0 = &utilities.DoubleArray{Encoding: map[string]int{"id": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
+)
+
+func request_UnsafeService_UpdateAttribute_0(ctx context.Context, marshaler runtime.Marshaler, client UnsafeServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+ var protoReq UpdateAttributeRequest
+ var metadata runtime.ServerMetadata
+
+ var (
+ val string
+ ok bool
+ err error
+ _ = err
+ )
+
+ val, ok = pathParams["id"]
+ if !ok {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
+ }
+
+ protoReq.Id, err = runtime.String(val)
+ if err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
+ }
+
+ if err := req.ParseForm(); err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+ }
+ if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_UnsafeService_UpdateAttribute_0); err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+ }
+
+ msg, err := client.UpdateAttribute(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+ return msg, metadata, err
+
+}
+
+func local_request_UnsafeService_UpdateAttribute_0(ctx context.Context, marshaler runtime.Marshaler, server UnsafeServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+ var protoReq UpdateAttributeRequest
+ var metadata runtime.ServerMetadata
+
+ var (
+ val string
+ ok bool
+ err error
+ _ = err
+ )
+
+ val, ok = pathParams["id"]
+ if !ok {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
+ }
+
+ protoReq.Id, err = runtime.String(val)
+ if err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
+ }
+
+ if err := req.ParseForm(); err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+ }
+ if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_UnsafeService_UpdateAttribute_0); err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+ }
+
+ msg, err := server.UpdateAttribute(ctx, &protoReq)
+ return msg, metadata, err
+
+}
+
+func request_UnsafeService_ReactivateAttribute_0(ctx context.Context, marshaler runtime.Marshaler, client UnsafeServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+ var protoReq ReactivateAttributeRequest
+ var metadata runtime.ServerMetadata
+
+ var (
+ val string
+ ok bool
+ err error
+ _ = err
+ )
+
+ val, ok = pathParams["id"]
+ if !ok {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
+ }
+
+ protoReq.Id, err = runtime.String(val)
+ if err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
+ }
+
+ msg, err := client.ReactivateAttribute(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+ return msg, metadata, err
+
+}
+
+func local_request_UnsafeService_ReactivateAttribute_0(ctx context.Context, marshaler runtime.Marshaler, server UnsafeServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+ var protoReq ReactivateAttributeRequest
+ var metadata runtime.ServerMetadata
+
+ var (
+ val string
+ ok bool
+ err error
+ _ = err
+ )
+
+ val, ok = pathParams["id"]
+ if !ok {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
+ }
+
+ protoReq.Id, err = runtime.String(val)
+ if err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
+ }
+
+ msg, err := server.ReactivateAttribute(ctx, &protoReq)
+ return msg, metadata, err
+
+}
+
+var (
+ filter_UnsafeService_DeleteAttribute_0 = &utilities.DoubleArray{Encoding: map[string]int{"id": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
+)
+
+func request_UnsafeService_DeleteAttribute_0(ctx context.Context, marshaler runtime.Marshaler, client UnsafeServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+ var protoReq DeleteAttributeRequest
+ var metadata runtime.ServerMetadata
+
+ var (
+ val string
+ ok bool
+ err error
+ _ = err
+ )
+
+ val, ok = pathParams["id"]
+ if !ok {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
+ }
+
+ protoReq.Id, err = runtime.String(val)
+ if err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
+ }
+
+ if err := req.ParseForm(); err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+ }
+ if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_UnsafeService_DeleteAttribute_0); err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+ }
+
+ msg, err := client.DeleteAttribute(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+ return msg, metadata, err
+
+}
+
+func local_request_UnsafeService_DeleteAttribute_0(ctx context.Context, marshaler runtime.Marshaler, server UnsafeServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+ var protoReq DeleteAttributeRequest
+ var metadata runtime.ServerMetadata
+
+ var (
+ val string
+ ok bool
+ err error
+ _ = err
+ )
+
+ val, ok = pathParams["id"]
+ if !ok {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
+ }
+
+ protoReq.Id, err = runtime.String(val)
+ if err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
+ }
+
+ if err := req.ParseForm(); err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+ }
+ if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_UnsafeService_DeleteAttribute_0); err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+ }
+
+ msg, err := server.DeleteAttribute(ctx, &protoReq)
+ return msg, metadata, err
+
+}
+
+var (
+ filter_UnsafeService_UpdateAttributeValue_0 = &utilities.DoubleArray{Encoding: map[string]int{"id": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
+)
+
+func request_UnsafeService_UpdateAttributeValue_0(ctx context.Context, marshaler runtime.Marshaler, client UnsafeServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+ var protoReq UpdateAttributeValueRequest
+ var metadata runtime.ServerMetadata
+
+ var (
+ val string
+ ok bool
+ err error
+ _ = err
+ )
+
+ val, ok = pathParams["id"]
+ if !ok {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
+ }
+
+ protoReq.Id, err = runtime.String(val)
+ if err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
+ }
+
+ if err := req.ParseForm(); err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+ }
+ if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_UnsafeService_UpdateAttributeValue_0); err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+ }
+
+ msg, err := client.UpdateAttributeValue(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+ return msg, metadata, err
+
+}
+
+func local_request_UnsafeService_UpdateAttributeValue_0(ctx context.Context, marshaler runtime.Marshaler, server UnsafeServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+ var protoReq UpdateAttributeValueRequest
+ var metadata runtime.ServerMetadata
+
+ var (
+ val string
+ ok bool
+ err error
+ _ = err
+ )
+
+ val, ok = pathParams["id"]
+ if !ok {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
+ }
+
+ protoReq.Id, err = runtime.String(val)
+ if err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
+ }
+
+ if err := req.ParseForm(); err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+ }
+ if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_UnsafeService_UpdateAttributeValue_0); err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+ }
+
+ msg, err := server.UpdateAttributeValue(ctx, &protoReq)
+ return msg, metadata, err
+
+}
+
+func request_UnsafeService_ReactivateAttributeValue_0(ctx context.Context, marshaler runtime.Marshaler, client UnsafeServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+ var protoReq ReactivateAttributeValueRequest
+ var metadata runtime.ServerMetadata
+
+ var (
+ val string
+ ok bool
+ err error
+ _ = err
+ )
+
+ val, ok = pathParams["id"]
+ if !ok {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
+ }
+
+ protoReq.Id, err = runtime.String(val)
+ if err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
+ }
+
+ msg, err := client.ReactivateAttributeValue(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+ return msg, metadata, err
+
+}
+
+func local_request_UnsafeService_ReactivateAttributeValue_0(ctx context.Context, marshaler runtime.Marshaler, server UnsafeServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+ var protoReq ReactivateAttributeValueRequest
+ var metadata runtime.ServerMetadata
+
+ var (
+ val string
+ ok bool
+ err error
+ _ = err
+ )
+
+ val, ok = pathParams["id"]
+ if !ok {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
+ }
+
+ protoReq.Id, err = runtime.String(val)
+ if err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
+ }
+
+ msg, err := server.ReactivateAttributeValue(ctx, &protoReq)
+ return msg, metadata, err
+
+}
+
+var (
+ filter_UnsafeService_DeleteAttributeValue_0 = &utilities.DoubleArray{Encoding: map[string]int{"id": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
+)
+
+func request_UnsafeService_DeleteAttributeValue_0(ctx context.Context, marshaler runtime.Marshaler, client UnsafeServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+ var protoReq DeleteAttributeValueRequest
+ var metadata runtime.ServerMetadata
+
+ var (
+ val string
+ ok bool
+ err error
+ _ = err
+ )
+
+ val, ok = pathParams["id"]
+ if !ok {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
+ }
+
+ protoReq.Id, err = runtime.String(val)
+ if err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
+ }
+
+ if err := req.ParseForm(); err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+ }
+ if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_UnsafeService_DeleteAttributeValue_0); err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+ }
+
+ msg, err := client.DeleteAttributeValue(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+ return msg, metadata, err
+
+}
+
+func local_request_UnsafeService_DeleteAttributeValue_0(ctx context.Context, marshaler runtime.Marshaler, server UnsafeServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+ var protoReq DeleteAttributeValueRequest
+ var metadata runtime.ServerMetadata
+
+ var (
+ val string
+ ok bool
+ err error
+ _ = err
+ )
+
+ val, ok = pathParams["id"]
+ if !ok {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
+ }
+
+ protoReq.Id, err = runtime.String(val)
+ if err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
+ }
+
+ if err := req.ParseForm(); err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+ }
+ if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_UnsafeService_DeleteAttributeValue_0); err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+ }
+
+ msg, err := server.DeleteAttributeValue(ctx, &protoReq)
+ return msg, metadata, err
+
+}
+
+// RegisterUnsafeServiceHandlerServer registers the http handlers for service UnsafeService to "mux".
+// UnaryRPC :call UnsafeServiceServer directly.
+// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
+// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterUnsafeServiceHandlerFromEndpoint instead.
+func RegisterUnsafeServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server UnsafeServiceServer) error {
+
+ mux.Handle("PATCH", pattern_UnsafeService_UpdateNamespace_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+ ctx, cancel := context.WithCancel(req.Context())
+ defer cancel()
+ var stream runtime.ServerTransportStream
+ ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+ var err error
+ var annotatedContext context.Context
+ annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/policy.unsafe.UnsafeService/UpdateNamespace", runtime.WithHTTPPathPattern("/unsafe/namespaces/{id}"))
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+ resp, md, err := local_request_UnsafeService_UpdateNamespace_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+ md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+ annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+ if err != nil {
+ runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+ return
+ }
+
+ forward_UnsafeService_UpdateNamespace_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+ })
+
+ mux.Handle("POST", pattern_UnsafeService_ReactivateNamespace_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+ ctx, cancel := context.WithCancel(req.Context())
+ defer cancel()
+ var stream runtime.ServerTransportStream
+ ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+ var err error
+ var annotatedContext context.Context
+ annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/policy.unsafe.UnsafeService/ReactivateNamespace", runtime.WithHTTPPathPattern("/unsafe/namespaces/{id}/reactivate"))
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+ resp, md, err := local_request_UnsafeService_ReactivateNamespace_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+ md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+ annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+ if err != nil {
+ runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+ return
+ }
+
+ forward_UnsafeService_ReactivateNamespace_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+ })
+
+ mux.Handle("DELETE", pattern_UnsafeService_DeleteNamespace_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+ ctx, cancel := context.WithCancel(req.Context())
+ defer cancel()
+ var stream runtime.ServerTransportStream
+ ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+ var err error
+ var annotatedContext context.Context
+ annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/policy.unsafe.UnsafeService/DeleteNamespace", runtime.WithHTTPPathPattern("/unsafe/namespaces/{id}"))
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+ resp, md, err := local_request_UnsafeService_DeleteNamespace_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+ md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+ annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+ if err != nil {
+ runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+ return
+ }
+
+ forward_UnsafeService_DeleteNamespace_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+ })
+
+ mux.Handle("PATCH", pattern_UnsafeService_UpdateAttribute_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+ ctx, cancel := context.WithCancel(req.Context())
+ defer cancel()
+ var stream runtime.ServerTransportStream
+ ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+ var err error
+ var annotatedContext context.Context
+ annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/policy.unsafe.UnsafeService/UpdateAttribute", runtime.WithHTTPPathPattern("/unsafe/attributes/{id}"))
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+ resp, md, err := local_request_UnsafeService_UpdateAttribute_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+ md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+ annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+ if err != nil {
+ runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+ return
+ }
+
+ forward_UnsafeService_UpdateAttribute_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+ })
+
+ mux.Handle("POST", pattern_UnsafeService_ReactivateAttribute_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+ ctx, cancel := context.WithCancel(req.Context())
+ defer cancel()
+ var stream runtime.ServerTransportStream
+ ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+ var err error
+ var annotatedContext context.Context
+ annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/policy.unsafe.UnsafeService/ReactivateAttribute", runtime.WithHTTPPathPattern("/unsafe/attributes/{id}/reactivate"))
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+ resp, md, err := local_request_UnsafeService_ReactivateAttribute_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+ md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+ annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+ if err != nil {
+ runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+ return
+ }
+
+ forward_UnsafeService_ReactivateAttribute_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+ })
+
+ mux.Handle("DELETE", pattern_UnsafeService_DeleteAttribute_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+ ctx, cancel := context.WithCancel(req.Context())
+ defer cancel()
+ var stream runtime.ServerTransportStream
+ ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+ var err error
+ var annotatedContext context.Context
+ annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/policy.unsafe.UnsafeService/DeleteAttribute", runtime.WithHTTPPathPattern("/unsafe/attributes/{id}"))
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+ resp, md, err := local_request_UnsafeService_DeleteAttribute_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+ md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+ annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+ if err != nil {
+ runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+ return
+ }
+
+ forward_UnsafeService_DeleteAttribute_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+ })
+
+ mux.Handle("PATCH", pattern_UnsafeService_UpdateAttributeValue_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+ ctx, cancel := context.WithCancel(req.Context())
+ defer cancel()
+ var stream runtime.ServerTransportStream
+ ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+ var err error
+ var annotatedContext context.Context
+ annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/policy.unsafe.UnsafeService/UpdateAttributeValue", runtime.WithHTTPPathPattern("/unsafe/attributes/values/{id}"))
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+ resp, md, err := local_request_UnsafeService_UpdateAttributeValue_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+ md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+ annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+ if err != nil {
+ runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+ return
+ }
+
+ forward_UnsafeService_UpdateAttributeValue_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+ })
+
+ mux.Handle("POST", pattern_UnsafeService_ReactivateAttributeValue_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+ ctx, cancel := context.WithCancel(req.Context())
+ defer cancel()
+ var stream runtime.ServerTransportStream
+ ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+ var err error
+ var annotatedContext context.Context
+ annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/policy.unsafe.UnsafeService/ReactivateAttributeValue", runtime.WithHTTPPathPattern("/unsafe/attributes/values/{id}/reactivate"))
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+ resp, md, err := local_request_UnsafeService_ReactivateAttributeValue_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+ md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+ annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+ if err != nil {
+ runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+ return
+ }
+
+ forward_UnsafeService_ReactivateAttributeValue_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+ })
+
+ mux.Handle("DELETE", pattern_UnsafeService_DeleteAttributeValue_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+ ctx, cancel := context.WithCancel(req.Context())
+ defer cancel()
+ var stream runtime.ServerTransportStream
+ ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+ var err error
+ var annotatedContext context.Context
+ annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/policy.unsafe.UnsafeService/DeleteAttributeValue", runtime.WithHTTPPathPattern("/unsafe/attributes/values/{id}"))
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+ resp, md, err := local_request_UnsafeService_DeleteAttributeValue_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+ md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+ annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+ if err != nil {
+ runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+ return
+ }
+
+ forward_UnsafeService_DeleteAttributeValue_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+ })
+
+ return nil
+}
+
+// RegisterUnsafeServiceHandlerFromEndpoint is same as RegisterUnsafeServiceHandler but
+// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
+func RegisterUnsafeServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
+ conn, err := grpc.DialContext(ctx, endpoint, opts...)
+ if err != nil {
+ return err
+ }
+ defer func() {
+ if err != nil {
+ if cerr := conn.Close(); cerr != nil {
+ grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
+ }
+ return
+ }
+ go func() {
+ <-ctx.Done()
+ if cerr := conn.Close(); cerr != nil {
+ grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
+ }
+ }()
+ }()
+
+ return RegisterUnsafeServiceHandler(ctx, mux, conn)
+}
+
+// RegisterUnsafeServiceHandler registers the http handlers for service UnsafeService to "mux".
+// The handlers forward requests to the grpc endpoint over "conn".
+func RegisterUnsafeServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
+ return RegisterUnsafeServiceHandlerClient(ctx, mux, NewUnsafeServiceClient(conn))
+}
+
+// RegisterUnsafeServiceHandlerClient registers the http handlers for service UnsafeService
+// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "UnsafeServiceClient".
+// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "UnsafeServiceClient"
+// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
+// "UnsafeServiceClient" to call the correct interceptors.
+func RegisterUnsafeServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client UnsafeServiceClient) error {
+
+ mux.Handle("PATCH", pattern_UnsafeService_UpdateNamespace_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+ ctx, cancel := context.WithCancel(req.Context())
+ defer cancel()
+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+ var err error
+ var annotatedContext context.Context
+ annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/policy.unsafe.UnsafeService/UpdateNamespace", runtime.WithHTTPPathPattern("/unsafe/namespaces/{id}"))
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+ resp, md, err := request_UnsafeService_UpdateNamespace_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+ annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+ if err != nil {
+ runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+ return
+ }
+
+ forward_UnsafeService_UpdateNamespace_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+ })
+
+ mux.Handle("POST", pattern_UnsafeService_ReactivateNamespace_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+ ctx, cancel := context.WithCancel(req.Context())
+ defer cancel()
+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+ var err error
+ var annotatedContext context.Context
+ annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/policy.unsafe.UnsafeService/ReactivateNamespace", runtime.WithHTTPPathPattern("/unsafe/namespaces/{id}/reactivate"))
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+ resp, md, err := request_UnsafeService_ReactivateNamespace_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+ annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+ if err != nil {
+ runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+ return
+ }
+
+ forward_UnsafeService_ReactivateNamespace_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+ })
+
+ mux.Handle("DELETE", pattern_UnsafeService_DeleteNamespace_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+ ctx, cancel := context.WithCancel(req.Context())
+ defer cancel()
+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+ var err error
+ var annotatedContext context.Context
+ annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/policy.unsafe.UnsafeService/DeleteNamespace", runtime.WithHTTPPathPattern("/unsafe/namespaces/{id}"))
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+ resp, md, err := request_UnsafeService_DeleteNamespace_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+ annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+ if err != nil {
+ runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+ return
+ }
+
+ forward_UnsafeService_DeleteNamespace_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+ })
+
+ mux.Handle("PATCH", pattern_UnsafeService_UpdateAttribute_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+ ctx, cancel := context.WithCancel(req.Context())
+ defer cancel()
+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+ var err error
+ var annotatedContext context.Context
+ annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/policy.unsafe.UnsafeService/UpdateAttribute", runtime.WithHTTPPathPattern("/unsafe/attributes/{id}"))
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+ resp, md, err := request_UnsafeService_UpdateAttribute_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+ annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+ if err != nil {
+ runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+ return
+ }
+
+ forward_UnsafeService_UpdateAttribute_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+ })
+
+ mux.Handle("POST", pattern_UnsafeService_ReactivateAttribute_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+ ctx, cancel := context.WithCancel(req.Context())
+ defer cancel()
+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+ var err error
+ var annotatedContext context.Context
+ annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/policy.unsafe.UnsafeService/ReactivateAttribute", runtime.WithHTTPPathPattern("/unsafe/attributes/{id}/reactivate"))
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+ resp, md, err := request_UnsafeService_ReactivateAttribute_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+ annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+ if err != nil {
+ runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+ return
+ }
+
+ forward_UnsafeService_ReactivateAttribute_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+ })
+
+ mux.Handle("DELETE", pattern_UnsafeService_DeleteAttribute_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+ ctx, cancel := context.WithCancel(req.Context())
+ defer cancel()
+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+ var err error
+ var annotatedContext context.Context
+ annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/policy.unsafe.UnsafeService/DeleteAttribute", runtime.WithHTTPPathPattern("/unsafe/attributes/{id}"))
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+ resp, md, err := request_UnsafeService_DeleteAttribute_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+ annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+ if err != nil {
+ runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+ return
+ }
+
+ forward_UnsafeService_DeleteAttribute_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+ })
+
+ mux.Handle("PATCH", pattern_UnsafeService_UpdateAttributeValue_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+ ctx, cancel := context.WithCancel(req.Context())
+ defer cancel()
+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+ var err error
+ var annotatedContext context.Context
+ annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/policy.unsafe.UnsafeService/UpdateAttributeValue", runtime.WithHTTPPathPattern("/unsafe/attributes/values/{id}"))
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+ resp, md, err := request_UnsafeService_UpdateAttributeValue_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+ annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+ if err != nil {
+ runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+ return
+ }
+
+ forward_UnsafeService_UpdateAttributeValue_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+ })
+
+ mux.Handle("POST", pattern_UnsafeService_ReactivateAttributeValue_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+ ctx, cancel := context.WithCancel(req.Context())
+ defer cancel()
+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+ var err error
+ var annotatedContext context.Context
+ annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/policy.unsafe.UnsafeService/ReactivateAttributeValue", runtime.WithHTTPPathPattern("/unsafe/attributes/values/{id}/reactivate"))
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+ resp, md, err := request_UnsafeService_ReactivateAttributeValue_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+ annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+ if err != nil {
+ runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+ return
+ }
+
+ forward_UnsafeService_ReactivateAttributeValue_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+ })
+
+ mux.Handle("DELETE", pattern_UnsafeService_DeleteAttributeValue_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+ ctx, cancel := context.WithCancel(req.Context())
+ defer cancel()
+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+ var err error
+ var annotatedContext context.Context
+ annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/policy.unsafe.UnsafeService/DeleteAttributeValue", runtime.WithHTTPPathPattern("/unsafe/attributes/values/{id}"))
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+ resp, md, err := request_UnsafeService_DeleteAttributeValue_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+ annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+ if err != nil {
+ runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+ return
+ }
+
+ forward_UnsafeService_DeleteAttributeValue_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+ })
+
+ return nil
+}
+
+var (
+ pattern_UnsafeService_UpdateNamespace_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"unsafe", "namespaces", "id"}, ""))
+
+ pattern_UnsafeService_ReactivateNamespace_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3}, []string{"unsafe", "namespaces", "id", "reactivate"}, ""))
+
+ pattern_UnsafeService_DeleteNamespace_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"unsafe", "namespaces", "id"}, ""))
+
+ pattern_UnsafeService_UpdateAttribute_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"unsafe", "attributes", "id"}, ""))
+
+ pattern_UnsafeService_ReactivateAttribute_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3}, []string{"unsafe", "attributes", "id", "reactivate"}, ""))
+
+ pattern_UnsafeService_DeleteAttribute_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"unsafe", "attributes", "id"}, ""))
+
+ pattern_UnsafeService_UpdateAttributeValue_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"unsafe", "attributes", "values", "id"}, ""))
+
+ pattern_UnsafeService_ReactivateAttributeValue_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"unsafe", "attributes", "values", "id", "reactivate"}, ""))
+
+ pattern_UnsafeService_DeleteAttributeValue_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"unsafe", "attributes", "values", "id"}, ""))
+)
+
+var (
+ forward_UnsafeService_UpdateNamespace_0 = runtime.ForwardResponseMessage
+
+ forward_UnsafeService_ReactivateNamespace_0 = runtime.ForwardResponseMessage
+
+ forward_UnsafeService_DeleteNamespace_0 = runtime.ForwardResponseMessage
+
+ forward_UnsafeService_UpdateAttribute_0 = runtime.ForwardResponseMessage
+
+ forward_UnsafeService_ReactivateAttribute_0 = runtime.ForwardResponseMessage
+
+ forward_UnsafeService_DeleteAttribute_0 = runtime.ForwardResponseMessage
+
+ forward_UnsafeService_UpdateAttributeValue_0 = runtime.ForwardResponseMessage
+
+ forward_UnsafeService_ReactivateAttributeValue_0 = runtime.ForwardResponseMessage
+
+ forward_UnsafeService_DeleteAttributeValue_0 = runtime.ForwardResponseMessage
+)
diff --git a/protocol/go/policy/unsafe/unsafe_grpc.pb.go b/protocol/go/policy/unsafe/unsafe_grpc.pb.go
new file mode 100644
index 000000000..bfbe8ad6f
--- /dev/null
+++ b/protocol/go/policy/unsafe/unsafe_grpc.pb.go
@@ -0,0 +1,423 @@
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.3.0
+// - protoc (unknown)
+// source: policy/unsafe/unsafe.proto
+
+package unsafe
+
+import (
+ context "context"
+ grpc "google.golang.org/grpc"
+ codes "google.golang.org/grpc/codes"
+ status "google.golang.org/grpc/status"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.32.0 or later.
+const _ = grpc.SupportPackageIsVersion7
+
+const (
+ UnsafeService_UpdateNamespace_FullMethodName = "/policy.unsafe.UnsafeService/UpdateNamespace"
+ UnsafeService_ReactivateNamespace_FullMethodName = "/policy.unsafe.UnsafeService/ReactivateNamespace"
+ UnsafeService_DeleteNamespace_FullMethodName = "/policy.unsafe.UnsafeService/DeleteNamespace"
+ UnsafeService_UpdateAttribute_FullMethodName = "/policy.unsafe.UnsafeService/UpdateAttribute"
+ UnsafeService_ReactivateAttribute_FullMethodName = "/policy.unsafe.UnsafeService/ReactivateAttribute"
+ UnsafeService_DeleteAttribute_FullMethodName = "/policy.unsafe.UnsafeService/DeleteAttribute"
+ UnsafeService_UpdateAttributeValue_FullMethodName = "/policy.unsafe.UnsafeService/UpdateAttributeValue"
+ UnsafeService_ReactivateAttributeValue_FullMethodName = "/policy.unsafe.UnsafeService/ReactivateAttributeValue"
+ UnsafeService_DeleteAttributeValue_FullMethodName = "/policy.unsafe.UnsafeService/DeleteAttributeValue"
+)
+
+// UnsafeServiceClient is the client API for UnsafeService service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type UnsafeServiceClient interface {
+ // --------------------------------------*
+ // Namespace RPCs
+ // ---------------------------------------
+ UpdateNamespace(ctx context.Context, in *UpdateNamespaceRequest, opts ...grpc.CallOption) (*UpdateNamespaceResponse, error)
+ ReactivateNamespace(ctx context.Context, in *ReactivateNamespaceRequest, opts ...grpc.CallOption) (*ReactivateNamespaceResponse, error)
+ DeleteNamespace(ctx context.Context, in *DeleteNamespaceRequest, opts ...grpc.CallOption) (*DeleteNamespaceResponse, error)
+ // --------------------------------------*
+ // Attribute RPCs
+ // ---------------------------------------
+ UpdateAttribute(ctx context.Context, in *UpdateAttributeRequest, opts ...grpc.CallOption) (*UpdateAttributeResponse, error)
+ ReactivateAttribute(ctx context.Context, in *ReactivateAttributeRequest, opts ...grpc.CallOption) (*ReactivateAttributeResponse, error)
+ DeleteAttribute(ctx context.Context, in *DeleteAttributeRequest, opts ...grpc.CallOption) (*DeleteAttributeResponse, error)
+ // --------------------------------------*
+ // Value RPCs
+ // ---------------------------------------
+ UpdateAttributeValue(ctx context.Context, in *UpdateAttributeValueRequest, opts ...grpc.CallOption) (*UpdateAttributeValueResponse, error)
+ ReactivateAttributeValue(ctx context.Context, in *ReactivateAttributeValueRequest, opts ...grpc.CallOption) (*ReactivateAttributeValueResponse, error)
+ DeleteAttributeValue(ctx context.Context, in *DeleteAttributeValueRequest, opts ...grpc.CallOption) (*DeleteAttributeValueResponse, error)
+}
+
+type unsafeServiceClient struct {
+ cc grpc.ClientConnInterface
+}
+
+func NewUnsafeServiceClient(cc grpc.ClientConnInterface) UnsafeServiceClient {
+ return &unsafeServiceClient{cc}
+}
+
+func (c *unsafeServiceClient) UpdateNamespace(ctx context.Context, in *UpdateNamespaceRequest, opts ...grpc.CallOption) (*UpdateNamespaceResponse, error) {
+ out := new(UpdateNamespaceResponse)
+ err := c.cc.Invoke(ctx, UnsafeService_UpdateNamespace_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *unsafeServiceClient) ReactivateNamespace(ctx context.Context, in *ReactivateNamespaceRequest, opts ...grpc.CallOption) (*ReactivateNamespaceResponse, error) {
+ out := new(ReactivateNamespaceResponse)
+ err := c.cc.Invoke(ctx, UnsafeService_ReactivateNamespace_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *unsafeServiceClient) DeleteNamespace(ctx context.Context, in *DeleteNamespaceRequest, opts ...grpc.CallOption) (*DeleteNamespaceResponse, error) {
+ out := new(DeleteNamespaceResponse)
+ err := c.cc.Invoke(ctx, UnsafeService_DeleteNamespace_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *unsafeServiceClient) UpdateAttribute(ctx context.Context, in *UpdateAttributeRequest, opts ...grpc.CallOption) (*UpdateAttributeResponse, error) {
+ out := new(UpdateAttributeResponse)
+ err := c.cc.Invoke(ctx, UnsafeService_UpdateAttribute_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *unsafeServiceClient) ReactivateAttribute(ctx context.Context, in *ReactivateAttributeRequest, opts ...grpc.CallOption) (*ReactivateAttributeResponse, error) {
+ out := new(ReactivateAttributeResponse)
+ err := c.cc.Invoke(ctx, UnsafeService_ReactivateAttribute_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *unsafeServiceClient) DeleteAttribute(ctx context.Context, in *DeleteAttributeRequest, opts ...grpc.CallOption) (*DeleteAttributeResponse, error) {
+ out := new(DeleteAttributeResponse)
+ err := c.cc.Invoke(ctx, UnsafeService_DeleteAttribute_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *unsafeServiceClient) UpdateAttributeValue(ctx context.Context, in *UpdateAttributeValueRequest, opts ...grpc.CallOption) (*UpdateAttributeValueResponse, error) {
+ out := new(UpdateAttributeValueResponse)
+ err := c.cc.Invoke(ctx, UnsafeService_UpdateAttributeValue_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *unsafeServiceClient) ReactivateAttributeValue(ctx context.Context, in *ReactivateAttributeValueRequest, opts ...grpc.CallOption) (*ReactivateAttributeValueResponse, error) {
+ out := new(ReactivateAttributeValueResponse)
+ err := c.cc.Invoke(ctx, UnsafeService_ReactivateAttributeValue_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *unsafeServiceClient) DeleteAttributeValue(ctx context.Context, in *DeleteAttributeValueRequest, opts ...grpc.CallOption) (*DeleteAttributeValueResponse, error) {
+ out := new(DeleteAttributeValueResponse)
+ err := c.cc.Invoke(ctx, UnsafeService_DeleteAttributeValue_FullMethodName, in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+// UnsafeServiceServer is the server API for UnsafeService service.
+// All implementations must embed UnimplementedUnsafeServiceServer
+// for forward compatibility
+type UnsafeServiceServer interface {
+ // --------------------------------------*
+ // Namespace RPCs
+ // ---------------------------------------
+ UpdateNamespace(context.Context, *UpdateNamespaceRequest) (*UpdateNamespaceResponse, error)
+ ReactivateNamespace(context.Context, *ReactivateNamespaceRequest) (*ReactivateNamespaceResponse, error)
+ DeleteNamespace(context.Context, *DeleteNamespaceRequest) (*DeleteNamespaceResponse, error)
+ // --------------------------------------*
+ // Attribute RPCs
+ // ---------------------------------------
+ UpdateAttribute(context.Context, *UpdateAttributeRequest) (*UpdateAttributeResponse, error)
+ ReactivateAttribute(context.Context, *ReactivateAttributeRequest) (*ReactivateAttributeResponse, error)
+ DeleteAttribute(context.Context, *DeleteAttributeRequest) (*DeleteAttributeResponse, error)
+ // --------------------------------------*
+ // Value RPCs
+ // ---------------------------------------
+ UpdateAttributeValue(context.Context, *UpdateAttributeValueRequest) (*UpdateAttributeValueResponse, error)
+ ReactivateAttributeValue(context.Context, *ReactivateAttributeValueRequest) (*ReactivateAttributeValueResponse, error)
+ DeleteAttributeValue(context.Context, *DeleteAttributeValueRequest) (*DeleteAttributeValueResponse, error)
+ mustEmbedUnimplementedUnsafeServiceServer()
+}
+
+// UnimplementedUnsafeServiceServer must be embedded to have forward compatible implementations.
+type UnimplementedUnsafeServiceServer struct {
+}
+
+func (UnimplementedUnsafeServiceServer) UpdateNamespace(context.Context, *UpdateNamespaceRequest) (*UpdateNamespaceResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method UpdateNamespace not implemented")
+}
+func (UnimplementedUnsafeServiceServer) ReactivateNamespace(context.Context, *ReactivateNamespaceRequest) (*ReactivateNamespaceResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method ReactivateNamespace not implemented")
+}
+func (UnimplementedUnsafeServiceServer) DeleteNamespace(context.Context, *DeleteNamespaceRequest) (*DeleteNamespaceResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method DeleteNamespace not implemented")
+}
+func (UnimplementedUnsafeServiceServer) UpdateAttribute(context.Context, *UpdateAttributeRequest) (*UpdateAttributeResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method UpdateAttribute not implemented")
+}
+func (UnimplementedUnsafeServiceServer) ReactivateAttribute(context.Context, *ReactivateAttributeRequest) (*ReactivateAttributeResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method ReactivateAttribute not implemented")
+}
+func (UnimplementedUnsafeServiceServer) DeleteAttribute(context.Context, *DeleteAttributeRequest) (*DeleteAttributeResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method DeleteAttribute not implemented")
+}
+func (UnimplementedUnsafeServiceServer) UpdateAttributeValue(context.Context, *UpdateAttributeValueRequest) (*UpdateAttributeValueResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method UpdateAttributeValue not implemented")
+}
+func (UnimplementedUnsafeServiceServer) ReactivateAttributeValue(context.Context, *ReactivateAttributeValueRequest) (*ReactivateAttributeValueResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method ReactivateAttributeValue not implemented")
+}
+func (UnimplementedUnsafeServiceServer) DeleteAttributeValue(context.Context, *DeleteAttributeValueRequest) (*DeleteAttributeValueResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method DeleteAttributeValue not implemented")
+}
+func (UnimplementedUnsafeServiceServer) mustEmbedUnimplementedUnsafeServiceServer() {}
+
+// UnsafeUnsafeServiceServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to UnsafeServiceServer will
+// result in compilation errors.
+type UnsafeUnsafeServiceServer interface {
+ mustEmbedUnimplementedUnsafeServiceServer()
+}
+
+func RegisterUnsafeServiceServer(s grpc.ServiceRegistrar, srv UnsafeServiceServer) {
+ s.RegisterService(&UnsafeService_ServiceDesc, srv)
+}
+
+func _UnsafeService_UpdateNamespace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(UpdateNamespaceRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(UnsafeServiceServer).UpdateNamespace(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: UnsafeService_UpdateNamespace_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(UnsafeServiceServer).UpdateNamespace(ctx, req.(*UpdateNamespaceRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _UnsafeService_ReactivateNamespace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(ReactivateNamespaceRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(UnsafeServiceServer).ReactivateNamespace(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: UnsafeService_ReactivateNamespace_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(UnsafeServiceServer).ReactivateNamespace(ctx, req.(*ReactivateNamespaceRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _UnsafeService_DeleteNamespace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(DeleteNamespaceRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(UnsafeServiceServer).DeleteNamespace(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: UnsafeService_DeleteNamespace_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(UnsafeServiceServer).DeleteNamespace(ctx, req.(*DeleteNamespaceRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _UnsafeService_UpdateAttribute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(UpdateAttributeRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(UnsafeServiceServer).UpdateAttribute(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: UnsafeService_UpdateAttribute_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(UnsafeServiceServer).UpdateAttribute(ctx, req.(*UpdateAttributeRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _UnsafeService_ReactivateAttribute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(ReactivateAttributeRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(UnsafeServiceServer).ReactivateAttribute(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: UnsafeService_ReactivateAttribute_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(UnsafeServiceServer).ReactivateAttribute(ctx, req.(*ReactivateAttributeRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _UnsafeService_DeleteAttribute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(DeleteAttributeRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(UnsafeServiceServer).DeleteAttribute(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: UnsafeService_DeleteAttribute_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(UnsafeServiceServer).DeleteAttribute(ctx, req.(*DeleteAttributeRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _UnsafeService_UpdateAttributeValue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(UpdateAttributeValueRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(UnsafeServiceServer).UpdateAttributeValue(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: UnsafeService_UpdateAttributeValue_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(UnsafeServiceServer).UpdateAttributeValue(ctx, req.(*UpdateAttributeValueRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _UnsafeService_ReactivateAttributeValue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(ReactivateAttributeValueRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(UnsafeServiceServer).ReactivateAttributeValue(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: UnsafeService_ReactivateAttributeValue_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(UnsafeServiceServer).ReactivateAttributeValue(ctx, req.(*ReactivateAttributeValueRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _UnsafeService_DeleteAttributeValue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(DeleteAttributeValueRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(UnsafeServiceServer).DeleteAttributeValue(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: UnsafeService_DeleteAttributeValue_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(UnsafeServiceServer).DeleteAttributeValue(ctx, req.(*DeleteAttributeValueRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+// UnsafeService_ServiceDesc is the grpc.ServiceDesc for UnsafeService service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var UnsafeService_ServiceDesc = grpc.ServiceDesc{
+ ServiceName: "policy.unsafe.UnsafeService",
+ HandlerType: (*UnsafeServiceServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "UpdateNamespace",
+ Handler: _UnsafeService_UpdateNamespace_Handler,
+ },
+ {
+ MethodName: "ReactivateNamespace",
+ Handler: _UnsafeService_ReactivateNamespace_Handler,
+ },
+ {
+ MethodName: "DeleteNamespace",
+ Handler: _UnsafeService_DeleteNamespace_Handler,
+ },
+ {
+ MethodName: "UpdateAttribute",
+ Handler: _UnsafeService_UpdateAttribute_Handler,
+ },
+ {
+ MethodName: "ReactivateAttribute",
+ Handler: _UnsafeService_ReactivateAttribute_Handler,
+ },
+ {
+ MethodName: "DeleteAttribute",
+ Handler: _UnsafeService_DeleteAttribute_Handler,
+ },
+ {
+ MethodName: "UpdateAttributeValue",
+ Handler: _UnsafeService_UpdateAttributeValue_Handler,
+ },
+ {
+ MethodName: "ReactivateAttributeValue",
+ Handler: _UnsafeService_ReactivateAttributeValue_Handler,
+ },
+ {
+ MethodName: "DeleteAttributeValue",
+ Handler: _UnsafeService_DeleteAttributeValue_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{},
+ Metadata: "policy/unsafe/unsafe.proto",
+}
diff --git a/service/policy/unsafe/unsafe.proto b/service/policy/unsafe/unsafe.proto
new file mode 100644
index 000000000..5565cbd05
--- /dev/null
+++ b/service/policy/unsafe/unsafe.proto
@@ -0,0 +1,197 @@
+syntax = "proto3";
+
+package policy.unsafe;
+
+import "buf/validate/validate.proto";
+import "google/api/annotations.proto";
+import "policy/objects.proto";
+
+// Namespaces Unsafe RPCs
+
+// WARNING!!
+// Updating the Namespace of an Attribute will retroactively alter access to existing TDFs of the old and new Namespace name.
+// Existing Attribute Definitions and their Values under the Namespace will now be associated with the new Namespace name.
+message UpdateNamespaceRequest {
+ // Required
+ string id = 1 [(buf.validate.field).required = true];
+
+ string name = 2 [
+ (buf.validate.field).string.max_len = 253,
+ (buf.validate.field).cel = {
+ id: "namespace_name_format",
+ message: "Namespace name must be an alphanumeric string, allowing hyphens and underscores but not as the first or last character. The stored namespace name will be normalized to lower case.",
+ expression: "this.matches('^[a-zA-Z0-9](?:[a-zA-Z0-9_-]*[a-zA-Z0-9])?$')"
+ }
+ ];
+}
+message UpdateNamespaceResponse {
+ policy.Namespace namespace = 1;
+}
+
+// WARNING!!
+// Reactivating a Namespace can potentially open up an access path to existing TDFs containing any Attributes under the Namespace.
+// Active state of any Definitions and their Values under this Namespace will NOT be changed.
+message ReactivateNamespaceRequest {
+ string id = 1 [(buf.validate.field).required = true];
+}
+message ReactivateNamespaceResponse {
+ policy.Namespace namespace = 1;
+}
+
+// WARNING!!
+// Deleting a Namespace will free up the Attribute Namespace, Definitions, and Values for reuse, which can introduce an access path to existing TDFs containing the deleted policy.
+// Definitions and their Values under this Namespace will be cascadingly deleted.
+message DeleteNamespaceRequest {
+ // Required
+ // UUID of the Namespace
+ string id = 1 [(buf.validate.field).required = true];
+ // Fully Qualified Name (FQN) of Namespace (i.e. https://), normalized to lower case.
+ string fqn = 2 [(buf.validate.field).required = true];
+}
+message DeleteNamespaceResponse {
+ policy.Namespace namespace = 1;
+}
+
+// Attribute Definitions Unsafe RPCs
+
+// WARNING!!
+// Updating an Attribute can have dangerous consequences. Use with caution.
+message UpdateAttributeRequest {
+ // Required
+ string id = 1 [(buf.validate.field).required = true];
+
+ // Optional
+ // WARNING!!
+ // Updating the name of an Attribute will retroactively alter access to existing TDFs of the old and new Attribute name.
+ string name = 2 [
+ (buf.validate.field).string.max_len = 253,
+ (buf.validate.field).cel = {
+ id: "attribute_name_format",
+ message: "Attribute name must be an alphanumeric string, allowing hyphens and underscores but not as the first or last character. The stored attribute name will be normalized to lower case.",
+ expression: "this.matches('^[a-zA-Z0-9](?:[a-zA-Z0-9_-]*[a-zA-Z0-9])?$')"
+ }
+ ];
+ // WARNING!!
+ // Updating the rule of an Attribute will retroactively alter access to existing TDFs of the Attribute name.
+ AttributeRuleTypeEnum rule = 3 [
+ (buf.validate.field).enum.defined_only = true
+ ];
+}
+message UpdateAttributeResponse {
+ policy.Attribute attribute = 1;
+}
+
+// WARNING!!
+// Reactivating an Attribute can potentially open up an access path to existing TDFs containing the Attribute name.
+// Active state of any Values under this Attribute Definition will NOT be changed.
+message ReactivateAttributeRequest {
+ string id = 1 [(buf.validate.field).required = true];
+}
+message ReactivateAttributeResponse {
+ policy.Attribute attribute = 1;
+}
+
+// WARNING!!
+// Deleting an Attribute will free up the Attribute name for reuse, which can introduce an access path to existing TDFs containing the deleted Attribute name.
+// Values under this Attribute will be cascadingly deleted.
+// Any KAS Grants associated with this Attribute will be cascadingly deleted.
+message DeleteAttributeRequest {
+ // Required
+ // UUID of the Attribute
+ string id = 1 [(buf.validate.field).required = true];
+ // Fully Qualified Name (FQN) of Attribute Definition (i.e. https:///attr/), normalized to lower case.
+ string fqn = 2 [(buf.validate.field).required = true];
+}
+message DeleteAttributeResponse {
+ policy.Attribute attribute = 1;
+}
+
+///
+/// Value Unsafe RPC messages
+///
+
+// WARNING!!
+// Updating an Attribute Value will retroactively alter access to existing TDFs containing the old and new Attribute Value.
+message UpdateAttributeValueRequest {
+ string id = 1 [(buf.validate.field).required = true];
+
+ string value = 2 [
+ (buf.validate.field).string.max_len = 253,
+ (buf.validate.field).cel = {
+ id: "value_format",
+ message: "Attribute Value must be an alphanumeric string, allowing hyphens and underscores but not as the first or last character. The stored attribute value will be normalized to lower case.",
+ expression: "this.matches('^[a-zA-Z0-9](?:[a-zA-Z0-9_-]*[a-zA-Z0-9])?$')"
+ }
+ ];
+}
+message UpdateAttributeValueResponse {
+ policy.Value value = 1;
+}
+
+// WARNING!!
+// Reactivating an Attribute Value can potentially open up an access path to existing TDFs containing the Attribute Value.
+message ReactivateAttributeValueRequest {
+ string id = 1 [(buf.validate.field).required = true];
+}
+message ReactivateAttributeValueResponse {
+ policy.Value value = 1;
+}
+
+// WARNING!!
+// Deleting an Attribute Value will free up the Attribute Value for reuse, which can introduce an access path to existing TDFs containing the deleted Attribute Value.
+// Any KAS Grants associated with this Attribute Value will be cascadingly deleted.
+message DeleteAttributeValueRequest {
+ // Required
+ // UUID of the Attribute Value
+ string id = 1 [(buf.validate.field).required = true];
+ // Fully Qualified Name (FQN) of Attribute Value (i.e. https:///attr//value/), normalized to lower case.
+ string fqn = 2 [(buf.validate.field).required = true];
+}
+message DeleteAttributeValueResponse {
+ policy.Value value = 1;
+}
+
+///
+/// Unsafe Service
+/// IN FLIGHT AND NOT YET IMPLEMENTED!
+///
+service UnsafeService {
+ /*--------------------------------------*
+ * Namespace RPCs
+ *---------------------------------------*/
+ rpc UpdateNamespace(UpdateNamespaceRequest) returns (UpdateNamespaceResponse) {
+ option (google.api.http) = {patch: "/unsafe/namespaces/{id}"};
+ }
+ rpc ReactivateNamespace(ReactivateNamespaceRequest) returns (ReactivateNamespaceResponse) {
+ option (google.api.http) = {post: "/unsafe/namespaces/{id}/reactivate"};
+ }
+ rpc DeleteNamespace(DeleteNamespaceRequest) returns (DeleteNamespaceResponse) {
+ option (google.api.http) = {delete: "/unsafe/namespaces/{id}"};
+ }
+
+ /*--------------------------------------*
+ * Attribute RPCs
+ *---------------------------------------*/
+ rpc UpdateAttribute(UpdateAttributeRequest) returns (UpdateAttributeResponse) {
+ option (google.api.http) = {patch: "/unsafe/attributes/{id}"};
+ }
+ rpc ReactivateAttribute(ReactivateAttributeRequest) returns (ReactivateAttributeResponse) {
+ option (google.api.http) = {post: "/unsafe/attributes/{id}/reactivate"};
+ }
+ rpc DeleteAttribute(DeleteAttributeRequest) returns (DeleteAttributeResponse) {
+ option (google.api.http) = {delete: "/unsafe/attributes/{id}"};
+ }
+
+ /*--------------------------------------*
+ * Value RPCs
+ *---------------------------------------*/
+ rpc UpdateAttributeValue(UpdateAttributeValueRequest) returns (UpdateAttributeValueResponse) {
+ option (google.api.http) = {patch: "/unsafe/attributes/values/{id}"};
+ }
+ rpc ReactivateAttributeValue(ReactivateAttributeValueRequest) returns (ReactivateAttributeValueResponse) {
+ option (google.api.http) = {post: "/unsafe/attributes/values/{id}/reactivate"};
+ }
+ rpc DeleteAttributeValue(DeleteAttributeValueRequest) returns (DeleteAttributeValueResponse) {
+ option (google.api.http) = {delete: "/unsafe/attributes/values/{id}"};
+ }
+}