// Code generated by rdl 1.5.2 DO NOT EDIT.

package zms

import (
	"log"

	rdl "github.com/ardielle/ardielle-go/rdl"
)

var schema *rdl.Schema

func init() {
	sb := rdl.NewSchemaBuilder("ZMS")
	sb.Version(1)
	sb.Namespace("com.yahoo.athenz.zms")
	sb.Comment("Copyright The Athenz Authors Licensed under the terms of the Apache version 2.0 license. See LICENSE file for terms. The Authorization Management Service (ZMS) Classes")

	tSimpleName := rdl.NewStringTypeBuilder("SimpleName")
	tSimpleName.Comment("Copyright The Athenz Authors Licensed under the terms of the Apache version 2.0 license. See LICENSE file for terms. Common name types used by several API definitions A simple identifier, an element of compound name.")
	tSimpleName.Pattern("[a-zA-Z0-9_][a-zA-Z0-9_-]*")
	sb.AddType(tSimpleName.Build())

	tCompoundName := rdl.NewStringTypeBuilder("CompoundName")
	tCompoundName.Comment("A compound name. Most names in this API are compound names.")
	tCompoundName.Pattern("([a-zA-Z0-9_][a-zA-Z0-9_-]*\\.)*[a-zA-Z0-9_][a-zA-Z0-9_-]*")
	sb.AddType(tCompoundName.Build())

	tDomainName := rdl.NewStringTypeBuilder("DomainName")
	tDomainName.Comment("A domain name is the general qualifier prefix, as its uniqueness is managed.")
	tDomainName.Pattern("([a-zA-Z0-9_][a-zA-Z0-9_-]*\\.)*[a-zA-Z0-9_][a-zA-Z0-9_-]*")
	sb.AddType(tDomainName.Build())

	tEntityName := rdl.NewStringTypeBuilder("EntityName")
	tEntityName.Comment("An entity name is a short form of a resource name, including only the domain and entity.")
	tEntityName.Pattern("([a-zA-Z0-9_][a-zA-Z0-9_-]*\\.)*[a-zA-Z0-9_][a-zA-Z0-9_-]*")
	sb.AddType(tEntityName.Build())

	tServiceName := rdl.NewStringTypeBuilder("ServiceName")
	tServiceName.Comment("A service name will generally be a unique subdomain.")
	tServiceName.Pattern("([a-zA-Z0-9_][a-zA-Z0-9_-]*\\.)*[a-zA-Z0-9_][a-zA-Z0-9_-]*")
	sb.AddType(tServiceName.Build())

	tLocationName := rdl.NewStringTypeBuilder("LocationName")
	tLocationName.Comment("A location name is not yet defined, but will be a dotted name like everything else.")
	tLocationName.Pattern("([a-zA-Z0-9_][a-zA-Z0-9_-]*\\.)*[a-zA-Z0-9_][a-zA-Z0-9_-]*")
	sb.AddType(tLocationName.Build())

	tActionName := rdl.NewStringTypeBuilder("ActionName")
	tActionName.Comment("An action (operation) name.")
	tActionName.Pattern("([a-zA-Z0-9_][a-zA-Z0-9_-]*\\.)*[a-zA-Z0-9_][a-zA-Z0-9_-]*")
	sb.AddType(tActionName.Build())

	tResourceName := rdl.NewStringTypeBuilder("ResourceName")
	tResourceName.Comment("A resource name Note that the EntityName part is optional, that is, a domain name followed by a colon is valid resource name.")
	tResourceName.Pattern("([a-zA-Z0-9_][a-zA-Z0-9_-]*\\.)*[a-zA-Z0-9_][a-zA-Z0-9_-]*(:([a-zA-Z0-9_][a-zA-Z0-9_-]*\\.)*[a-zA-Z0-9_][a-zA-Z0-9_-]*)?")
	sb.AddType(tResourceName.Build())

	tResourceNames := rdl.NewStringTypeBuilder("ResourceNames")
	tResourceNames.Comment("A comma separated list of resource names")
	tResourceNames.Pattern("(([a-zA-Z0-9_][a-zA-Z0-9_-]*\\.)*[a-zA-Z0-9_][a-zA-Z0-9_-]*(:([a-zA-Z0-9_][a-zA-Z0-9_-]*\\.)*[a-zA-Z0-9_][a-zA-Z0-9_-]*)?,)*([a-zA-Z0-9_][a-zA-Z0-9_-]*\\.)*[a-zA-Z0-9_][a-zA-Z0-9_-]*(:([a-zA-Z0-9_][a-zA-Z0-9_-]*\\.)*[a-zA-Z0-9_][a-zA-Z0-9_-]*)?")
	sb.AddType(tResourceNames.Build())

	tYBase64 := rdl.NewStringTypeBuilder("YBase64")
	tYBase64.Comment("The Y-specific URL-safe Base64 variant.")
	tYBase64.Pattern("[a-zA-Z0-9\\._-]+")
	sb.AddType(tYBase64.Build())

	tYEncoded := rdl.NewStringTypeBuilder("YEncoded")
	tYEncoded.Comment("YEncoded includes ybase64 chars, as well as = and %. This can represent a user cookie and URL-encoded values.")
	tYEncoded.Pattern("[a-zA-Z0-9\\._%=-]*")
	sb.AddType(tYEncoded.Build())

	tAuthorityName := rdl.NewStringTypeBuilder("AuthorityName")
	tAuthorityName.Comment("Used as the prefix in a signed assertion. This uniquely identifies a signing authority.")
	tAuthorityName.Pattern("([a-zA-Z0-9_][a-zA-Z0-9_-]*\\.)*[a-zA-Z0-9_][a-zA-Z0-9_-]*")
	sb.AddType(tAuthorityName.Build())

	tSignedToken := rdl.NewStringTypeBuilder("SignedToken")
	tSignedToken.Comment("A signed assertion if identity. i.e. the user cookie value. This token will only make sense to the authority that generated it, so it is beneficial to have something in the value that is cheaply recognized to quickly reject if it belongs to another authority. In addition to the YEncoded set our token includes ; to separate components and , to separate roles and : for IPv6 addresses")
	tSignedToken.Pattern("[a-zA-Z0-9\\._%=:;,-]*")
	sb.AddType(tSignedToken.Build())

	tGroupName := rdl.NewStringTypeBuilder("GroupName")
	tGroupName.Comment("A group name")
	tGroupName.Pattern("([a-zA-Z0-9_][a-zA-Z0-9_-]*\\.)*[a-zA-Z0-9_][a-zA-Z0-9_-]*:group\\.([a-zA-Z0-9_][a-zA-Z0-9_-]*\\.)*[a-zA-Z0-9_][a-zA-Z0-9_-]*")
	sb.AddType(tGroupName.Build())

	tGroupMemberName := rdl.NewStringTypeBuilder("GroupMemberName")
	tGroupMemberName.Comment("A group member name")
	tGroupMemberName.Pattern("([a-zA-Z0-9_][a-zA-Z0-9_-]*\\.)*[a-zA-Z0-9_][a-zA-Z0-9_-]*")
	sb.AddType(tGroupMemberName.Build())

	tMemberName := rdl.NewStringTypeBuilder("MemberName")
	tMemberName.Comment("Role Member name - could be one of four values: *, DomainName.* or ServiceName[*], or GroupNames")
	tMemberName.Pattern("\\*|([a-zA-Z0-9_][a-zA-Z0-9_-]*\\.)*[a-zA-Z0-9_][a-zA-Z0-9_-]*\\.\\*|([a-zA-Z0-9_][a-zA-Z0-9_-]*\\.)*[a-zA-Z0-9_][a-zA-Z0-9_-]*(\\*)?|([a-zA-Z0-9_][a-zA-Z0-9_-]*\\.)*[a-zA-Z0-9_][a-zA-Z0-9_-]*:group\\.([a-zA-Z0-9_][a-zA-Z0-9_-]*\\.)*[a-zA-Z0-9_][a-zA-Z0-9_-]*")
	sb.AddType(tMemberName.Build())

	tAuthorityKeyword := rdl.NewStringTypeBuilder("AuthorityKeyword")
	tAuthorityKeyword.Comment("A comma separated list of authority keywords")
	tAuthorityKeyword.Pattern("[a-zA-Z0-9_][a-zA-Z0-9_-]*")
	sb.AddType(tAuthorityKeyword.Build())

	tAuthorityKeywords := rdl.NewStringTypeBuilder("AuthorityKeywords")
	tAuthorityKeywords.Pattern("([a-zA-Z0-9_][a-zA-Z0-9_-]*,)*[a-zA-Z0-9_][a-zA-Z0-9_-]*")
	sb.AddType(tAuthorityKeywords.Build())

	tTagKey := rdl.NewStringTypeBuilder("TagKey")
	tTagKey.Pattern("([a-zA-Z0-9_][a-zA-Z0-9_-]*[:\\.])*[a-zA-Z0-9_][a-zA-Z0-9_-]*")
	sb.AddType(tTagKey.Build())

	tTagValue := rdl.NewStringTypeBuilder("TagValue")
	tTagValue.Comment("TagValue to contain generic string patterns")
	tTagValue.Pattern("[a-zA-Z0-9_:,\\/][a-zA-Z0-9_:%,\\/-]*")
	sb.AddType(tTagValue.Build())

	tTagCompoundValue := rdl.NewStringTypeBuilder("TagCompoundValue")
	tTagCompoundValue.Comment("A compound value of TagValue")
	tTagCompoundValue.Pattern("([a-zA-Z0-9_:,\\/][a-zA-Z0-9_:%,\\/-]*\\.)*[a-zA-Z0-9_:,\\/][a-zA-Z0-9_:%,\\/-]*")
	sb.AddType(tTagCompoundValue.Build())

	tTagValueList := rdl.NewStructTypeBuilder("Struct", "TagValueList")
	tTagValueList.ArrayField("list", "TagCompoundValue", false, "list of tag values")
	sb.AddType(tTagValueList.Build())

	tAssertionConditionKeyPattern := rdl.NewStringTypeBuilder("AssertionConditionKeyPattern")
	tAssertionConditionKeyPattern.Pattern("[a-zA-Z][a-zA-Z0-9_-]+")
	sb.AddType(tAssertionConditionKeyPattern.Build())

	tAssertionConditionKey := rdl.NewStringTypeBuilder("AssertionConditionKey")
	tAssertionConditionKey.Pattern("([a-zA-Z][a-zA-Z0-9_-]+\\.)*[a-zA-Z][a-zA-Z0-9_-]+")
	sb.AddType(tAssertionConditionKey.Build())

	tAssertionConditionValuePattern := rdl.NewStringTypeBuilder("AssertionConditionValuePattern")
	tAssertionConditionValuePattern.Pattern("[a-zA-Z0-9\\*][a-zA-Z0-9_\\.\\*-]*")
	sb.AddType(tAssertionConditionValuePattern.Build())

	tAssertionConditionValue := rdl.NewStringTypeBuilder("AssertionConditionValue")
	tAssertionConditionValue.Pattern("([a-zA-Z0-9\\*][a-zA-Z0-9_\\.\\*-]*,)*[a-zA-Z0-9\\*][a-zA-Z0-9_\\.\\*-]*")
	sb.AddType(tAssertionConditionValue.Build())

	tResourceOwnerName := rdl.NewStringTypeBuilder("ResourceOwnerName")
	tResourceOwnerName.Pattern("[a-zA-Z0-9_][a-zA-Z0-9_:-]*")
	sb.AddType(tResourceOwnerName.Build())

	tResourceDomainOwnership := rdl.NewStructTypeBuilder("Struct", "ResourceDomainOwnership")
	tResourceDomainOwnership.Comment("The representation of the domain ownership object")
	tResourceDomainOwnership.Field("metaOwner", "SimpleName", true, nil, "owner of the object's meta attribute")
	tResourceDomainOwnership.Field("objectOwner", "SimpleName", true, nil, "owner of the object itself - checked for object deletion")
	sb.AddType(tResourceDomainOwnership.Build())

	tDomainMeta := rdl.NewStructTypeBuilder("Struct", "DomainMeta")
	tDomainMeta.Comment("Set of metadata attributes that all domains may have and can be changed.")
	tDomainMeta.Field("description", "String", true, nil, "a description of the domain")
	tDomainMeta.Field("org", "ResourceName", true, nil, "a reference to an audit organization defined in athenz")
	tDomainMeta.Field("enabled", "Bool", true, true, "Future use only, currently not used")
	tDomainMeta.Field("auditEnabled", "Bool", true, false, "Flag indicates whether or not domain modifications should be logged for SOX+Auditing. If true, the auditRef parameter must be supplied(not empty) for any API defining it.")
	tDomainMeta.Field("account", "String", true, nil, "associated aws account id (system attribute - uniqueness check - if enabled)")
	tDomainMeta.Field("ypmId", "Int32", true, nil, "associated product id (system attribute - uniqueness check - if enabled)")
	tDomainMeta.Field("applicationId", "String", true, nil, "associated application id")
	tDomainMeta.Field("certDnsDomain", "String", true, nil, "domain certificate dns domain (system attribute)")
	tDomainMeta.Field("memberExpiryDays", "Int32", true, nil, "all user members in the domain will have specified max expiry days")
	tDomainMeta.Field("tokenExpiryMins", "Int32", true, nil, "tokens issued for this domain will have specified max timeout in mins")
	tDomainMeta.Field("serviceCertExpiryMins", "Int32", true, nil, "service identity certs issued for this domain will have specified max timeout in mins")
	tDomainMeta.Field("roleCertExpiryMins", "Int32", true, nil, "role certs issued for this domain will have specified max timeout in mins")
	tDomainMeta.Field("signAlgorithm", "String", true, nil, "rsa or ec signing algorithm to be used for tokens")
	tDomainMeta.Field("serviceExpiryDays", "Int32", true, nil, "all services in the domain roles will have specified max expiry days")
	tDomainMeta.Field("groupExpiryDays", "Int32", true, nil, "all groups in the domain roles will have specified max expiry days")
	tDomainMeta.Field("userAuthorityFilter", "String", true, nil, "membership filtered based on user authority configured attributes")
	tDomainMeta.Field("azureSubscription", "String", true, nil, "associated azure subscription id (system attribute - uniqueness check - if enabled)")
	tDomainMeta.Field("azureTenant", "String", true, nil, "associated azure tenant id (system attribute)")
	tDomainMeta.Field("azureClient", "String", true, nil, "associated azure client id (system attribute)")
	tDomainMeta.Field("gcpProject", "String", true, nil, "associated gcp project id (system attribute - uniqueness check - if enabled)")
	tDomainMeta.Field("gcpProjectNumber", "String", true, nil, "associated gcp project number (system attribute)")
	tDomainMeta.MapField("tags", "TagKey", "TagValueList", true, "key-value pair tags, tag might contain multiple values")
	tDomainMeta.Field("businessService", "String", true, nil, "associated business service with domain")
	tDomainMeta.Field("memberPurgeExpiryDays", "Int32", true, nil, "purge role/group members with expiry date configured days in the past")
	tDomainMeta.Field("productId", "String", true, nil, "associated product id (system attribute - uniqueness check - if enabled)")
	tDomainMeta.Field("featureFlags", "Int32", true, nil, "features enabled per domain (system attribute)")
	tDomainMeta.MapField("contacts", "SimpleName", "String", true, "list of domain contacts (PE-Owner, Product-Owner, etc), each type can have a single value")
	tDomainMeta.Field("environment", "String", true, nil, "domain environment e.g. production, staging, etc")
	tDomainMeta.Field("resourceOwnership", "ResourceDomainOwnership", true, nil, "ownership information for the domain (read-only attribute)")
	tDomainMeta.Field("x509CertSignerKeyId", "String", true, nil, "requested x509 cert signer key id (system attribute)")
	tDomainMeta.Field("sshCertSignerKeyId", "String", true, nil, "requested ssh cert signer key id (system attribute)")
	tDomainMeta.Field("slackChannel", "String", true, nil, "slack channel for any notifications in this domain")
	tDomainMeta.Field("onCall", "String", true, nil, "oncall team name/id for any incidents in this domain")
	tDomainMeta.Field("autoDeleteTenantAssumeRoleAssertions", "Bool", true, false, "Indicates whether to automatically delete assertions for a tenant's assume role")
	sb.AddType(tDomainMeta.Build())

	tDomain := rdl.NewStructTypeBuilder("DomainMeta", "Domain")
	tDomain.Comment("A domain is an independent partition of users, roles, and resources. Its name represents the definition of a namespace; the only way a new namespace can be created, from the top, is by creating Domains. Administration of a domain is governed by the parent domain (using reverse-DNS namespaces). The top level domains are governed by the special \"sys.auth\" domain.")
	tDomain.Field("name", "DomainName", false, nil, "the common name to be referred to, the symbolic id. It is immutable")
	tDomain.Field("modified", "Timestamp", true, nil, "the last modification timestamp of any object or attribute in this domain")
	tDomain.Field("id", "UUID", true, nil, "unique identifier of the domain. generated on create, never reused")
	sb.AddType(tDomain.Build())

	tDomainMetaList := rdl.NewStructTypeBuilder("Struct", "DomainMetaList")
	tDomainMetaList.Comment("A list of domain objects with their meta attributes.")
	tDomainMetaList.ArrayField("domains", "Domain", false, "list of domain objects")
	sb.AddType(tDomainMetaList.Build())

	tDomainList := rdl.NewStructTypeBuilder("Struct", "DomainList")
	tDomainList.Comment("A paginated list of domains.")
	tDomainList.ArrayField("names", "DomainName", false, "list of domain names")
	tDomainList.Field("next", "String", true, nil, "if the response is a paginated list, this attribute specifies the value to be used in the next domain list request as the value for the skip query parameter.")
	sb.AddType(tDomainList.Build())

	tDomainAttributes := rdl.NewStructTypeBuilder("Struct", "DomainAttributes")
	tDomainAttributes.Comment("A domain attributes for the changelog support")
	tDomainAttributes.Field("fetchTime", "Int64", false, nil, "timestamp when the domain object was fetched from ZMS")
	sb.AddType(tDomainAttributes.Build())

	tDomainOptions := rdl.NewStructTypeBuilder("Struct", "DomainOptions")
	tDomainOptions.Comment("A domain options for enforcing uniqueness checks")
	tDomainOptions.Field("enforceUniqueProductIds", "Bool", false, nil, "enforce domains are associated with unique product ids")
	tDomainOptions.Field("enforceUniqueAWSAccounts", "Bool", false, nil, "enforce domains are associated with unique aws accounts")
	tDomainOptions.Field("enforceUniqueAzureSubscriptions", "Bool", false, nil, "enforce domains are associated with unique azure subscriptions")
	tDomainOptions.Field("enforceUniqueGCPProjects", "Bool", false, nil, "enforce domains are associated with unique gcp projects")
	sb.AddType(tDomainOptions.Build())

	tRoleList := rdl.NewStructTypeBuilder("Struct", "RoleList")
	tRoleList.Comment("The representation for an enumeration of roles in the namespace, with pagination.")
	tRoleList.ArrayField("names", "EntityName", false, "list of role names")
	tRoleList.Field("next", "String", true, nil, "if the response is a paginated list, this attribute specifies the value to be used in the next role list request as the value for the skip query parameter.")
	sb.AddType(tRoleList.Build())

	tRoleAuditLog := rdl.NewStructTypeBuilder("Struct", "RoleAuditLog")
	tRoleAuditLog.Comment("An audit log entry for role membership change.")
	tRoleAuditLog.Field("member", "MemberName", false, nil, "name of the role member")
	tRoleAuditLog.Field("admin", "ResourceName", false, nil, "name of the principal executing the change")
	tRoleAuditLog.Field("created", "Timestamp", false, nil, "timestamp of the entry")
	tRoleAuditLog.Field("action", "String", false, nil, "log action - e.g. add, delete, approve, etc")
	tRoleAuditLog.Field("auditRef", "String", true, nil, "audit reference string for the change as supplied by admin")
	sb.AddType(tRoleAuditLog.Build())

	tRoleMember := rdl.NewStructTypeBuilder("Struct", "RoleMember")
	tRoleMember.Field("memberName", "MemberName", false, nil, "name of the member")
	tRoleMember.Field("expiration", "Timestamp", true, nil, "the expiration timestamp")
	tRoleMember.Field("reviewReminder", "Timestamp", true, nil, "the review reminder timestamp")
	tRoleMember.Field("active", "Bool", true, true, "Flag to indicate whether membership is active")
	tRoleMember.Field("approved", "Bool", true, true, "Flag to indicate whether membership is approved either by delegates ( in case of auditEnabled roles ) or by domain admins ( in case of selfserve roles )")
	tRoleMember.Field("auditRef", "String", true, nil, "audit reference string for the change as supplied by admin")
	tRoleMember.Field("requestTime", "Timestamp", true, nil, "for pending membership requests, the request time")
	tRoleMember.Field("lastNotifiedTime", "Timestamp", true, nil, "for pending membership requests, time when last notification was sent")
	tRoleMember.Field("requestPrincipal", "ResourceName", true, nil, "pending members only - name of the principal requesting the change")
	tRoleMember.Field("reviewLastNotifiedTime", "Timestamp", true, nil, "for pending membership requests, time when last notification was sent (for file store)")
	tRoleMember.Field("systemDisabled", "Int32", true, nil, "user disabled by system based on configured role setting")
	tRoleMember.Field("principalType", "Int32", true, nil, "server use only - principal type: unknown(0), user(1), service(2), or group(3)")
	tRoleMember.Field("pendingState", "String", true, nil, "for pending membership requests, the request state - e.g. add, delete")
	sb.AddType(tRoleMember.Build())

	tResourceRoleOwnership := rdl.NewStructTypeBuilder("Struct", "ResourceRoleOwnership")
	tResourceRoleOwnership.Comment("The representation of the role ownership object")
	tResourceRoleOwnership.Field("metaOwner", "SimpleName", true, nil, "owner of the object's meta attribute")
	tResourceRoleOwnership.Field("membersOwner", "SimpleName", true, nil, "owner of the object's members attribute")
	tResourceRoleOwnership.Field("objectOwner", "SimpleName", true, nil, "owner of the object itself - checked for object deletion")
	sb.AddType(tResourceRoleOwnership.Build())

	tRoleMeta := rdl.NewStructTypeBuilder("Struct", "RoleMeta")
	tRoleMeta.Comment("Set of metadata attributes that all roles may have and can be changed by domain admins.")
	tRoleMeta.Field("selfServe", "Bool", true, false, "Flag indicates whether or not role allows self service. Users can add themselves in the role, but it has to be approved by domain admins to be effective.")
	tRoleMeta.Field("memberExpiryDays", "Int32", true, nil, "all user members in the role will have specified max expiry days")
	tRoleMeta.Field("tokenExpiryMins", "Int32", true, nil, "tokens issued for this role will have specified max timeout in mins")
	tRoleMeta.Field("certExpiryMins", "Int32", true, nil, "certs issued for this role will have specified max timeout in mins")
	tRoleMeta.Field("signAlgorithm", "String", true, nil, "rsa or ec signing algorithm to be used for tokens")
	tRoleMeta.Field("serviceExpiryDays", "Int32", true, nil, "all services in the role will have specified max expiry days")
	tRoleMeta.Field("memberReviewDays", "Int32", true, nil, "all user members in the role will have specified max review days")
	tRoleMeta.Field("serviceReviewDays", "Int32", true, nil, "all services in the role will have specified max review days")
	tRoleMeta.Field("reviewEnabled", "Bool", true, false, "Flag indicates whether or not role updates require another review and approval")
	tRoleMeta.Field("notifyRoles", "String", true, nil, "list of roles whose members should be notified for member review/approval")
	tRoleMeta.Field("userAuthorityFilter", "String", true, nil, "membership filtered based on user authority configured attributes")
	tRoleMeta.Field("userAuthorityExpiration", "String", true, nil, "expiration enforced by a user authority configured attribute")
	tRoleMeta.Field("groupExpiryDays", "Int32", true, nil, "all groups in the domain roles will have specified max expiry days")
	tRoleMeta.Field("groupReviewDays", "Int32", true, nil, "all groups in the domain roles will have specified max review days")
	tRoleMeta.MapField("tags", "TagKey", "TagValueList", true, "key-value pair tags, tag might contain multiple values")
	tRoleMeta.Field("description", "String", true, nil, "a description of the role")
	tRoleMeta.Field("auditEnabled", "Bool", true, false, "Flag indicates whether or not role updates should be approved by GRC. If true, the auditRef parameter must be supplied(not empty) for any API defining it.")
	tRoleMeta.Field("deleteProtection", "Bool", true, false, "If true, ask for delete confirmation in audit and review enabled roles.")
	tRoleMeta.Field("lastReviewedDate", "Timestamp", true, nil, "last review timestamp of the role")
	tRoleMeta.Field("selfRenew", "Bool", true, nil, "Flag indicates whether to allow expired members to renew their membership")
	tRoleMeta.Field("selfRenewMins", "Int32", true, nil, "Number of minutes members can renew their membership if self review option is enabled")
	tRoleMeta.Field("maxMembers", "Int32", true, nil, "Maximum number of members allowed in the group")
	tRoleMeta.Field("resourceOwnership", "ResourceRoleOwnership", true, nil, "ownership information for the role (read-only attribute)")
	tRoleMeta.Field("principalDomainFilter", "String", true, nil, "membership filtered based on configured principal domains")
	tRoleMeta.Field("notifyDetails", "String", true, nil, "additional details included in the notifications")
	sb.AddType(tRoleMeta.Build())

	tRole := rdl.NewStructTypeBuilder("RoleMeta", "Role")
	tRole.Comment("The representation for a Role with set of members. The members (Array<MemberName>) field is deprecated and not used in role objects since it incorrectly lists all the members in the role without taking into account if the member is expired or possibly disabled. Thus, using this attribute will result in incorrect authorization checks by the client and, thus, it's no longer being populated. All applications must use the roleMembers field and take into account all the attributes of the member.")
	tRole.Field("name", "ResourceName", false, nil, "name of the role")
	tRole.Field("modified", "Timestamp", true, nil, "last modification timestamp of the role")
	tRole.ArrayField("members", "MemberName", true, "deprecated and not used")
	tRole.ArrayField("roleMembers", "RoleMember", true, "members with expiration and other member attributes. might be empty or null, if trust is set")
	tRole.Field("trust", "DomainName", true, nil, "a trusted domain to delegate membership decisions to")
	tRole.ArrayField("auditLog", "RoleAuditLog", true, "an audit log for role membership changes")
	sb.AddType(tRole.Build())

	tRoles := rdl.NewStructTypeBuilder("Struct", "Roles")
	tRoles.Comment("The representation for a list of roles with full details")
	tRoles.ArrayField("list", "Role", false, "list of role objects")
	sb.AddType(tRoles.Build())

	tMembership := rdl.NewStructTypeBuilder("Struct", "Membership")
	tMembership.Comment("The representation for a role membership.")
	tMembership.Field("memberName", "MemberName", false, nil, "name of the member")
	tMembership.Field("isMember", "Bool", true, true, "flag to indicate whether or the user is a member or not")
	tMembership.Field("roleName", "ResourceName", true, nil, "name of the role")
	tMembership.Field("expiration", "Timestamp", true, nil, "the expiration timestamp")
	tMembership.Field("reviewReminder", "Timestamp", true, nil, "the review reminder timestamp")
	tMembership.Field("active", "Bool", true, true, "Flag to indicate whether membership is active")
	tMembership.Field("approved", "Bool", true, true, "Flag to indicate whether membership is approved either by delegates ( in case of auditEnabled roles ) or by domain admins ( in case of selfserve roles )")
	tMembership.Field("auditRef", "String", true, nil, "audit reference string for the change as supplied by admin")
	tMembership.Field("requestPrincipal", "ResourceName", true, nil, "pending members only - name of the principal requesting the change")
	tMembership.Field("systemDisabled", "Int32", true, nil, "user disabled by system based on configured role setting")
	tMembership.Field("pendingState", "String", true, nil, "for pending membership requests, the request state - e.g. add, delete")
	sb.AddType(tMembership.Build())

	tDefaultAdmins := rdl.NewStructTypeBuilder("Struct", "DefaultAdmins")
	tDefaultAdmins.Comment("The list of domain administrators.")
	tDefaultAdmins.ArrayField("admins", "ResourceName", false, "list of domain administrators")
	sb.AddType(tDefaultAdmins.Build())

	tMemberRole := rdl.NewStructTypeBuilder("Struct", "MemberRole")
	tMemberRole.Field("roleName", "ResourceName", false, nil, "name of the role")
	tMemberRole.Field("domainName", "DomainName", true, nil, "name of the domain")
	tMemberRole.Field("memberName", "MemberName", true, nil, "name of the member")
	tMemberRole.Field("expiration", "Timestamp", true, nil, "the expiration timestamp")
	tMemberRole.Field("reviewReminder", "Timestamp", true, nil, "the review reminder timestamp")
	tMemberRole.Field("active", "Bool", true, true, "Flag to indicate whether membership is active")
	tMemberRole.Field("auditRef", "String", true, nil, "audit reference string for the change as supplied by admin")
	tMemberRole.Field("requestPrincipal", "EntityName", true, nil, "pending members only - name of the principal requesting the change")
	tMemberRole.Field("requestTime", "Timestamp", true, nil, "for pending membership requests, the request time")
	tMemberRole.Field("systemDisabled", "Int32", true, nil, "user disabled by system based on configured role setting")
	tMemberRole.Field("pendingState", "String", true, nil, "for pending membership requests, the request state - e.g. add, delete")
	tMemberRole.Field("trustRoleName", "ResourceName", true, nil, "name of the role that handles the membership delegation for the role specified in roleName")
	tMemberRole.Field("notifyRoles", "String", true, nil, "list of roles whose members should be notified for member review/approval/expiry")
	tMemberRole.Field("notifyDetails", "String", true, nil, "additional details included in the notifications")
	sb.AddType(tMemberRole.Build())

	tDomainRoleMember := rdl.NewStructTypeBuilder("Struct", "DomainRoleMember")
	tDomainRoleMember.Field("memberName", "MemberName", false, nil, "name of the member")
	tDomainRoleMember.ArrayField("memberRoles", "MemberRole", false, "roles for this member")
	sb.AddType(tDomainRoleMember.Build())

	tDomainRoleMembers := rdl.NewStructTypeBuilder("Struct", "DomainRoleMembers")
	tDomainRoleMembers.Field("domainName", "DomainName", false, nil, "name of the domain")
	tDomainRoleMembers.ArrayField("members", "DomainRoleMember", false, "role members")
	sb.AddType(tDomainRoleMembers.Build())

	tRoleSystemMeta := rdl.NewStructTypeBuilder("Struct", "RoleSystemMeta")
	tRoleSystemMeta.Comment("Set of system metadata attributes that all roles may have and can be changed by system admins.")
	tRoleSystemMeta.Field("auditEnabled", "Bool", true, false, "Flag indicates whether or not role updates should be approved by GRC. If true, the auditRef parameter must be supplied(not empty) for any API defining it.")
	sb.AddType(tRoleSystemMeta.Build())

	tAssertionEffect := rdl.NewEnumTypeBuilder("Enum", "AssertionEffect")
	tAssertionEffect.Comment("Every assertion can have the effect of ALLOW or DENY.")
	tAssertionEffect.Element("ALLOW", "")
	tAssertionEffect.Element("DENY", "")
	sb.AddType(tAssertionEffect.Build())

	tAssertionConditionOperator := rdl.NewEnumTypeBuilder("Enum", "AssertionConditionOperator")
	tAssertionConditionOperator.Comment("Allowed operators for assertion conditions")
	tAssertionConditionOperator.Element("EQUALS", "")
	sb.AddType(tAssertionConditionOperator.Build())

	tAssertionConditionData := rdl.NewStructTypeBuilder("Struct", "AssertionConditionData")
	tAssertionConditionData.Comment("A representation of details associated with an assertion condition key")
	tAssertionConditionData.Field("operator", "AssertionConditionOperator", false, nil, "Operator for the assertion condition")
	tAssertionConditionData.Field("value", "AssertionConditionValue", false, nil, "Value of the assertion condition")
	sb.AddType(tAssertionConditionData.Build())

	tAssertionCondition := rdl.NewStructTypeBuilder("Struct", "AssertionCondition")
	tAssertionCondition.Comment("A representation of condition associated with an assertion")
	tAssertionCondition.Field("id", "Int32", true, nil, "condition id - auto generated by server. Not required during put operations.")
	tAssertionCondition.MapField("conditionsMap", "AssertionConditionKey", "AssertionConditionData", false, "each key in the map represents a unique condition. All the keys present in the map form a logical condition with AND operation.")
	sb.AddType(tAssertionCondition.Build())

	tAssertionConditions := rdl.NewStructTypeBuilder("Struct", "AssertionConditions")
	tAssertionConditions.Comment("The representation of list of assertion conditions")
	tAssertionConditions.ArrayField("conditionsList", "AssertionCondition", false, "list of assertion conditions.")
	sb.AddType(tAssertionConditions.Build())

	tAssertion := rdl.NewStructTypeBuilder("Struct", "Assertion")
	tAssertion.Comment("A representation for the encapsulation of an action to be performed on a resource by a principal.")
	tAssertion.Field("role", "String", false, nil, "the subject of the assertion - a role")
	tAssertion.Field("resource", "String", false, nil, "the object of the assertion. Must be in the local namespace. Can contain wildcards")
	tAssertion.Field("action", "String", false, nil, "the predicate of the assertion. Can contain wildcards")
	tAssertion.Field("effect", "AssertionEffect", true, ALLOW, "the effect of the assertion in the policy language")
	tAssertion.Field("id", "Int64", true, nil, "assertion id - auto generated by server. Not required during put operations.")
	tAssertion.Field("caseSensitive", "Bool", true, nil, "If true, we should store action and resource in their original case")
	tAssertion.Field("conditions", "AssertionConditions", true, nil, "optional list of assertion conditions associated with given assertion")
	sb.AddType(tAssertion.Build())

	tResourcePolicyOwnership := rdl.NewStructTypeBuilder("Struct", "ResourcePolicyOwnership")
	tResourcePolicyOwnership.Comment("The representation of the policy ownership object")
	tResourcePolicyOwnership.Field("assertionsOwner", "SimpleName", true, nil, "owner of the object's assertions attribute")
	tResourcePolicyOwnership.Field("objectOwner", "SimpleName", true, nil, "owner of the object itself - checked for object deletion")
	sb.AddType(tResourcePolicyOwnership.Build())

	tPolicy := rdl.NewStructTypeBuilder("Struct", "Policy")
	tPolicy.Comment("The representation for a Policy with set of assertions.")
	tPolicy.Field("name", "ResourceName", false, nil, "name of the policy")
	tPolicy.Field("modified", "Timestamp", true, nil, "last modification timestamp of this policy")
	tPolicy.ArrayField("assertions", "Assertion", false, "list of defined assertions for this policy")
	tPolicy.Field("caseSensitive", "Bool", true, nil, "If true, we should store action and resource in their original case")
	tPolicy.Field("version", "SimpleName", true, nil, "optional version string, defaults to 0")
	tPolicy.Field("active", "Bool", true, nil, "if multi-version policy then indicates active version")
	tPolicy.Field("description", "String", true, nil, "a description of the policy")
	tPolicy.MapField("tags", "TagKey", "TagValueList", true, "key-value pair tags, tag might contain multiple values")
	tPolicy.Field("resourceOwnership", "ResourcePolicyOwnership", true, nil, "ownership information for the policy (read-only attribute)")
	sb.AddType(tPolicy.Build())

	tPolicies := rdl.NewStructTypeBuilder("Struct", "Policies")
	tPolicies.Comment("The representation of list of policy objects")
	tPolicies.ArrayField("list", "Policy", false, "list of policy objects")
	sb.AddType(tPolicies.Build())

	tPolicyOptions := rdl.NewStructTypeBuilder("Struct", "PolicyOptions")
	tPolicyOptions.Comment("Options for Policy Management Requests")
	tPolicyOptions.Field("version", "SimpleName", false, nil, "policy version")
	tPolicyOptions.Field("fromVersion", "SimpleName", true, nil, "optional source version used when creating a new version, defaults to 0")
	sb.AddType(tPolicyOptions.Build())

	tPublicKeyEntry := rdl.NewStructTypeBuilder("Struct", "PublicKeyEntry")
	tPublicKeyEntry.Comment("The representation of the public key in a service identity object.")
	tPublicKeyEntry.Field("key", "String", false, nil, "the public key for the service")
	tPublicKeyEntry.Field("id", "String", false, nil, "the key identifier (version or zone name)")
	sb.AddType(tPublicKeyEntry.Build())

	tCredsEntry := rdl.NewStructTypeBuilder("Struct", "CredsEntry")
	tCredsEntry.Comment("The representation of the credentials for a service identity object.")
	tCredsEntry.Field("value", "String", true, nil, "the secret for the service")
	sb.AddType(tCredsEntry.Build())

	tResourceServiceIdentityOwnership := rdl.NewStructTypeBuilder("Struct", "ResourceServiceIdentityOwnership")
	tResourceServiceIdentityOwnership.Comment("The representation of the service identity ownership object")
	tResourceServiceIdentityOwnership.Field("publicKeysOwner", "SimpleName", true, nil, "owner of the object's public keys attribute")
	tResourceServiceIdentityOwnership.Field("hostsOwner", "SimpleName", true, nil, "owner of the object's host list attribute")
	tResourceServiceIdentityOwnership.Field("objectOwner", "SimpleName", true, nil, "owner of the object itself - checked for object deletion")
	sb.AddType(tResourceServiceIdentityOwnership.Build())

	tServiceIdentity := rdl.NewStructTypeBuilder("Struct", "ServiceIdentity")
	tServiceIdentity.Comment("The representation of the service identity object.")
	tServiceIdentity.Field("name", "ServiceName", false, nil, "the full name of the service, i.e. \"sports.storage\"")
	tServiceIdentity.Field("description", "String", true, nil, "description of the service")
	tServiceIdentity.ArrayField("publicKeys", "PublicKeyEntry", true, "array of public keys for key rotation")
	tServiceIdentity.Field("providerEndpoint", "String", true, nil, "if present, then this service can provision tenants via this endpoint.")
	tServiceIdentity.Field("modified", "Timestamp", true, nil, "the timestamp when this entry was last modified")
	tServiceIdentity.Field("executable", "String", true, nil, "the path of the executable that runs the service")
	tServiceIdentity.ArrayField("hosts", "String", true, "list of host names that this service can run on")
	tServiceIdentity.Field("user", "String", true, nil, "local (unix) user name this service can run as")
	tServiceIdentity.Field("group", "String", true, nil, "local (unix) group name this service can run as")
	tServiceIdentity.MapField("tags", "TagKey", "TagValueList", true, "key-value pair tags, tag might contain multiple values")
	tServiceIdentity.Field("resourceOwnership", "ResourceServiceIdentityOwnership", true, nil, "ownership information for the service (read-only attribute)")
	tServiceIdentity.Field("x509CertSignerKeyId", "String", true, nil, "requested x509 cert signer key id (system attribute)")
	tServiceIdentity.Field("sshCertSignerKeyId", "String", true, nil, "requested ssh cert signer key id (system attribute)")
	tServiceIdentity.Field("creds", "String", true, nil, "the credentials for the service")
	sb.AddType(tServiceIdentity.Build())

	tServiceIdentities := rdl.NewStructTypeBuilder("Struct", "ServiceIdentities")
	tServiceIdentities.Comment("The representation of list of services")
	tServiceIdentities.ArrayField("list", "ServiceIdentity", false, "list of services")
	tServiceIdentities.Field("serviceMatchCount", "Int64", false, nil, "if set, the value indicates the total number of services in the system that match the query criteria but not returned due to limit constraints; thus, the result in the list is a partial set.")
	sb.AddType(tServiceIdentities.Build())

	tServiceIdentityList := rdl.NewStructTypeBuilder("Struct", "ServiceIdentityList")
	tServiceIdentityList.Comment("The representation for an enumeration of services in the namespace, with pagination.")
	tServiceIdentityList.ArrayField("names", "EntityName", false, "list of service names")
	tServiceIdentityList.Field("next", "String", true, nil, "if the response is a paginated list, this attribute specifies the value to be used in the next service list request as the value for the skip query parameter.")
	sb.AddType(tServiceIdentityList.Build())

	tServiceIdentitySystemMeta := rdl.NewStructTypeBuilder("Struct", "ServiceIdentitySystemMeta")
	tServiceIdentitySystemMeta.Comment("Set of system metadata attributes that all services may have and can be changed by system admins.")
	tServiceIdentitySystemMeta.Field("providerEndpoint", "String", true, nil, "provider callback endpoint")
	tServiceIdentitySystemMeta.Field("x509CertSignerKeyId", "String", true, nil, "requested x509 cert signer key id")
	tServiceIdentitySystemMeta.Field("sshCertSignerKeyId", "String", true, nil, "requested ssh cert signer key id")
	sb.AddType(tServiceIdentitySystemMeta.Build())

	tGroupAuditLog := rdl.NewStructTypeBuilder("Struct", "GroupAuditLog")
	tGroupAuditLog.Comment("An audit log entry for group membership change.")
	tGroupAuditLog.Field("member", "GroupMemberName", false, nil, "name of the group member")
	tGroupAuditLog.Field("admin", "ResourceName", false, nil, "name of the principal executing the change")
	tGroupAuditLog.Field("created", "Timestamp", false, nil, "timestamp of the entry")
	tGroupAuditLog.Field("action", "String", false, nil, "log action - e.g. add, delete, approve, etc")
	tGroupAuditLog.Field("auditRef", "String", true, nil, "audit reference string for the change as supplied by admin")
	sb.AddType(tGroupAuditLog.Build())

	tGroupMember := rdl.NewStructTypeBuilder("Struct", "GroupMember")
	tGroupMember.Field("memberName", "GroupMemberName", true, nil, "name of the member")
	tGroupMember.Field("groupName", "ResourceName", true, nil, "name of the group")
	tGroupMember.Field("domainName", "DomainName", true, nil, "name of the domain")
	tGroupMember.Field("expiration", "Timestamp", true, nil, "the expiration timestamp")
	tGroupMember.Field("active", "Bool", true, true, "Flag to indicate whether membership is active")
	tGroupMember.Field("approved", "Bool", true, true, "Flag to indicate whether membership is approved either by delegates ( in case of auditEnabled groups ) or by domain admins ( in case of selfserve groups )")
	tGroupMember.Field("auditRef", "String", true, nil, "audit reference string for the change as supplied by admin")
	tGroupMember.Field("requestTime", "Timestamp", true, nil, "for pending membership requests, the request time")
	tGroupMember.Field("lastNotifiedTime", "Timestamp", true, nil, "for pending membership requests, time when last notification was sent")
	tGroupMember.Field("requestPrincipal", "ResourceName", true, nil, "pending members only - name of the principal requesting the change")
	tGroupMember.Field("reviewLastNotifiedTime", "Timestamp", true, nil, "for pending membership requests, time when last notification was sent (for file store)")
	tGroupMember.Field("systemDisabled", "Int32", true, nil, "user disabled by system based on configured group setting")
	tGroupMember.Field("principalType", "Int32", true, nil, "server use only - principal type: unknown(0), user(1) or service(2)")
	tGroupMember.Field("pendingState", "String", true, nil, "for pending membership requests, the request state - e.g. add, delete")
	tGroupMember.Field("notifyRoles", "String", true, nil, "list of roles whose members should be notified for member review/approval/expiry")
	tGroupMember.Field("notifyDetails", "String", true, nil, "additional details included in the notifications")
	sb.AddType(tGroupMember.Build())

	tGroupMembership := rdl.NewStructTypeBuilder("Struct", "GroupMembership")
	tGroupMembership.Comment("The representation for a group membership.")
	tGroupMembership.Field("memberName", "GroupMemberName", false, nil, "name of the member")
	tGroupMembership.Field("isMember", "Bool", true, true, "flag to indicate whether or the user is a member or not")
	tGroupMembership.Field("groupName", "ResourceName", true, nil, "name of the group")
	tGroupMembership.Field("expiration", "Timestamp", true, nil, "the expiration timestamp")
	tGroupMembership.Field("active", "Bool", true, true, "Flag to indicate whether membership is active")
	tGroupMembership.Field("approved", "Bool", true, true, "Flag to indicate whether membership is approved either by delegates ( in case of auditEnabled groups ) or by domain admins ( in case of selfserve groups )")
	tGroupMembership.Field("auditRef", "String", true, nil, "audit reference string for the change as supplied by admin")
	tGroupMembership.Field("requestPrincipal", "ResourceName", true, nil, "pending members only - name of the principal requesting the change")
	tGroupMembership.Field("systemDisabled", "Int32", true, nil, "user disabled by system based on configured group setting")
	tGroupMembership.Field("pendingState", "String", true, nil, "for pending membership requests, the request state - e.g. add, delete")
	sb.AddType(tGroupMembership.Build())

	tResourceGroupOwnership := rdl.NewStructTypeBuilder("Struct", "ResourceGroupOwnership")
	tResourceGroupOwnership.Comment("The representation of the group ownership object")
	tResourceGroupOwnership.Field("metaOwner", "SimpleName", true, nil, "owner of the object's meta attribute")
	tResourceGroupOwnership.Field("membersOwner", "SimpleName", true, nil, "owner of the object's members attribute")
	tResourceGroupOwnership.Field("objectOwner", "SimpleName", true, nil, "owner of the object itself - checked for object deletion")
	sb.AddType(tResourceGroupOwnership.Build())

	tGroupMeta := rdl.NewStructTypeBuilder("Struct", "GroupMeta")
	tGroupMeta.Comment("Set of metadata attributes that all groups may have and can be changed by domain admins.")
	tGroupMeta.Field("selfServe", "Bool", true, false, "Flag indicates whether or not group allows self service. Users can add themselves in the group, but it has to be approved by domain admins to be effective.")
	tGroupMeta.Field("reviewEnabled", "Bool", true, false, "Flag indicates whether or not group updates require another review and approval")
	tGroupMeta.Field("notifyRoles", "String", true, nil, "list of roles whose members should be notified for member review/approval")
	tGroupMeta.Field("userAuthorityFilter", "String", true, nil, "membership filtered based on user authority configured attributes")
	tGroupMeta.Field("userAuthorityExpiration", "String", true, nil, "expiration enforced by a user authority configured attribute")
	tGroupMeta.Field("memberExpiryDays", "Int32", true, nil, "all user members in the group will have specified max expiry days")
	tGroupMeta.Field("serviceExpiryDays", "Int32", true, nil, "all services in the group will have specified max expiry days")
	tGroupMeta.MapField("tags", "TagKey", "TagValueList", true, "key-value pair tags, tag might contain multiple values")
	tGroupMeta.Field("auditEnabled", "Bool", true, false, "Flag indicates whether or not group updates should require GRC approval. If true, the auditRef parameter must be supplied(not empty) for any API defining it")
	tGroupMeta.Field("deleteProtection", "Bool", true, false, "If true, ask for delete confirmation in audit and review enabled groups.")
	tGroupMeta.Field("lastReviewedDate", "Timestamp", true, nil, "last review timestamp of the group")
	tGroupMeta.Field("selfRenew", "Bool", true, nil, "Flag indicates whether to allow expired members to renew their membership")
	tGroupMeta.Field("selfRenewMins", "Int32", true, nil, "Number of minutes members can renew their membership if self review option is enabled")
	tGroupMeta.Field("maxMembers", "Int32", true, nil, "Maximum number of members allowed in the group")
	tGroupMeta.Field("resourceOwnership", "ResourceGroupOwnership", true, nil, "ownership information for the group (read-only attribute)")
	tGroupMeta.Field("principalDomainFilter", "String", true, nil, "membership filtered based on configured principal domains")
	tGroupMeta.Field("notifyDetails", "String", true, nil, "additional details included in the notifications")
	sb.AddType(tGroupMeta.Build())

	tGroup := rdl.NewStructTypeBuilder("GroupMeta", "Group")
	tGroup.Comment("The representation for a Group with set of members.")
	tGroup.Field("name", "ResourceName", false, nil, "name of the group")
	tGroup.Field("modified", "Timestamp", true, nil, "last modification timestamp of the group")
	tGroup.ArrayField("groupMembers", "GroupMember", true, "members with expiration")
	tGroup.ArrayField("auditLog", "GroupAuditLog", true, "an audit log for group membership changes")
	sb.AddType(tGroup.Build())

	tGroups := rdl.NewStructTypeBuilder("Struct", "Groups")
	tGroups.Comment("The representation for a list of groups with full details")
	tGroups.ArrayField("list", "Group", false, "list of group objects")
	sb.AddType(tGroups.Build())

	tDomainGroupMember := rdl.NewStructTypeBuilder("Struct", "DomainGroupMember")
	tDomainGroupMember.Field("memberName", "GroupMemberName", false, nil, "name of the member")
	tDomainGroupMember.ArrayField("memberGroups", "GroupMember", false, "groups for this member")
	sb.AddType(tDomainGroupMember.Build())

	tDomainGroupMembers := rdl.NewStructTypeBuilder("Struct", "DomainGroupMembers")
	tDomainGroupMembers.Field("domainName", "DomainName", false, nil, "name of the domain")
	tDomainGroupMembers.ArrayField("members", "DomainGroupMember", false, "group members")
	sb.AddType(tDomainGroupMembers.Build())

	tDomainGroupMembership := rdl.NewStructTypeBuilder("Struct", "DomainGroupMembership")
	tDomainGroupMembership.ArrayField("domainGroupMembersList", "DomainGroupMembers", false, "")
	sb.AddType(tDomainGroupMembership.Build())

	tGroupSystemMeta := rdl.NewStructTypeBuilder("Struct", "GroupSystemMeta")
	tGroupSystemMeta.Comment("Set of system metadata attributes that all groups may have and can be changed by system admins.")
	tGroupSystemMeta.Field("auditEnabled", "Bool", true, false, "Flag indicates whether or not group updates should be approved by GRC. If true, the auditRef parameter must be supplied(not empty) for any API defining it.")
	sb.AddType(tGroupSystemMeta.Build())

	tTemplateMetaData := rdl.NewStructTypeBuilder("Struct", "TemplateMetaData")
	tTemplateMetaData.Comment("MetaData for template.")
	tTemplateMetaData.Field("templateName", "String", true, nil, "name of the template")
	tTemplateMetaData.Field("description", "String", true, nil, "description of the template")
	tTemplateMetaData.Field("currentVersion", "Int32", true, nil, "Version from DB(zms_store->domain_template->version)")
	tTemplateMetaData.Field("latestVersion", "Int32", true, nil, "Bumped up version from solutions-template.json when there is a change")
	tTemplateMetaData.Field("keywordsToReplace", "String", true, nil, "placeholders in the template roles/policies to replace (ex:_service_)")
	tTemplateMetaData.Field("timestamp", "Timestamp", true, nil, "the updated timestamp of the template(solution_templates.json)")
	tTemplateMetaData.Field("autoUpdate", "Bool", true, nil, "flag to automatically update the roles/policies that belongs to the template")
	sb.AddType(tTemplateMetaData.Build())

	tTemplate := rdl.NewStructTypeBuilder("Struct", "Template")
	tTemplate.Comment("Solution Template object defined on the server")
	tTemplate.ArrayField("roles", "Role", false, "list of roles in the template")
	tTemplate.ArrayField("policies", "Policy", false, "list of policies defined in this template")
	tTemplate.ArrayField("groups", "Group", true, "list of groups defined in this template")
	tTemplate.ArrayField("services", "ServiceIdentity", true, "list of services defined in this template")
	tTemplate.Field("metadata", "TemplateMetaData", true, nil, "list of services defined in this template")
	sb.AddType(tTemplate.Build())

	tTemplateList := rdl.NewStructTypeBuilder("Struct", "TemplateList")
	tTemplateList.Comment("List of template names that is the base struct for server and domain templates")
	tTemplateList.ArrayField("templateNames", "SimpleName", false, "list of template names")
	sb.AddType(tTemplateList.Build())

	tTemplateParam := rdl.NewStructTypeBuilder("Struct", "TemplateParam")
	tTemplateParam.Field("name", "SimpleName", false, nil, "name of the parameter")
	tTemplateParam.Field("value", "String", false, nil, "value of the parameter")
	sb.AddType(tTemplateParam.Build())

	tDomainTemplate := rdl.NewStructTypeBuilder("TemplateList", "DomainTemplate")
	tDomainTemplate.Comment("solution template(s) to be applied to a domain")
	tDomainTemplate.ArrayField("params", "TemplateParam", true, "optional template parameters")
	sb.AddType(tDomainTemplate.Build())

	tDomainTemplateList := rdl.NewStructTypeBuilder("TemplateList", "DomainTemplateList")
	tDomainTemplateList.Comment("List of solution templates to be applied to a domain")
	sb.AddType(tDomainTemplateList.Build())

	tServerTemplateList := rdl.NewStructTypeBuilder("TemplateList", "ServerTemplateList")
	tServerTemplateList.Comment("List of solution templates available in the server")
	sb.AddType(tServerTemplateList.Build())

	tDomainTemplateDetailsList := rdl.NewStructTypeBuilder("Struct", "DomainTemplateDetailsList")
	tDomainTemplateDetailsList.Comment("List of templates with metadata details given a domain")
	tDomainTemplateDetailsList.ArrayField("metaData", "TemplateMetaData", false, "list of template metadata")
	sb.AddType(tDomainTemplateDetailsList.Build())

	tTopLevelDomain := rdl.NewStructTypeBuilder("DomainMeta", "TopLevelDomain")
	tTopLevelDomain.Comment("Top Level Domain object. The required attributes include the name of the domain and list of domain administrators.")
	tTopLevelDomain.Field("name", "SimpleName", false, nil, "name of the domain")
	tTopLevelDomain.ArrayField("adminUsers", "ResourceName", false, "list of domain administrators")
	tTopLevelDomain.Field("templates", "DomainTemplateList", true, nil, "list of solution template names")
	sb.AddType(tTopLevelDomain.Build())

	tSubDomain := rdl.NewStructTypeBuilder("TopLevelDomain", "SubDomain")
	tSubDomain.Comment("A Subdomain is a TopLevelDomain, except it has a parent.")
	tSubDomain.Field("parent", "DomainName", false, nil, "name of the parent domain")
	sb.AddType(tSubDomain.Build())

	tUserDomain := rdl.NewStructTypeBuilder("DomainMeta", "UserDomain")
	tUserDomain.Comment("A UserDomain is the user's own top level domain in user - e.g. user.hga")
	tUserDomain.Field("name", "SimpleName", false, nil, "user id which will be the domain name")
	tUserDomain.Field("templates", "DomainTemplateList", true, nil, "list of solution template names")
	sb.AddType(tUserDomain.Build())

	tDomainMetaStoreValidValuesList := rdl.NewStructTypeBuilder("Struct", "DomainMetaStoreValidValuesList")
	tDomainMetaStoreValidValuesList.Comment("List of valid domain meta attribute values")
	tDomainMetaStoreValidValuesList.ArrayField("validValues", "String", false, "list of valid values for attribute")
	sb.AddType(tDomainMetaStoreValidValuesList.Build())

	tAuthHistory := rdl.NewStructTypeBuilder("Struct", "AuthHistory")
	tAuthHistory.Field("uriDomain", "DomainName", true, nil, "Name of the domain from URI")
	tAuthHistory.Field("principalDomain", "DomainName", true, nil, "Principal domain")
	tAuthHistory.Field("principalName", "SimpleName", true, nil, "Principal name")
	tAuthHistory.Field("timestamp", "Timestamp", true, nil, "Last authorization event timestamp")
	tAuthHistory.Field("endpoint", "String", true, nil, "Last authorization endpoint used")
	tAuthHistory.Field("ttl", "Int64", false, nil, "Time until the record will expire")
	sb.AddType(tAuthHistory.Build())

	tAuthHistoryDependencies := rdl.NewStructTypeBuilder("Struct", "AuthHistoryDependencies")
	tAuthHistoryDependencies.ArrayField("incomingDependencies", "AuthHistory", false, "list of incoming auth dependencies for domain")
	tAuthHistoryDependencies.ArrayField("outgoingDependencies", "AuthHistory", false, "list of incoming auth dependencies for domain")
	sb.AddType(tAuthHistoryDependencies.Build())

	tExpiryMember := rdl.NewStructTypeBuilder("Struct", "ExpiryMember")
	tExpiryMember.Field("domainName", "DomainName", false, nil, "name of the domain")
	tExpiryMember.Field("collectionName", "EntityName", false, nil, "name of the collection")
	tExpiryMember.Field("principalName", "ResourceName", false, nil, "name of the principal")
	tExpiryMember.Field("expiration", "Timestamp", false, nil, "the expiration timestamp")
	sb.AddType(tExpiryMember.Build())

	tExpiredMembers := rdl.NewStructTypeBuilder("Struct", "ExpiredMembers")
	tExpiredMembers.ArrayField("expiredRoleMembers", "ExpiryMember", false, "list of deleted expired role members")
	tExpiredMembers.ArrayField("expiredGroupMembers", "ExpiryMember", false, "list of deleted expired groups members")
	sb.AddType(tExpiredMembers.Build())

	tDanglingPolicy := rdl.NewStructTypeBuilder("Struct", "DanglingPolicy")
	tDanglingPolicy.Comment("A dangling policy where the assertion is referencing a role name that doesn't exist in the domain")
	tDanglingPolicy.Field("policyName", "EntityName", false, nil, "")
	tDanglingPolicy.Field("roleName", "EntityName", false, nil, "")
	sb.AddType(tDanglingPolicy.Build())

	tDomainDataCheck := rdl.NewStructTypeBuilder("Struct", "DomainDataCheck")
	tDomainDataCheck.Comment("Domain data object representing the results of a check operation looking for dangling roles, policies and trust relationships that are set either on tenant or provider side only")
	tDomainDataCheck.ArrayField("danglingRoles", "EntityName", true, "Names of roles not specified in any assertion. Might be empty or null if no dangling roles.")
	tDomainDataCheck.ArrayField("danglingPolicies", "DanglingPolicy", true, "Policy+role tuples where role doesnt exist. Might be empty or null if no dangling policies.")
	tDomainDataCheck.Field("policyCount", "Int32", false, nil, "total number of policies")
	tDomainDataCheck.Field("assertionCount", "Int32", false, nil, "total number of assertions")
	tDomainDataCheck.Field("roleWildCardCount", "Int32", false, nil, "total number of assertions containing roles as wildcards")
	tDomainDataCheck.ArrayField("providersWithoutTrust", "ServiceName", true, "Service names (domain.service) that dont contain trust role if this is a tenant domain. Might be empty or null, if not a tenant or if all providers support this tenant.")
	tDomainDataCheck.ArrayField("tenantsWithoutAssumeRole", "DomainName", true, "Names of Tenant domains that dont contain assume role assertions if this is a provider domain. Might be empty or null, if not a provider or if all tenants support use this provider.")
	sb.AddType(tDomainDataCheck.Build())

	tEntity := rdl.NewStructTypeBuilder("Struct", "Entity")
	tEntity.Comment("An entity is a name and a structured value. some entity names/prefixes are reserved (i.e. \"role\",  \"policy\", \"meta\", \"domain\", \"service\")")
	tEntity.Field("name", "ResourceName", false, nil, "name of the entity object")
	tEntity.Field("value", "Struct", false, nil, "value of the entity")
	sb.AddType(tEntity.Build())

	tEntityList := rdl.NewStructTypeBuilder("Struct", "EntityList")
	tEntityList.Comment("The representation for an enumeration of entities in the namespace")
	tEntityList.ArrayField("names", "EntityName", false, "list of entity names")
	sb.AddType(tEntityList.Build())

	tPolicyList := rdl.NewStructTypeBuilder("Struct", "PolicyList")
	tPolicyList.Comment("The representation for an enumeration of policies in the namespace, with pagination.")
	tPolicyList.ArrayField("names", "EntityName", false, "list of policy names")
	tPolicyList.Field("next", "String", true, nil, "if the response is a paginated list, this attribute specifies the value to be used in the next policy list request as the value for the skip query parameter.")
	sb.AddType(tPolicyList.Build())

	tTenancy := rdl.NewStructTypeBuilder("Struct", "Tenancy")
	tTenancy.Comment("A representation of tenant.")
	tTenancy.Field("domain", "DomainName", false, nil, "the domain that is to get a tenancy")
	tTenancy.Field("service", "ServiceName", false, nil, "the provider service on which the tenancy is to reside")
	tTenancy.ArrayField("resourceGroups", "EntityName", true, "registered resource groups for this tenant")
	tTenancy.Field("createAdminRole", "Bool", true, true, "optional flag indicating whether to create a default tenancy admin role")
	sb.AddType(tTenancy.Build())

	tTenantRoleAction := rdl.NewStructTypeBuilder("Struct", "TenantRoleAction")
	tTenantRoleAction.Comment("A representation of tenant role action.")
	tTenantRoleAction.Field("role", "SimpleName", false, nil, "name of the role")
	tTenantRoleAction.Field("action", "String", false, nil, "action value for the generated policy assertion")
	sb.AddType(tTenantRoleAction.Build())

	tTenantResourceGroupRoles := rdl.NewStructTypeBuilder("Struct", "TenantResourceGroupRoles")
	tTenantResourceGroupRoles.Comment("A representation of tenant roles for resource groups to be provisioned.")
	tTenantResourceGroupRoles.Field("domain", "DomainName", false, nil, "name of the provider domain")
	tTenantResourceGroupRoles.Field("service", "SimpleName", false, nil, "name of the provider service")
	tTenantResourceGroupRoles.Field("tenant", "DomainName", false, nil, "name of the tenant domain")
	tTenantResourceGroupRoles.ArrayField("roles", "TenantRoleAction", false, "the role/action pairs to provision")
	tTenantResourceGroupRoles.Field("resourceGroup", "EntityName", false, nil, "tenant resource group")
	sb.AddType(tTenantResourceGroupRoles.Build())

	tProviderResourceGroupRoles := rdl.NewStructTypeBuilder("Struct", "ProviderResourceGroupRoles")
	tProviderResourceGroupRoles.Comment("A representation of provider roles to be provisioned.")
	tProviderResourceGroupRoles.Field("domain", "DomainName", false, nil, "name of the provider domain")
	tProviderResourceGroupRoles.Field("service", "SimpleName", false, nil, "name of the provider service")
	tProviderResourceGroupRoles.Field("tenant", "DomainName", false, nil, "name of the tenant domain")
	tProviderResourceGroupRoles.ArrayField("roles", "TenantRoleAction", false, "the role/action pairs to provision")
	tProviderResourceGroupRoles.Field("resourceGroup", "EntityName", false, nil, "tenant resource group")
	tProviderResourceGroupRoles.Field("createAdminRole", "Bool", true, true, "optional flag indicating whether to create a default tenancy admin role")
	tProviderResourceGroupRoles.Field("skipPrincipalMember", "Bool", true, false, "optional flag indicating to skip adding the caller principal into the resource role")
	sb.AddType(tProviderResourceGroupRoles.Build())

	tAccess := rdl.NewStructTypeBuilder("Struct", "Access")
	tAccess.Comment("Access can be checked and returned as this resource.")
	tAccess.Field("granted", "Bool", false, nil, "true (allowed) or false (denied)")
	sb.AddType(tAccess.Build())

	tResourceAccess := rdl.NewStructTypeBuilder("Struct", "ResourceAccess")
	tResourceAccess.Field("principal", "ResourceName", false, nil, "")
	tResourceAccess.ArrayField("assertions", "Assertion", false, "")
	sb.AddType(tResourceAccess.Build())

	tResourceAccessList := rdl.NewStructTypeBuilder("Struct", "ResourceAccessList")
	tResourceAccessList.ArrayField("resources", "ResourceAccess", false, "")
	sb.AddType(tResourceAccessList.Build())

	tDomainPolicies := rdl.NewStructTypeBuilder("Struct", "DomainPolicies")
	tDomainPolicies.Comment("We need to include the name of the domain in this struct since this data will be passed back to ZPU through ZTS so we need to sign not only the list of policies but also the corresponding domain name that the policies belong to.")
	tDomainPolicies.Field("domain", "DomainName", false, nil, "name of the domain")
	tDomainPolicies.ArrayField("policies", "Policy", false, "list of policies defined in this server")
	sb.AddType(tDomainPolicies.Build())

	tSignedPolicies := rdl.NewStructTypeBuilder("Struct", "SignedPolicies")
	tSignedPolicies.Comment("A signed bulk transfer of policies. The data is signed with server's private key.")
	tSignedPolicies.Field("contents", "DomainPolicies", false, nil, "list of policies defined in a domain")
	tSignedPolicies.Field("signature", "String", false, nil, "signature generated based on the domain active policies object")
	tSignedPolicies.Field("keyId", "String", false, nil, "the identifier of the key used to generate the signature")
	sb.AddType(tSignedPolicies.Build())

	tDomainData := rdl.NewStructTypeBuilder("DomainMeta", "DomainData")
	tDomainData.Comment("A domain object that includes its roles, policies and services.")
	tDomainData.Field("name", "DomainName", false, nil, "name of the domain")
	tDomainData.ArrayField("roles", "Role", false, "list of roles in the domain")
	tDomainData.Field("policies", "SignedPolicies", false, nil, "list of policies in the domain signed with ZMS private key")
	tDomainData.ArrayField("services", "ServiceIdentity", false, "list of services in the domain")
	tDomainData.ArrayField("entities", "Entity", false, "list of entities in the domain")
	tDomainData.ArrayField("groups", "Group", false, "list of groups in the domain")
	tDomainData.Field("modified", "Timestamp", false, nil, "last modification timestamp")
	sb.AddType(tDomainData.Build())

	tSignedDomain := rdl.NewStructTypeBuilder("Struct", "SignedDomain")
	tSignedDomain.Comment("A domain object signed with server's private key. The signature and keyid are optional if the metaonly flag is set to true in the getSignedDomains api call")
	tSignedDomain.Field("domain", "DomainData", false, nil, "domain object with its roles, policies and services")
	tSignedDomain.Field("signature", "String", true, nil, "signature generated based on the domain object")
	tSignedDomain.Field("keyId", "String", true, nil, "the identifier of the key used to generate the signature")
	sb.AddType(tSignedDomain.Build())

	tSignedDomains := rdl.NewStructTypeBuilder("Struct", "SignedDomains")
	tSignedDomains.Comment("A list of signed domain objects")
	tSignedDomains.ArrayField("domains", "SignedDomain", false, "")
	sb.AddType(tSignedDomains.Build())

	tJWSDomain := rdl.NewStructTypeBuilder("Struct", "JWSDomain")
	tJWSDomain.Comment("SignedDomain using flattened JWS JSON Serialization syntax. https://tools.ietf.org/html/rfc7515#section-7.2.2")
	tJWSDomain.Field("payload", "String", false, nil, "")
	tJWSDomain.Field("protected", "String", false, nil, "")
	tJWSDomain.MapField("header", "String", "String", false, "")
	tJWSDomain.Field("signature", "String", false, nil, "")
	sb.AddType(tJWSDomain.Build())

	tUserToken := rdl.NewStructTypeBuilder("Struct", "UserToken")
	tUserToken.Comment("A user token generated based on user's credentials")
	tUserToken.Field("token", "SignedToken", false, nil, "Signed user token identifying a specific authenticated user")
	tUserToken.Field("header", "String", true, nil, "Authorization header name for the token")
	sb.AddType(tUserToken.Build())

	tServicePrincipal := rdl.NewStructTypeBuilder("Struct", "ServicePrincipal")
	tServicePrincipal.Comment("A service principal object identifying a given service.")
	tServicePrincipal.Field("domain", "DomainName", false, nil, "name of the domain")
	tServicePrincipal.Field("service", "EntityName", false, nil, "name of the service")
	tServicePrincipal.Field("token", "SignedToken", false, nil, "service's signed token")
	sb.AddType(tServicePrincipal.Build())

	tUser := rdl.NewStructTypeBuilder("Struct", "User")
	tUser.Comment("The representation for a user")
	tUser.Field("name", "SimpleName", false, nil, "name of the user")
	sb.AddType(tUser.Build())

	tUserList := rdl.NewStructTypeBuilder("Struct", "UserList")
	tUserList.ArrayField("names", "SimpleName", false, "list of user names")
	sb.AddType(tUserList.Build())

	tQuota := rdl.NewStructTypeBuilder("Struct", "Quota")
	tQuota.Comment("The representation for a quota object")
	tQuota.Field("name", "DomainName", false, nil, "name of the domain object")
	tQuota.Field("subdomain", "Int32", false, nil, "number of subdomains allowed (applied at top level domain level)")
	tQuota.Field("role", "Int32", false, nil, "number of roles allowed")
	tQuota.Field("roleMember", "Int32", false, nil, "number of members a role may have")
	tQuota.Field("policy", "Int32", false, nil, "number of policies allowed")
	tQuota.Field("assertion", "Int32", false, nil, "total number of assertions a policy may have")
	tQuota.Field("entity", "Int32", false, nil, "total number of entity objects")
	tQuota.Field("service", "Int32", false, nil, "number of services allowed")
	tQuota.Field("serviceHost", "Int32", false, nil, "number of hosts allowed per service")
	tQuota.Field("publicKey", "Int32", false, nil, "number of public keys per service")
	tQuota.Field("group", "Int32", false, nil, "number of groups per domain")
	tQuota.Field("groupMember", "Int32", false, nil, "number of members a group may have")
	tQuota.Field("modified", "Timestamp", true, nil, "the last modification timestamp of the quota object")
	sb.AddType(tQuota.Build())

	tStatus := rdl.NewStructTypeBuilder("Struct", "Status")
	tStatus.Comment("The representation for a status object")
	tStatus.Field("code", "Int32", false, nil, "status message code")
	tStatus.Field("message", "String", false, nil, "status message of the server")
	sb.AddType(tStatus.Build())

	tDomainRoleMembership := rdl.NewStructTypeBuilder("Struct", "DomainRoleMembership")
	tDomainRoleMembership.ArrayField("domainRoleMembersList", "DomainRoleMembers", false, "")
	sb.AddType(tDomainRoleMembership.Build())

	tUserAuthorityAttributes := rdl.NewStructTypeBuilder("Struct", "UserAuthorityAttributes")
	tUserAuthorityAttributes.Comment("Copyright The Athenz Authors Licensed under the terms of the Apache version 2.0 license. See LICENSE file for terms.")
	tUserAuthorityAttributes.ArrayField("values", "String", false, "")
	sb.AddType(tUserAuthorityAttributes.Build())

	tUserAuthorityAttributeMap := rdl.NewStructTypeBuilder("Struct", "UserAuthorityAttributeMap")
	tUserAuthorityAttributeMap.Comment("Map of user authority attributes")
	tUserAuthorityAttributeMap.MapField("attributes", "SimpleName", "UserAuthorityAttributes", false, "map of type to attribute values")
	sb.AddType(tUserAuthorityAttributeMap.Build())

	tStats := rdl.NewStructTypeBuilder("Struct", "Stats")
	tStats.Comment("The representation for a stats object")
	tStats.Field("name", "DomainName", true, nil, "name of the domain object, null for system stats")
	tStats.Field("subdomain", "Int32", false, nil, "number of subdomains in this domain (all levels)")
	tStats.Field("role", "Int32", false, nil, "number of roles")
	tStats.Field("roleMember", "Int32", false, nil, "number of members in all the roles")
	tStats.Field("policy", "Int32", false, nil, "number of policies")
	tStats.Field("assertion", "Int32", false, nil, "total number of assertions in all policies")
	tStats.Field("entity", "Int32", false, nil, "total number of entity objects")
	tStats.Field("service", "Int32", false, nil, "number of services")
	tStats.Field("serviceHost", "Int32", false, nil, "number of hosts defined in all services")
	tStats.Field("publicKey", "Int32", false, nil, "number of public keys in all services")
	tStats.Field("group", "Int32", false, nil, "number of groups")
	tStats.Field("groupMember", "Int32", false, nil, "number of members in all the groups")
	sb.AddType(tStats.Build())

	tDependentService := rdl.NewStructTypeBuilder("Struct", "DependentService")
	tDependentService.Comment("Dependent service provider details")
	tDependentService.Field("service", "ServiceName", false, nil, "name of the service")
	sb.AddType(tDependentService.Build())

	tDependentServiceResourceGroup := rdl.NewStructTypeBuilder("Struct", "DependentServiceResourceGroup")
	tDependentServiceResourceGroup.Field("service", "ServiceName", false, nil, "name of the service")
	tDependentServiceResourceGroup.Field("domain", "DomainName", false, nil, "name of the dependent domain")
	tDependentServiceResourceGroup.ArrayField("resourceGroups", "EntityName", true, "registered resource groups for this service and domain")
	sb.AddType(tDependentServiceResourceGroup.Build())

	tDependentServiceResourceGroupList := rdl.NewStructTypeBuilder("Struct", "DependentServiceResourceGroupList")
	tDependentServiceResourceGroupList.ArrayField("serviceAndResourceGroups", "DependentServiceResourceGroup", false, "collection of dependent services and resource groups for tenant domain")
	sb.AddType(tDependentServiceResourceGroupList.Build())

	tReviewObject := rdl.NewStructTypeBuilder("Struct", "ReviewObject")
	tReviewObject.Comment("Details for the roles and/or groups that need to be reviewed")
	tReviewObject.Field("domainName", "DomainName", false, nil, "name of the domain")
	tReviewObject.Field("name", "EntityName", false, nil, "name of the role and/or group")
	tReviewObject.Field("memberExpiryDays", "Int32", false, nil, "all user members in the object have specified max expiry days")
	tReviewObject.Field("memberReviewDays", "Int32", false, nil, "all user members in the object have specified max review days")
	tReviewObject.Field("serviceExpiryDays", "Int32", false, nil, "all services in the object have specified max expiry days")
	tReviewObject.Field("serviceReviewDays", "Int32", false, nil, "all services in the object have specified max review days")
	tReviewObject.Field("groupExpiryDays", "Int32", false, nil, "all groups in the object have specified max expiry days")
	tReviewObject.Field("groupReviewDays", "Int32", false, nil, "all groups in the object have specified max review days")
	tReviewObject.Field("lastReviewedDate", "Timestamp", true, nil, "last review timestamp of the object")
	tReviewObject.Field("created", "Timestamp", false, nil, "creation time of the object")
	sb.AddType(tReviewObject.Build())

	tReviewObjects := rdl.NewStructTypeBuilder("Struct", "ReviewObjects")
	tReviewObjects.Comment("The representation for a list of objects with full details")
	tReviewObjects.ArrayField("list", "ReviewObject", false, "list of review objects")
	sb.AddType(tReviewObjects.Build())

	tInfo := rdl.NewStructTypeBuilder("Struct", "Info")
	tInfo.Comment("Copyright The Athenz Authors Licensed under the terms of the Apache version 2.0 license. See LICENSE file for terms. The representation for an info object")
	tInfo.Field("buildJdkSpec", "String", true, nil, "jdk build version")
	tInfo.Field("implementationTitle", "String", true, nil, "implementation title - e.g. athenz-zms-server")
	tInfo.Field("implementationVersion", "String", true, nil, "implementation version - e.g. 1.11.1")
	tInfo.Field("implementationVendor", "String", true, nil, "implementation vendor - Athenz")
	sb.AddType(tInfo.Build())

	tPrincipalMember := rdl.NewStructTypeBuilder("Struct", "PrincipalMember")
	tPrincipalMember.Field("principalName", "MemberName", false, nil, "name of the principal")
	tPrincipalMember.Field("suspendedState", "Int32", false, nil, "current system suspended state of the principal")
	sb.AddType(tPrincipalMember.Build())

	tPrincipalState := rdl.NewStructTypeBuilder("Struct", "PrincipalState")
	tPrincipalState.Comment("A principal state entry")
	tPrincipalState.Field("suspended", "Bool", false, nil, "athenz suspended state for the principal")
	sb.AddType(tPrincipalState.Build())

	tRdl_Identifier := rdl.NewStringTypeBuilder("rdl.Identifier")
	tRdl_Identifier.Comment("All names need to be of this restricted string type")
	tRdl_Identifier.Pattern("[a-zA-Z_]+[a-zA-Z_0-9]*")
	sb.AddType(tRdl_Identifier.Build())

	tRdl_NamespacedIdentifier := rdl.NewStringTypeBuilder("rdl.NamespacedIdentifier")
	tRdl_NamespacedIdentifier.Comment("A Namespace is a dotted compound name, using reverse domain name order (i.e. \"com.yahoo.auth\")")
	tRdl_NamespacedIdentifier.Pattern("([a-zA-Z_]+[a-zA-Z_0-9]*)(\\.[a-zA-Z_]+[a-zA-Z_0-9])*")
	sb.AddType(tRdl_NamespacedIdentifier.Build())

	tRdl_TypeName := rdl.NewAliasTypeBuilder("rdl.Identifier", "rdl.TypeName")
	tRdl_TypeName.Comment("The identifier for an already-defined type")
	sb.AddType(tRdl_TypeName.Build())

	tRdl_TypeRef := rdl.NewAliasTypeBuilder("rdl.NamespacedIdentifier", "rdl.TypeRef")
	tRdl_TypeRef.Comment("A type reference can be a simple name, or also a namespaced name.")
	sb.AddType(tRdl_TypeRef.Build())

	tRdl_BaseType := rdl.NewEnumTypeBuilder("Enum", "rdl.BaseType")
	tRdl_BaseType.Element("Bool", "")
	tRdl_BaseType.Element("Int8", "")
	tRdl_BaseType.Element("Int16", "")
	tRdl_BaseType.Element("Int32", "")
	tRdl_BaseType.Element("Int64", "")
	tRdl_BaseType.Element("Float32", "")
	tRdl_BaseType.Element("Float64", "")
	tRdl_BaseType.Element("Bytes", "")
	tRdl_BaseType.Element("String", "")
	tRdl_BaseType.Element("Timestamp", "")
	tRdl_BaseType.Element("Symbol", "")
	tRdl_BaseType.Element("UUID", "")
	tRdl_BaseType.Element("Array", "")
	tRdl_BaseType.Element("Map", "")
	tRdl_BaseType.Element("Struct", "")
	tRdl_BaseType.Element("Enum", "")
	tRdl_BaseType.Element("Union", "")
	tRdl_BaseType.Element("Any", "")
	sb.AddType(tRdl_BaseType.Build())

	tRdl_ExtendedAnnotation := rdl.NewStringTypeBuilder("rdl.ExtendedAnnotation")
	tRdl_ExtendedAnnotation.Comment("ExtendedAnnotation - parsed and preserved, but has no defined meaning in RDL. Such annotations must begin with \"x_\", and may have an associated string literal value (the value will be \"\" if the annotation is just a flag).")
	tRdl_ExtendedAnnotation.Pattern("x_[a-zA-Z_0-9]*")
	sb.AddType(tRdl_ExtendedAnnotation.Build())

	tRdl_TypeDef := rdl.NewStructTypeBuilder("Struct", "rdl.TypeDef")
	tRdl_TypeDef.Comment("TypeDef is the basic type definition.")
	tRdl_TypeDef.Field("type", "rdl.TypeRef", false, nil, "The type this type is derived from. For base types, it is the same as the name")
	tRdl_TypeDef.Field("name", "rdl.TypeName", false, nil, "The name of the type")
	tRdl_TypeDef.Field("comment", "String", true, nil, "The comment for the type")
	tRdl_TypeDef.MapField("annotations", "rdl.ExtendedAnnotation", "String", true, "additional annotations starting with \"x_\"")
	sb.AddType(tRdl_TypeDef.Build())

	tRdl_AliasTypeDef := rdl.NewStructTypeBuilder("rdl.TypeDef", "rdl.AliasTypeDef")
	tRdl_AliasTypeDef.Comment("AliasTypeDef is used for type definitions that add no additional attributes, and thus just create an alias")
	sb.AddType(tRdl_AliasTypeDef.Build())

	tRdl_BytesTypeDef := rdl.NewStructTypeBuilder("rdl.TypeDef", "rdl.BytesTypeDef")
	tRdl_BytesTypeDef.Comment("Bytes allow the restriction by fixed size, or min/max size.")
	tRdl_BytesTypeDef.Field("size", "Int32", true, nil, "Fixed size")
	tRdl_BytesTypeDef.Field("minSize", "Int32", true, nil, "Min size")
	tRdl_BytesTypeDef.Field("maxSize", "Int32", true, nil, "Max size")
	sb.AddType(tRdl_BytesTypeDef.Build())

	tRdl_StringTypeDef := rdl.NewStructTypeBuilder("rdl.TypeDef", "rdl.StringTypeDef")
	tRdl_StringTypeDef.Comment("Strings allow the restriction by regular expression pattern or by an explicit set of values. An optional maximum size may be asserted")
	tRdl_StringTypeDef.Field("pattern", "String", true, nil, "A regular expression that must be matched. Mutually exclusive with values")
	tRdl_StringTypeDef.ArrayField("values", "String", true, "A set of allowable values")
	tRdl_StringTypeDef.Field("minSize", "Int32", true, nil, "Min size")
	tRdl_StringTypeDef.Field("maxSize", "Int32", true, nil, "Max size")
	sb.AddType(tRdl_StringTypeDef.Build())

	tRdl_Number := rdl.NewUnionTypeBuilder("Union", "rdl.Number")
	tRdl_Number.Comment("A numeric is any of the primitive numeric types")
	tRdl_Number.Variant("Int8")
	tRdl_Number.Variant("Int16")
	tRdl_Number.Variant("Int32")
	tRdl_Number.Variant("Int64")
	tRdl_Number.Variant("Float32")
	tRdl_Number.Variant("Float64")
	sb.AddType(tRdl_Number.Build())

	tRdl_NumberTypeDef := rdl.NewStructTypeBuilder("rdl.TypeDef", "rdl.NumberTypeDef")
	tRdl_NumberTypeDef.Comment("A number type definition allows the restriction of numeric values.")
	tRdl_NumberTypeDef.Field("min", "rdl.Number", true, nil, "Min value")
	tRdl_NumberTypeDef.Field("max", "rdl.Number", true, nil, "Max value")
	sb.AddType(tRdl_NumberTypeDef.Build())

	tRdl_ArrayTypeDef := rdl.NewStructTypeBuilder("rdl.TypeDef", "rdl.ArrayTypeDef")
	tRdl_ArrayTypeDef.Comment("Array types can be restricted by item type and size")
	tRdl_ArrayTypeDef.Field("items", "rdl.TypeRef", false, "Any", "The type of the items, default to any type")
	tRdl_ArrayTypeDef.Field("size", "Int32", true, nil, "If present, indicate the fixed size.")
	tRdl_ArrayTypeDef.Field("minSize", "Int32", true, nil, "If present, indicate the min size")
	tRdl_ArrayTypeDef.Field("maxSize", "Int32", true, nil, "If present, indicate the max size")
	sb.AddType(tRdl_ArrayTypeDef.Build())

	tRdl_MapTypeDef := rdl.NewStructTypeBuilder("rdl.TypeDef", "rdl.MapTypeDef")
	tRdl_MapTypeDef.Comment("Map types can be restricted by key type, item type and size")
	tRdl_MapTypeDef.Field("keys", "rdl.TypeRef", false, "String", "The type of the keys, default to String.")
	tRdl_MapTypeDef.Field("items", "rdl.TypeRef", false, "Any", "The type of the items, default to Any type")
	tRdl_MapTypeDef.Field("size", "Int32", true, nil, "If present, indicates the fixed size.")
	tRdl_MapTypeDef.Field("minSize", "Int32", true, nil, "If present, indicate the min size")
	tRdl_MapTypeDef.Field("maxSize", "Int32", true, nil, "If present, indicate the max size")
	sb.AddType(tRdl_MapTypeDef.Build())

	tRdl_StructFieldDef := rdl.NewStructTypeBuilder("Struct", "rdl.StructFieldDef")
	tRdl_StructFieldDef.Comment("Each field in a struct_field_spec is defined by this type")
	tRdl_StructFieldDef.Field("name", "rdl.Identifier", false, nil, "The name of the field")
	tRdl_StructFieldDef.Field("type", "rdl.TypeRef", false, nil, "The type of the field")
	tRdl_StructFieldDef.Field("optional", "Bool", false, false, "The field may be omitted even if specified")
	tRdl_StructFieldDef.Field("default", "Any", true, nil, "If field is absent, what default value should be assumed.")
	tRdl_StructFieldDef.Field("comment", "String", true, nil, "The comment for the field")
	tRdl_StructFieldDef.Field("items", "rdl.TypeRef", true, nil, "For map or array fields, the type of the items")
	tRdl_StructFieldDef.Field("keys", "rdl.TypeRef", true, nil, "For map type fields, the type of the keys")
	tRdl_StructFieldDef.MapField("annotations", "rdl.ExtendedAnnotation", "String", true, "additional annotations starting with \"x_\"")
	sb.AddType(tRdl_StructFieldDef.Build())

	tRdl_StructTypeDef := rdl.NewStructTypeBuilder("rdl.TypeDef", "rdl.StructTypeDef")
	tRdl_StructTypeDef.Comment("A struct can restrict specific named fields to specific types. By default, any field not specified is allowed, and can be of any type. Specifying closed means only those fields explicitly")
	tRdl_StructTypeDef.ArrayField("fields", "rdl.StructFieldDef", false, "The fields in this struct. By default, open Structs can have any fields in addition to these")
	tRdl_StructTypeDef.Field("closed", "Bool", false, false, "indicates that only the specified fields are acceptable. Default is open (any fields)")
	sb.AddType(tRdl_StructTypeDef.Build())

	tRdl_EnumElementDef := rdl.NewStructTypeBuilder("Struct", "rdl.EnumElementDef")
	tRdl_EnumElementDef.Comment("EnumElementDef defines one of the elements of an Enum")
	tRdl_EnumElementDef.Field("symbol", "rdl.Identifier", false, nil, "The identifier representing the value")
	tRdl_EnumElementDef.Field("comment", "String", true, nil, "the comment for the element")
	tRdl_EnumElementDef.MapField("annotations", "rdl.ExtendedAnnotation", "String", true, "additional annotations starting with \"x_\"")
	sb.AddType(tRdl_EnumElementDef.Build())

	tRdl_EnumTypeDef := rdl.NewStructTypeBuilder("rdl.TypeDef", "rdl.EnumTypeDef")
	tRdl_EnumTypeDef.Comment("Define an enumerated type. Each value of the type is represented by a symbolic identifier.")
	tRdl_EnumTypeDef.ArrayField("elements", "rdl.EnumElementDef", false, "The enumeration of the possible elements")
	sb.AddType(tRdl_EnumTypeDef.Build())

	tRdl_UnionTypeDef := rdl.NewStructTypeBuilder("rdl.TypeDef", "rdl.UnionTypeDef")
	tRdl_UnionTypeDef.Comment("Define a type as one of any other specified type.")
	tRdl_UnionTypeDef.ArrayField("variants", "rdl.TypeRef", false, "The type names of constituent types. Union types get expanded, this is a flat list")
	sb.AddType(tRdl_UnionTypeDef.Build())

	tRdl_Type := rdl.NewUnionTypeBuilder("Union", "rdl.Type")
	tRdl_Type.Comment("A Type can be specified by any of the above specialized Types, determined by the value of the the 'type' field")
	tRdl_Type.Variant("rdl.BaseType")
	tRdl_Type.Variant("rdl.StructTypeDef")
	tRdl_Type.Variant("rdl.MapTypeDef")
	tRdl_Type.Variant("rdl.ArrayTypeDef")
	tRdl_Type.Variant("rdl.EnumTypeDef")
	tRdl_Type.Variant("rdl.UnionTypeDef")
	tRdl_Type.Variant("rdl.StringTypeDef")
	tRdl_Type.Variant("rdl.BytesTypeDef")
	tRdl_Type.Variant("rdl.NumberTypeDef")
	tRdl_Type.Variant("rdl.AliasTypeDef")
	sb.AddType(tRdl_Type.Build())

	tRdl_ResourceInput := rdl.NewStructTypeBuilder("Struct", "rdl.ResourceInput")
	tRdl_ResourceInput.Comment("ResourceOutput defines input characteristics of a Resource")
	tRdl_ResourceInput.Field("name", "rdl.Identifier", false, nil, "the formal name of the input")
	tRdl_ResourceInput.Field("type", "rdl.TypeRef", false, nil, "The type of the input")
	tRdl_ResourceInput.Field("comment", "String", true, nil, "The optional comment")
	tRdl_ResourceInput.Field("pathParam", "Bool", false, false, "true of this input is a path parameter")
	tRdl_ResourceInput.Field("queryParam", "String", true, nil, "if present, the name of the query param name")
	tRdl_ResourceInput.Field("header", "String", true, nil, "If present, the name of the header the input is associated with")
	tRdl_ResourceInput.Field("pattern", "String", true, nil, "If present, the pattern associated with the pathParam (i.e. wildcard path matches)")
	tRdl_ResourceInput.Field("default", "Any", true, nil, "If present, the default value for optional params")
	tRdl_ResourceInput.Field("optional", "Bool", false, false, "If present, indicates that the input is optional")
	tRdl_ResourceInput.Field("flag", "Bool", false, false, "If present, indicates the queryparam is of flag style (no value)")
	tRdl_ResourceInput.Field("context", "String", true, nil, "If present, indicates the parameter comes form the implementation context")
	tRdl_ResourceInput.MapField("annotations", "rdl.ExtendedAnnotation", "String", true, "additional annotations starting with \"x_\"")
	sb.AddType(tRdl_ResourceInput.Build())

	tRdl_ResourceOutput := rdl.NewStructTypeBuilder("Struct", "rdl.ResourceOutput")
	tRdl_ResourceOutput.Comment("ResourceOutput defines output characteristics of a Resource")
	tRdl_ResourceOutput.Field("name", "rdl.Identifier", false, nil, "the formal name of the output")
	tRdl_ResourceOutput.Field("type", "rdl.TypeRef", false, nil, "The type of the output")
	tRdl_ResourceOutput.Field("header", "String", false, nil, "the name of the header associated with this output")
	tRdl_ResourceOutput.Field("comment", "String", true, nil, "The optional comment for the output")
	tRdl_ResourceOutput.Field("optional", "Bool", false, false, "If present, indicates that the output is optional (the server decides)")
	tRdl_ResourceOutput.MapField("annotations", "rdl.ExtendedAnnotation", "String", true, "additional annotations starting with \"x_\"")
	sb.AddType(tRdl_ResourceOutput.Build())

	tRdl_ResourceAuth := rdl.NewStructTypeBuilder("Struct", "rdl.ResourceAuth")
	tRdl_ResourceAuth.Comment("ResourceAuth defines authentication and authorization attributes of a resource. Presence of action, resource, or domain implies authentication; the authentication flag alone is required only when no authorization is done.")
	tRdl_ResourceAuth.Field("authenticate", "Bool", false, false, "if present and true, then the requester must be authenticated")
	tRdl_ResourceAuth.Field("action", "String", true, nil, "the action to authorize access to. This forces authentication")
	tRdl_ResourceAuth.Field("resource", "String", true, nil, "the resource identity to authorize access to")
	tRdl_ResourceAuth.Field("domain", "String", true, nil, "if present, the alternate domain to check access to. This is rare.")
	sb.AddType(tRdl_ResourceAuth.Build())

	tRdl_ExceptionDef := rdl.NewStructTypeBuilder("Struct", "rdl.ExceptionDef")
	tRdl_ExceptionDef.Comment("ExceptionDef describes the exception a symbolic response code maps to.")
	tRdl_ExceptionDef.Field("type", "String", false, nil, "The type of the exception")
	tRdl_ExceptionDef.Field("comment", "String", true, nil, "the optional comment for the exception")
	sb.AddType(tRdl_ExceptionDef.Build())

	tRdl_Resource := rdl.NewStructTypeBuilder("Struct", "rdl.Resource")
	tRdl_Resource.Comment("A Resource of a REST service")
	tRdl_Resource.Field("type", "rdl.TypeRef", false, nil, "The type of the resource")
	tRdl_Resource.Field("method", "String", false, nil, "The method for the action (typically GET, POST, etc for HTTP access)")
	tRdl_Resource.Field("path", "String", false, nil, "The resource path template")
	tRdl_Resource.Field("comment", "String", true, nil, "The optional comment")
	tRdl_Resource.ArrayField("inputs", "rdl.ResourceInput", true, "An Array named inputs")
	tRdl_Resource.ArrayField("outputs", "rdl.ResourceOutput", true, "An Array of named outputs")
	tRdl_Resource.Field("auth", "rdl.ResourceAuth", true, nil, "The optional authentication or authorization directive")
	tRdl_Resource.Field("expected", "String", false, "OK", "The expected symbolic response code")
	tRdl_Resource.ArrayField("alternatives", "String", true, "The set of alternative but non-error response codes")
	tRdl_Resource.MapField("exceptions", "String", "rdl.ExceptionDef", true, "A map of symbolic response code to Exception definitions")
	tRdl_Resource.Field("async", "Bool", true, nil, "A hint to server implementations that this resource would be better implemented with async I/O")
	tRdl_Resource.MapField("annotations", "rdl.ExtendedAnnotation", "String", true, "additional annotations starting with \"x_\"")
	tRdl_Resource.ArrayField("consumes", "String", true, "Optional hint for resource acceptable input types")
	tRdl_Resource.ArrayField("produces", "String", true, "Optional hint for resource output content types")
	tRdl_Resource.Field("name", "rdl.Identifier", true, nil, "The optional name of the resource")
	sb.AddType(tRdl_Resource.Build())

	tRdl_Schema := rdl.NewStructTypeBuilder("Struct", "rdl.Schema")
	tRdl_Schema.Comment("A Schema is a container for types and resources. It is self-contained (no external references). and is the output of the RDL parser.")
	tRdl_Schema.Field("namespace", "rdl.NamespacedIdentifier", true, nil, "The namespace for the schema")
	tRdl_Schema.Field("name", "rdl.Identifier", true, nil, "The name of the schema")
	tRdl_Schema.Field("version", "Int32", true, nil, "The version of the schema")
	tRdl_Schema.Field("comment", "String", true, nil, "The comment for the entire schema")
	tRdl_Schema.ArrayField("types", "rdl.Type", true, "The types this schema defines.")
	tRdl_Schema.ArrayField("resources", "rdl.Resource", true, "The resources for a service this schema defines")
	tRdl_Schema.Field("base", "String", true, nil, "the base path for resources in the schema.")
	tRdl_Schema.MapField("annotations", "rdl.ExtendedAnnotation", "String", true, "additional annotations starting with \"x_\"")
	sb.AddType(tRdl_Schema.Build())

	mGetDomain := rdl.NewResourceBuilder("Domain", "GET", "/domain/{domain}")
	mGetDomain.Comment("Get info for the specified domain, by name. This request only returns the configured domain attributes and not any domain objects like roles, policies or service identities.")
	mGetDomain.Input("domain", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetDomain.Auth("", "", true, "")
	mGetDomain.Exception("BAD_REQUEST", "ResourceError", "")
	mGetDomain.Exception("FORBIDDEN", "ResourceError", "")
	mGetDomain.Exception("NOT_FOUND", "ResourceError", "")
	mGetDomain.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetDomain.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetDomain.Build())

	mGetDomainList := rdl.NewResourceBuilder("DomainList", "GET", "/domain")
	mGetDomainList.Comment("Enumerate domains. Can be filtered by prefix and depth, and paginated. Most of the query options that are looking for specific domain attributes (e.g. aws account, azure subscriptions, gcp project, business service, tags, etc) are mutually exclusive. The server will only process the first query argument and ignore the others.")
	mGetDomainList.Input("limit", "Int32", false, "limit", "", true, nil, "restrict the number of results in this call")
	mGetDomainList.Input("skip", "String", false, "skip", "", true, nil, "restrict the set to those after the specified \"next\" token returned from a previous call")
	mGetDomainList.Input("prefix", "String", false, "prefix", "", true, nil, "restrict to names that start with the prefix")
	mGetDomainList.Input("depth", "Int32", false, "depth", "", true, nil, "restrict the depth of the name, specifying the number of '.' characters that can appear")
	mGetDomainList.Input("account", "String", false, "account", "", true, nil, "restrict to domain names that have specified account name")
	mGetDomainList.Input("productNumber", "Int32", false, "ypmid", "", true, nil, "restrict the domain names that have specified product number")
	mGetDomainList.Input("roleMember", "ResourceName", false, "member", "", true, nil, "restrict the domain names where the specified user is in a role - see roleName")
	mGetDomainList.Input("roleName", "ResourceName", false, "role", "", true, nil, "restrict the domain names where the specified user is in this role - see roleMember")
	mGetDomainList.Input("subscription", "String", false, "azure", "", true, nil, "restrict to domain names that have specified azure subscription name")
	mGetDomainList.Input("project", "String", false, "gcp", "", true, nil, "restrict to domain names that have specified gcp project name")
	mGetDomainList.Input("tagKey", "TagKey", false, "tagKey", "", true, nil, "flag to query all domains that have a given tagName")
	mGetDomainList.Input("tagValue", "TagCompoundValue", false, "tagValue", "", true, nil, "flag to query all domains that have a given tag name and value")
	mGetDomainList.Input("businessService", "String", false, "businessService", "", true, nil, "restrict to domain names that have specified business service name")
	mGetDomainList.Input("productId", "String", false, "productId", "", true, nil, "restrict the domain names that have specified product id")
	mGetDomainList.Input("modifiedSince", "String", false, "", "If-Modified-Since", false, nil, "This header specifies to the server to return any domains modified since this HTTP date")
	mGetDomainList.Auth("", "", true, "")
	mGetDomainList.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetDomainList.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetDomainList.Build())

	mPostTopLevelDomain := rdl.NewResourceBuilder("Domain", "POST", "/domain")
	mPostTopLevelDomain.Comment("Create a new top level domain. This is a privileged action for the \"sys.auth\" administrators.")
	mPostTopLevelDomain.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPostTopLevelDomain.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mPostTopLevelDomain.Input("detail", "TopLevelDomain", false, "", "", false, nil, "TopLevelDomain object to be created")
	mPostTopLevelDomain.Auth("create", "sys.auth:domain", false, "")
	mPostTopLevelDomain.Exception("BAD_REQUEST", "ResourceError", "")
	mPostTopLevelDomain.Exception("FORBIDDEN", "ResourceError", "")
	mPostTopLevelDomain.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPostTopLevelDomain.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPostTopLevelDomain.Build())

	mPostSubDomain := rdl.NewResourceBuilder("Domain", "POST", "/subdomain/{parent}")
	mPostSubDomain.Comment("Create a new subdomain. The domain administrators of the {parent} domain have the privilege to create subdomains.")
	mPostSubDomain.Input("parent", "DomainName", true, "", "", false, nil, "name of the parent domain")
	mPostSubDomain.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPostSubDomain.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mPostSubDomain.Input("detail", "SubDomain", false, "", "", false, nil, "Subdomain object to be created")
	mPostSubDomain.Auth("create", "{parent}:domain", false, "")
	mPostSubDomain.Exception("BAD_REQUEST", "ResourceError", "")
	mPostSubDomain.Exception("FORBIDDEN", "ResourceError", "")
	mPostSubDomain.Exception("NOT_FOUND", "ResourceError", "")
	mPostSubDomain.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPostSubDomain.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPostSubDomain.Build())

	mPostUserDomain := rdl.NewResourceBuilder("Domain", "POST", "/userdomain/{name}")
	mPostUserDomain.Comment("Create a new user domain. The user domain will be created in the user top level domain and the user himself will be set as the administrator for this domain.")
	mPostUserDomain.Input("name", "SimpleName", true, "", "", false, nil, "name of the domain which will be the user id")
	mPostUserDomain.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPostUserDomain.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mPostUserDomain.Input("detail", "UserDomain", false, "", "", false, nil, "UserDomain object to be created")
	mPostUserDomain.Auth("create", "user.{name}:domain", false, "")
	mPostUserDomain.Exception("BAD_REQUEST", "ResourceError", "")
	mPostUserDomain.Exception("FORBIDDEN", "ResourceError", "")
	mPostUserDomain.Exception("NOT_FOUND", "ResourceError", "")
	mPostUserDomain.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPostUserDomain.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPostUserDomain.Build())

	mDeleteTopLevelDomain := rdl.NewResourceBuilder("TopLevelDomain", "DELETE", "/domain/{name}")
	mDeleteTopLevelDomain.Comment("Delete the specified domain.  This is a privileged action for the \"sys.auth\" administrators. Upon successful completion of this delete request, the server will return NO_CONTENT status code without any data (no object will be returned).")
	mDeleteTopLevelDomain.Input("name", "SimpleName", true, "", "", false, nil, "name of the domain to be deleted")
	mDeleteTopLevelDomain.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mDeleteTopLevelDomain.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mDeleteTopLevelDomain.Auth("delete", "sys.auth:domain", false, "")
	mDeleteTopLevelDomain.Expected("NO_CONTENT")
	mDeleteTopLevelDomain.Exception("BAD_REQUEST", "ResourceError", "")
	mDeleteTopLevelDomain.Exception("FORBIDDEN", "ResourceError", "")
	mDeleteTopLevelDomain.Exception("NOT_FOUND", "ResourceError", "")
	mDeleteTopLevelDomain.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeleteTopLevelDomain.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeleteTopLevelDomain.Build())

	mDeleteSubDomain := rdl.NewResourceBuilder("SubDomain", "DELETE", "/subdomain/{parent}/{name}")
	mDeleteSubDomain.Comment("Delete the specified subdomain. Caller must have domain delete permissions in parent or in the domain itself. Therefore, the RDL requires authentication only and the server will perform the authorization check based on the caller's identity. Upon successful completion of this delete request, the server will return NO_CONTENT status code without any data (no object will be returned).")
	mDeleteSubDomain.Input("parent", "DomainName", true, "", "", false, nil, "name of the parent domain")
	mDeleteSubDomain.Input("name", "SimpleName", true, "", "", false, nil, "name of the subdomain to be deleted")
	mDeleteSubDomain.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mDeleteSubDomain.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mDeleteSubDomain.Auth("", "", true, "")
	mDeleteSubDomain.Expected("NO_CONTENT")
	mDeleteSubDomain.Exception("BAD_REQUEST", "ResourceError", "")
	mDeleteSubDomain.Exception("FORBIDDEN", "ResourceError", "")
	mDeleteSubDomain.Exception("NOT_FOUND", "ResourceError", "")
	mDeleteSubDomain.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeleteSubDomain.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeleteSubDomain.Build())

	mDeleteUserDomain := rdl.NewResourceBuilder("UserDomain", "DELETE", "/userdomain/{name}")
	mDeleteUserDomain.Comment("Delete the specified userdomain. Caller must have domain delete permissions in the domain. Upon successful completion of this delete request, the server will return NO_CONTENT status code without any data (no object will be returned).")
	mDeleteUserDomain.Input("name", "SimpleName", true, "", "", false, nil, "name of the domain to be deleted which will be the user id")
	mDeleteUserDomain.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mDeleteUserDomain.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mDeleteUserDomain.Auth("delete", "user.{name}:domain", false, "")
	mDeleteUserDomain.Expected("NO_CONTENT")
	mDeleteUserDomain.Exception("BAD_REQUEST", "ResourceError", "")
	mDeleteUserDomain.Exception("FORBIDDEN", "ResourceError", "")
	mDeleteUserDomain.Exception("NOT_FOUND", "ResourceError", "")
	mDeleteUserDomain.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeleteUserDomain.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeleteUserDomain.Build())

	mPutDomainMeta := rdl.NewResourceBuilder("Domain", "PUT", "/domain/{name}/meta")
	mPutDomainMeta.Comment("Update the specified top level domain metadata. Note that entities in the domain are not affected. Caller must have update privileges on the domain itself.")
	mPutDomainMeta.Input("name", "DomainName", true, "", "", false, nil, "name of the domain to be updated")
	mPutDomainMeta.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutDomainMeta.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mPutDomainMeta.Input("detail", "DomainMeta", false, "", "", false, nil, "DomainMeta object with updated attribute values")
	mPutDomainMeta.Auth("update", "{name}:", false, "")
	mPutDomainMeta.Expected("NO_CONTENT")
	mPutDomainMeta.Exception("BAD_REQUEST", "ResourceError", "")
	mPutDomainMeta.Exception("CONFLICT", "ResourceError", "")
	mPutDomainMeta.Exception("FORBIDDEN", "ResourceError", "")
	mPutDomainMeta.Exception("NOT_FOUND", "ResourceError", "")
	mPutDomainMeta.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutDomainMeta.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutDomainMeta.Build())

	mPutDomainSystemMeta := rdl.NewResourceBuilder("Domain", "PUT", "/domain/{name}/meta/system/{attribute}")
	mPutDomainSystemMeta.Comment("Set the specified top level domain metadata. Note that entities in the domain are not affected. Caller must have update privileges on the domain itself. If the system attribute is one of the string attributes, then the caller must also have delete action on the same resource in order to reset the configured value")
	mPutDomainSystemMeta.Name("PutDomainSystemMeta")
	mPutDomainSystemMeta.Input("name", "DomainName", true, "", "", false, nil, "name of the domain to be updated")
	mPutDomainSystemMeta.Input("attribute", "SimpleName", true, "", "", false, nil, "name of the system attribute to be modified")
	mPutDomainSystemMeta.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutDomainSystemMeta.Input("detail", "DomainMeta", false, "", "", false, nil, "DomainMeta object with updated attribute values")
	mPutDomainSystemMeta.Auth("update", "sys.auth:meta.domain.{attribute}.{name}", false, "")
	mPutDomainSystemMeta.Expected("NO_CONTENT")
	mPutDomainSystemMeta.Exception("BAD_REQUEST", "ResourceError", "")
	mPutDomainSystemMeta.Exception("CONFLICT", "ResourceError", "")
	mPutDomainSystemMeta.Exception("FORBIDDEN", "ResourceError", "")
	mPutDomainSystemMeta.Exception("NOT_FOUND", "ResourceError", "")
	mPutDomainSystemMeta.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutDomainSystemMeta.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutDomainSystemMeta.Build())

	mPutDomainTemplate := rdl.NewResourceBuilder("DomainTemplate", "PUT", "/domain/{name}/template")
	mPutDomainTemplate.Comment("Update the given domain by applying the roles and policies defined in the specified solution template(s). Caller must have UPDATE privileges on the domain itself.")
	mPutDomainTemplate.Input("name", "DomainName", true, "", "", false, nil, "name of the domain to be updated")
	mPutDomainTemplate.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutDomainTemplate.Input("domainTemplate", "DomainTemplate", false, "", "", false, nil, "DomainTemplate object with solution template name(s)")
	mPutDomainTemplate.Auth("update", "{name}:template", false, "")
	mPutDomainTemplate.Expected("NO_CONTENT")
	mPutDomainTemplate.Exception("BAD_REQUEST", "ResourceError", "")
	mPutDomainTemplate.Exception("CONFLICT", "ResourceError", "")
	mPutDomainTemplate.Exception("FORBIDDEN", "ResourceError", "")
	mPutDomainTemplate.Exception("NOT_FOUND", "ResourceError", "")
	mPutDomainTemplate.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutDomainTemplate.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutDomainTemplate.Build())

	mPutDomainTemplateExt := rdl.NewResourceBuilder("DomainTemplate", "PUT", "/domain/{name}/template/{template}")
	mPutDomainTemplateExt.Comment("Update the given domain by applying the roles and policies defined in the specified solution template(s). Caller must have UPDATE privileges on the domain itself.")
	mPutDomainTemplateExt.Name("PutDomainTemplateExt")
	mPutDomainTemplateExt.Input("name", "DomainName", true, "", "", false, nil, "name of the domain to be updated")
	mPutDomainTemplateExt.Input("template", "SimpleName", true, "", "", false, nil, "name of the solution template")
	mPutDomainTemplateExt.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutDomainTemplateExt.Input("domainTemplate", "DomainTemplate", false, "", "", false, nil, "DomainTemplate object with a single template name to match URI")
	mPutDomainTemplateExt.Auth("update", "{name}:template.{template}", false, "")
	mPutDomainTemplateExt.Expected("NO_CONTENT")
	mPutDomainTemplateExt.Exception("BAD_REQUEST", "ResourceError", "")
	mPutDomainTemplateExt.Exception("CONFLICT", "ResourceError", "")
	mPutDomainTemplateExt.Exception("FORBIDDEN", "ResourceError", "")
	mPutDomainTemplateExt.Exception("NOT_FOUND", "ResourceError", "")
	mPutDomainTemplateExt.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutDomainTemplateExt.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutDomainTemplateExt.Build())

	mGetDomainTemplateList := rdl.NewResourceBuilder("DomainTemplateList", "GET", "/domain/{name}/template")
	mGetDomainTemplateList.Comment("Get the list of solution templates applied to a domain")
	mGetDomainTemplateList.Input("name", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetDomainTemplateList.Auth("", "", true, "")
	mGetDomainTemplateList.Exception("BAD_REQUEST", "ResourceError", "")
	mGetDomainTemplateList.Exception("NOT_FOUND", "ResourceError", "")
	mGetDomainTemplateList.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetDomainTemplateList.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetDomainTemplateList.Build())

	mDeleteDomainTemplate := rdl.NewResourceBuilder("DomainTemplate", "DELETE", "/domain/{name}/template/{template}")
	mDeleteDomainTemplate.Comment("Update the given domain by deleting the specified template from the domain template list. Cycles through the roles and policies defined in the template and deletes them. Caller must have delete privileges on the domain itself.")
	mDeleteDomainTemplate.Input("name", "DomainName", true, "", "", false, nil, "name of the domain to be updated")
	mDeleteDomainTemplate.Input("template", "SimpleName", true, "", "", false, nil, "name of the solution template")
	mDeleteDomainTemplate.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mDeleteDomainTemplate.Auth("delete", "{name}:template.{template}", false, "")
	mDeleteDomainTemplate.Expected("NO_CONTENT")
	mDeleteDomainTemplate.Exception("BAD_REQUEST", "ResourceError", "")
	mDeleteDomainTemplate.Exception("CONFLICT", "ResourceError", "")
	mDeleteDomainTemplate.Exception("FORBIDDEN", "ResourceError", "")
	mDeleteDomainTemplate.Exception("NOT_FOUND", "ResourceError", "")
	mDeleteDomainTemplate.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeleteDomainTemplate.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeleteDomainTemplate.Build())

	mGetDomainMetaStoreValidValuesList := rdl.NewResourceBuilder("DomainMetaStoreValidValuesList", "GET", "/domain/metastore")
	mGetDomainMetaStoreValidValuesList.Comment("List all valid values for the given attribute and user")
	mGetDomainMetaStoreValidValuesList.Input("attributeName", "String", false, "attribute", "", false, nil, "name of attribute")
	mGetDomainMetaStoreValidValuesList.Input("userName", "String", false, "user", "", true, nil, "restrict to values associated with the given user")
	mGetDomainMetaStoreValidValuesList.Auth("", "", true, "")
	mGetDomainMetaStoreValidValuesList.Exception("BAD_REQUEST", "ResourceError", "")
	mGetDomainMetaStoreValidValuesList.Exception("NOT_FOUND", "ResourceError", "")
	mGetDomainMetaStoreValidValuesList.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetDomainMetaStoreValidValuesList.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetDomainMetaStoreValidValuesList.Build())

	mGetAuthHistoryDependencies := rdl.NewResourceBuilder("AuthHistoryDependencies", "GET", "/domain/{domainName}/history/auth")
	mGetAuthHistoryDependencies.Comment("Get the authorization and token requests history for the domain")
	mGetAuthHistoryDependencies.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetAuthHistoryDependencies.Auth("", "", true, "")
	mGetAuthHistoryDependencies.Exception("BAD_REQUEST", "ResourceError", "")
	mGetAuthHistoryDependencies.Exception("NOT_FOUND", "ResourceError", "")
	mGetAuthHistoryDependencies.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetAuthHistoryDependencies.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetAuthHistoryDependencies.Build())

	mDeleteExpiredMembers := rdl.NewResourceBuilder("ExpiredMembers", "DELETE", "/expired-members")
	mDeleteExpiredMembers.Comment("Delete expired principals This command will purge expired members of the following resources based on the purgeResources value 0 - none of them will be purged 1 - only roles will be purged 2 - only groups will be purged default/3 - both of them will be purged")
	mDeleteExpiredMembers.Input("purgeResources", "Int32", false, "purgeResources", "", true, nil, "defining which resources will be purged. by default all resources will be purged")
	mDeleteExpiredMembers.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit reference")
	mDeleteExpiredMembers.Input("returnObj", "Bool", false, "", "Athenz-Return-Object", true, false, "Return object param updated object back.")
	mDeleteExpiredMembers.Auth("delete", "sys.auth:expired_members", false, "")
	mDeleteExpiredMembers.Expected("NO_CONTENT")
	mDeleteExpiredMembers.Exception("BAD_REQUEST", "ResourceError", "")
	mDeleteExpiredMembers.Exception("FORBIDDEN", "ResourceError", "")
	mDeleteExpiredMembers.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeleteExpiredMembers.Build())

	mPutResourceDomainOwnership := rdl.NewResourceBuilder("ResourceDomainOwnership", "PUT", "/domain/{domainName}/ownership")
	mPutResourceDomainOwnership.Comment("Set the resource ownership for the given domain")
	mPutResourceDomainOwnership.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutResourceDomainOwnership.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutResourceDomainOwnership.Input("resourceOwnership", "ResourceDomainOwnership", false, "", "", false, nil, "resource ownership to be set for the given domain")
	mPutResourceDomainOwnership.Auth("update", "{domainName}:meta.domain.ownership", false, "")
	mPutResourceDomainOwnership.Expected("NO_CONTENT")
	mPutResourceDomainOwnership.Exception("BAD_REQUEST", "ResourceError", "")
	mPutResourceDomainOwnership.Exception("FORBIDDEN", "ResourceError", "")
	mPutResourceDomainOwnership.Exception("NOT_FOUND", "ResourceError", "")
	mPutResourceDomainOwnership.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutResourceDomainOwnership.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutResourceDomainOwnership.Build())

	mGetDomainDataCheck := rdl.NewResourceBuilder("DomainDataCheck", "GET", "/domain/{domainName}/check")
	mGetDomainDataCheck.Comment("Carry out data check operation for the specified domain.")
	mGetDomainDataCheck.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetDomainDataCheck.Auth("", "", true, "")
	mGetDomainDataCheck.Exception("FORBIDDEN", "ResourceError", "")
	mGetDomainDataCheck.Exception("NOT_FOUND", "ResourceError", "")
	mGetDomainDataCheck.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetDomainDataCheck.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetDomainDataCheck.Build())

	mPutEntity := rdl.NewResourceBuilder("Entity", "PUT", "/domain/{domainName}/entity/{entityName}")
	mPutEntity.Comment("Put an entity into the domain.")
	mPutEntity.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutEntity.Input("entityName", "EntityName", true, "", "", false, nil, "name of entity")
	mPutEntity.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutEntity.Input("entity", "Entity", false, "", "", false, nil, "Entity object to be added to the domain")
	mPutEntity.Auth("update", "{domainName}:entity.{entityName}", false, "")
	mPutEntity.Expected("NO_CONTENT")
	mPutEntity.Exception("BAD_REQUEST", "ResourceError", "")
	mPutEntity.Exception("CONFLICT", "ResourceError", "")
	mPutEntity.Exception("FORBIDDEN", "ResourceError", "")
	mPutEntity.Exception("NOT_FOUND", "ResourceError", "")
	mPutEntity.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutEntity.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutEntity.Build())

	mGetEntity := rdl.NewResourceBuilder("Entity", "GET", "/domain/{domainName}/entity/{entityName}")
	mGetEntity.Comment("Get a entity from a domain. open for all authenticated users to read")
	mGetEntity.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetEntity.Input("entityName", "EntityName", true, "", "", false, nil, "name of entity")
	mGetEntity.Auth("", "", true, "")
	mGetEntity.Exception("BAD_REQUEST", "ResourceError", "")
	mGetEntity.Exception("FORBIDDEN", "ResourceError", "")
	mGetEntity.Exception("NOT_FOUND", "ResourceError", "")
	mGetEntity.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetEntity.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetEntity.Build())

	mDeleteEntity := rdl.NewResourceBuilder("Entity", "DELETE", "/domain/{domainName}/entity/{entityName}")
	mDeleteEntity.Comment("Delete the entity from the domain. Upon successful completion of this delete request, the server will return NO_CONTENT status code without any data (no object will be returned).")
	mDeleteEntity.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mDeleteEntity.Input("entityName", "EntityName", true, "", "", false, nil, "name of entity")
	mDeleteEntity.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mDeleteEntity.Auth("delete", "{domainName}:entity.{entityName}", false, "")
	mDeleteEntity.Expected("NO_CONTENT")
	mDeleteEntity.Exception("BAD_REQUEST", "ResourceError", "")
	mDeleteEntity.Exception("CONFLICT", "ResourceError", "")
	mDeleteEntity.Exception("FORBIDDEN", "ResourceError", "")
	mDeleteEntity.Exception("NOT_FOUND", "ResourceError", "")
	mDeleteEntity.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeleteEntity.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeleteEntity.Build())

	mGetEntityList := rdl.NewResourceBuilder("EntityList", "GET", "/domain/{domainName}/entity")
	mGetEntityList.Comment("Enumerate entities provisioned in this domain.")
	mGetEntityList.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetEntityList.Auth("", "", true, "")
	mGetEntityList.Exception("BAD_REQUEST", "ResourceError", "")
	mGetEntityList.Exception("NOT_FOUND", "ResourceError", "")
	mGetEntityList.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetEntityList.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetEntityList.Build())

	mGetRoleList := rdl.NewResourceBuilder("RoleList", "GET", "/domain/{domainName}/role")
	mGetRoleList.Comment("Enumerate roles provisioned in this domain.")
	mGetRoleList.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetRoleList.Input("limit", "Int32", false, "limit", "", true, nil, "restrict the number of results in this call")
	mGetRoleList.Input("skip", "String", false, "skip", "", true, nil, "restrict the set to those after the specified \"next\" token returned from a previous call")
	mGetRoleList.Auth("", "", true, "")
	mGetRoleList.Exception("BAD_REQUEST", "ResourceError", "")
	mGetRoleList.Exception("FORBIDDEN", "ResourceError", "")
	mGetRoleList.Exception("NOT_FOUND", "ResourceError", "")
	mGetRoleList.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetRoleList.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetRoleList.Build())

	mGetRoles := rdl.NewResourceBuilder("Roles", "GET", "/domain/{domainName}/roles")
	mGetRoles.Comment("Get the list of all roles in a domain with optional flag whether or not include members")
	mGetRoles.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetRoles.Input("members", "Bool", false, "members", "", true, false, "return list of members in the role")
	mGetRoles.Input("tagKey", "TagKey", false, "tagKey", "", true, nil, "flag to query all roles that have a given tagName")
	mGetRoles.Input("tagValue", "TagCompoundValue", false, "tagValue", "", true, nil, "flag to query all roles that have a given tag name and value")
	mGetRoles.Auth("", "", true, "")
	mGetRoles.Exception("BAD_REQUEST", "ResourceError", "")
	mGetRoles.Exception("NOT_FOUND", "ResourceError", "")
	mGetRoles.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetRoles.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetRoles.Build())

	mGetRole := rdl.NewResourceBuilder("Role", "GET", "/domain/{domainName}/role/{roleName}")
	mGetRole.Comment("Get the specified role in the domain.")
	mGetRole.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetRole.Input("roleName", "EntityName", true, "", "", false, nil, "name of the role to be retrieved")
	mGetRole.Input("auditLog", "Bool", false, "auditLog", "", true, false, "flag to indicate whether or not to return role audit log")
	mGetRole.Input("expand", "Bool", false, "expand", "", true, false, "expand delegated trust roles and return trusted members")
	mGetRole.Input("pending", "Bool", false, "pending", "", true, false, "include pending members")
	mGetRole.Auth("", "", true, "")
	mGetRole.Exception("BAD_REQUEST", "ResourceError", "")
	mGetRole.Exception("FORBIDDEN", "ResourceError", "")
	mGetRole.Exception("NOT_FOUND", "ResourceError", "")
	mGetRole.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetRole.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetRole.Build())

	mPutRole := rdl.NewResourceBuilder("Role", "PUT", "/domain/{domainName}/role/{roleName}")
	mPutRole.Comment("Create/update the specified role.")
	mPutRole.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutRole.Input("roleName", "EntityName", true, "", "", false, nil, "name of the role to be added/updated")
	mPutRole.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutRole.Input("returnObj", "Bool", false, "", "Athenz-Return-Object", true, false, "Return object param updated object back.")
	mPutRole.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mPutRole.Input("role", "Role", false, "", "", false, nil, "Role object to be added/updated in the domain")
	mPutRole.Auth("update", "{domainName}:role.{roleName}", false, "")
	mPutRole.Expected("NO_CONTENT")
	mPutRole.Exception("BAD_REQUEST", "ResourceError", "")
	mPutRole.Exception("CONFLICT", "ResourceError", "")
	mPutRole.Exception("FORBIDDEN", "ResourceError", "")
	mPutRole.Exception("NOT_FOUND", "ResourceError", "")
	mPutRole.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutRole.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutRole.Build())

	mDeleteRole := rdl.NewResourceBuilder("Role", "DELETE", "/domain/{domainName}/role/{roleName}")
	mDeleteRole.Comment("Delete the specified role. Upon successful completion of this delete request, the server will return NO_CONTENT status code without any data (no object will be returned).")
	mDeleteRole.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mDeleteRole.Input("roleName", "EntityName", true, "", "", false, nil, "name of the role to be deleted")
	mDeleteRole.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mDeleteRole.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mDeleteRole.Auth("delete", "{domainName}:role.{roleName}", false, "")
	mDeleteRole.Expected("NO_CONTENT")
	mDeleteRole.Exception("BAD_REQUEST", "ResourceError", "")
	mDeleteRole.Exception("CONFLICT", "ResourceError", "")
	mDeleteRole.Exception("FORBIDDEN", "ResourceError", "")
	mDeleteRole.Exception("NOT_FOUND", "ResourceError", "")
	mDeleteRole.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeleteRole.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeleteRole.Build())

	mGetMembership := rdl.NewResourceBuilder("Membership", "GET", "/domain/{domainName}/role/{roleName}/member/{memberName}")
	mGetMembership.Comment("Get the membership status for a specified user in a role.")
	mGetMembership.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetMembership.Input("roleName", "EntityName", true, "", "", false, nil, "name of the role")
	mGetMembership.Input("memberName", "MemberName", true, "", "", false, nil, "user name to be checked for membership")
	mGetMembership.Input("expiration", "String", false, "expiration", "", true, nil, "the expiration timestamp")
	mGetMembership.Auth("", "", true, "")
	mGetMembership.Exception("BAD_REQUEST", "ResourceError", "")
	mGetMembership.Exception("FORBIDDEN", "ResourceError", "")
	mGetMembership.Exception("NOT_FOUND", "ResourceError", "")
	mGetMembership.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetMembership.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetMembership.Build())

	mGetOverdueReview := rdl.NewResourceBuilder("DomainRoleMembers", "GET", "/domain/{domainName}/overdue")
	mGetOverdueReview.Comment("Get members with overdue review")
	mGetOverdueReview.Name("GetOverdueReview")
	mGetOverdueReview.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetOverdueReview.Auth("", "", true, "")
	mGetOverdueReview.Exception("BAD_REQUEST", "ResourceError", "")
	mGetOverdueReview.Exception("FORBIDDEN", "ResourceError", "")
	mGetOverdueReview.Exception("NOT_FOUND", "ResourceError", "")
	mGetOverdueReview.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetOverdueReview.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetOverdueReview.Build())

	mGetDomainRoleMembers := rdl.NewResourceBuilder("DomainRoleMembers", "GET", "/domain/{domainName}/member")
	mGetDomainRoleMembers.Comment("Get list of principals defined in roles in the given domain")
	mGetDomainRoleMembers.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetDomainRoleMembers.Auth("", "", true, "")
	mGetDomainRoleMembers.Exception("BAD_REQUEST", "ResourceError", "")
	mGetDomainRoleMembers.Exception("FORBIDDEN", "ResourceError", "")
	mGetDomainRoleMembers.Exception("NOT_FOUND", "ResourceError", "")
	mGetDomainRoleMembers.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetDomainRoleMembers.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetDomainRoleMembers.Build())

	mGetPrincipalRoles := rdl.NewResourceBuilder("DomainRoleMember", "GET", "/role")
	mGetPrincipalRoles.Comment("Fetch all the roles across domains by either calling or specified principal The optional expand argument will include all direct and indirect roles, however, it will force authorization that you must be either the principal or for service accounts have update access to the service identity: 1. authenticated principal is the same as the check principal 2. system authorized (\"access\", \"sys.auth:meta.role.lookup\") 3. service admin (\"update\", \"{principal}\") 4. domain authorized (\"access\", \"{domainName}:meta.role.lookup\") if domainName is provided")
	mGetPrincipalRoles.Name("getPrincipalRoles")
	mGetPrincipalRoles.Input("principal", "ResourceName", false, "principal", "", true, nil, "If not present, will return roles for the user making the call")
	mGetPrincipalRoles.Input("domainName", "DomainName", false, "domain", "", true, nil, "If not present, will return roles from all domains")
	mGetPrincipalRoles.Input("expand", "Bool", false, "expand", "", true, false, "expand to include group and delegated trust role membership")
	mGetPrincipalRoles.Auth("", "", true, "")
	mGetPrincipalRoles.Exception("BAD_REQUEST", "ResourceError", "")
	mGetPrincipalRoles.Exception("FORBIDDEN", "ResourceError", "")
	mGetPrincipalRoles.Exception("NOT_FOUND", "ResourceError", "")
	mGetPrincipalRoles.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetPrincipalRoles.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetPrincipalRoles.Build())

	mPutMembership := rdl.NewResourceBuilder("Membership", "PUT", "/domain/{domainName}/role/{roleName}/member/{memberName}")
	mPutMembership.Comment("Add the specified user to the role's member list. If the role is selfRenewEnabled, then an existing member may extend their expiration time by the configured number of minutes (selfRenewMins) by calling this API regardless or not the user is expired or active. If the role is neither auditEnabled nor selfserve, then it will use authorize (\"update\", \"{domainName}:role.{roleName}\") or (\"update_members\", \"{domainName}:role.{roleName}\"). This only allows access to members and not role attributes. otherwise membership will be sent for approval to either designated delegates ( in case of auditEnabled roles ) or to domain admins ( in case of selfserve roles )")
	mPutMembership.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutMembership.Input("roleName", "EntityName", true, "", "", false, nil, "name of the role")
	mPutMembership.Input("memberName", "MemberName", true, "", "", false, nil, "name of the user to be added as a member")
	mPutMembership.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutMembership.Input("returnObj", "Bool", false, "", "Athenz-Return-Object", true, false, "Return object param updated object back.")
	mPutMembership.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mPutMembership.Input("membership", "Membership", false, "", "", false, nil, "Membership object (must contain role/member names as specified in the URI)")
	mPutMembership.Auth("", "", true, "")
	mPutMembership.Expected("NO_CONTENT")
	mPutMembership.Exception("BAD_REQUEST", "ResourceError", "")
	mPutMembership.Exception("CONFLICT", "ResourceError", "")
	mPutMembership.Exception("FORBIDDEN", "ResourceError", "")
	mPutMembership.Exception("NOT_FOUND", "ResourceError", "")
	mPutMembership.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutMembership.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutMembership.Build())

	mDeleteMembership := rdl.NewResourceBuilder("Membership", "DELETE", "/domain/{domainName}/role/{roleName}/member/{memberName}")
	mDeleteMembership.Comment("Delete the specified role membership. Upon successful completion of this delete request, the server will return NO_CONTENT status code without any data (no object will be returned). The required authorization includes three options: 1. (\"update\", \"{domainName}:role.{roleName}\") 2. (\"update_members\", \"{domainName}:role.{roleName}\") 3. principal matches memberName")
	mDeleteMembership.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mDeleteMembership.Input("roleName", "EntityName", true, "", "", false, nil, "name of the role")
	mDeleteMembership.Input("memberName", "MemberName", true, "", "", false, nil, "name of the user to be removed as a member")
	mDeleteMembership.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mDeleteMembership.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mDeleteMembership.Auth("", "", true, "")
	mDeleteMembership.Expected("NO_CONTENT")
	mDeleteMembership.Exception("BAD_REQUEST", "ResourceError", "")
	mDeleteMembership.Exception("CONFLICT", "ResourceError", "")
	mDeleteMembership.Exception("FORBIDDEN", "ResourceError", "")
	mDeleteMembership.Exception("NOT_FOUND", "ResourceError", "")
	mDeleteMembership.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeleteMembership.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeleteMembership.Build())

	mDeletePendingMembership := rdl.NewResourceBuilder("Membership", "DELETE", "/domain/{domainName}/role/{roleName}/pendingmember/{memberName}")
	mDeletePendingMembership.Comment("Delete the specified pending role membership. Upon successful completion of this delete request, the server will return NO_CONTENT status code without any data (no object will be returned). Authorization will be completed within the server itself since there are two possibilities: 1) The domain admins can delete any pending requests 2) the requestor can also delete his/her own pending request.")
	mDeletePendingMembership.Name("DeletePendingMembership")
	mDeletePendingMembership.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mDeletePendingMembership.Input("roleName", "EntityName", true, "", "", false, nil, "name of the role")
	mDeletePendingMembership.Input("memberName", "MemberName", true, "", "", false, nil, "name of the user to be removed as a pending member")
	mDeletePendingMembership.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mDeletePendingMembership.Auth("", "", true, "")
	mDeletePendingMembership.Expected("NO_CONTENT")
	mDeletePendingMembership.Exception("BAD_REQUEST", "ResourceError", "")
	mDeletePendingMembership.Exception("CONFLICT", "ResourceError", "")
	mDeletePendingMembership.Exception("FORBIDDEN", "ResourceError", "")
	mDeletePendingMembership.Exception("NOT_FOUND", "ResourceError", "")
	mDeletePendingMembership.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeletePendingMembership.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeletePendingMembership.Build())

	mPutDefaultAdmins := rdl.NewResourceBuilder("DefaultAdmins", "PUT", "/domain/{domainName}/admins")
	mPutDefaultAdmins.Comment("Verify and, if necessary, fix domain roles and policies to make sure the given set of users have administrative access to the domain. This request is only restricted to \"sys.auth\" domain administrators and can be used when the domain administrators incorrectly have blocked their own access to their domains.")
	mPutDefaultAdmins.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutDefaultAdmins.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutDefaultAdmins.Input("defaultAdmins", "DefaultAdmins", false, "", "", false, nil, "list of domain administrators")
	mPutDefaultAdmins.Auth("update", "sys.auth:domain", false, "")
	mPutDefaultAdmins.Expected("NO_CONTENT")
	mPutDefaultAdmins.Exception("BAD_REQUEST", "ResourceError", "")
	mPutDefaultAdmins.Exception("FORBIDDEN", "ResourceError", "")
	mPutDefaultAdmins.Exception("NOT_FOUND", "ResourceError", "")
	mPutDefaultAdmins.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutDefaultAdmins.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutDefaultAdmins.Build())

	mPutRoleSystemMeta := rdl.NewResourceBuilder("Role", "PUT", "/domain/{domainName}/role/{roleName}/meta/system/{attribute}")
	mPutRoleSystemMeta.Comment("Set the specified role metadata. Caller must have update privileges on the sys.auth domain. If the system attribute is one of the string attributes, then the caller must also have delete action on the same resource in order to reset the configured value")
	mPutRoleSystemMeta.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutRoleSystemMeta.Input("roleName", "EntityName", true, "", "", false, nil, "name of the role")
	mPutRoleSystemMeta.Input("attribute", "SimpleName", true, "", "", false, nil, "name of the system attribute to be modified")
	mPutRoleSystemMeta.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutRoleSystemMeta.Input("detail", "RoleSystemMeta", false, "", "", false, nil, "RoleSystemMeta object with updated attribute values")
	mPutRoleSystemMeta.Auth("update", "sys.auth:meta.role.{attribute}.{domainName}", false, "")
	mPutRoleSystemMeta.Expected("NO_CONTENT")
	mPutRoleSystemMeta.Exception("BAD_REQUEST", "ResourceError", "")
	mPutRoleSystemMeta.Exception("CONFLICT", "ResourceError", "")
	mPutRoleSystemMeta.Exception("FORBIDDEN", "ResourceError", "")
	mPutRoleSystemMeta.Exception("NOT_FOUND", "ResourceError", "")
	mPutRoleSystemMeta.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutRoleSystemMeta.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutRoleSystemMeta.Build())

	mPutRoleMeta := rdl.NewResourceBuilder("Role", "PUT", "/domain/{domainName}/role/{roleName}/meta")
	mPutRoleMeta.Comment("Update the specified role metadata. Caller must have update privileges on the domain itself.")
	mPutRoleMeta.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain to be updated")
	mPutRoleMeta.Input("roleName", "EntityName", true, "", "", false, nil, "name of the role")
	mPutRoleMeta.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutRoleMeta.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mPutRoleMeta.Input("detail", "RoleMeta", false, "", "", false, nil, "RoleMeta object with updated attribute values")
	mPutRoleMeta.Auth("", "", true, "")
	mPutRoleMeta.Expected("NO_CONTENT")
	mPutRoleMeta.Exception("BAD_REQUEST", "ResourceError", "")
	mPutRoleMeta.Exception("CONFLICT", "ResourceError", "")
	mPutRoleMeta.Exception("FORBIDDEN", "ResourceError", "")
	mPutRoleMeta.Exception("NOT_FOUND", "ResourceError", "")
	mPutRoleMeta.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutRoleMeta.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutRoleMeta.Build())

	mPutMembershipDecision := rdl.NewResourceBuilder("Membership", "PUT", "/domain/{domainName}/role/{roleName}/member/{memberName}/decision")
	mPutMembershipDecision.Comment("Approve or Reject the request to add specified user to role membership. This endpoint will be used by 2 use cases: 1. Audit enabled roles with authorize (\"update\", \"sys.auth:meta.role.{attribute}.{domainName}\") 2. Selfserve roles in any domain with authorize (\"update\", \"{domainName}:\")")
	mPutMembershipDecision.Name("PutMembershipDecision")
	mPutMembershipDecision.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutMembershipDecision.Input("roleName", "EntityName", true, "", "", false, nil, "name of the role")
	mPutMembershipDecision.Input("memberName", "MemberName", true, "", "", false, nil, "name of the user to be added as a member")
	mPutMembershipDecision.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutMembershipDecision.Input("membership", "Membership", false, "", "", false, nil, "Membership object (must contain role/member names as specified in the URI)")
	mPutMembershipDecision.Auth("", "", true, "")
	mPutMembershipDecision.Expected("NO_CONTENT")
	mPutMembershipDecision.Exception("BAD_REQUEST", "ResourceError", "")
	mPutMembershipDecision.Exception("CONFLICT", "ResourceError", "")
	mPutMembershipDecision.Exception("FORBIDDEN", "ResourceError", "")
	mPutMembershipDecision.Exception("NOT_FOUND", "ResourceError", "")
	mPutMembershipDecision.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutMembershipDecision.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutMembershipDecision.Build())

	mPutRoleReview := rdl.NewResourceBuilder("Role", "PUT", "/domain/{domainName}/role/{roleName}/review")
	mPutRoleReview.Comment("Review role membership and take action to either extend and/or delete existing members. The required authorization includes two options: 1. (\"update\", \"{domainName}:role.{roleName}\") 2. (\"update_members\", \"{domainName}:role.{roleName}\")")
	mPutRoleReview.Name("PutRoleReview")
	mPutRoleReview.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutRoleReview.Input("roleName", "EntityName", true, "", "", false, nil, "name of the role")
	mPutRoleReview.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutRoleReview.Input("returnObj", "Bool", false, "", "Athenz-Return-Object", true, false, "Return object param updated object back.")
	mPutRoleReview.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mPutRoleReview.Input("role", "Role", false, "", "", false, nil, "Role object with updated and/or deleted members")
	mPutRoleReview.Auth("", "", true, "")
	mPutRoleReview.Expected("NO_CONTENT")
	mPutRoleReview.Exception("BAD_REQUEST", "ResourceError", "")
	mPutRoleReview.Exception("CONFLICT", "ResourceError", "")
	mPutRoleReview.Exception("FORBIDDEN", "ResourceError", "")
	mPutRoleReview.Exception("NOT_FOUND", "ResourceError", "")
	mPutRoleReview.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutRoleReview.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutRoleReview.Build())

	mPutResourceRoleOwnership := rdl.NewResourceBuilder("ResourceRoleOwnership", "PUT", "/domain/{domainName}/role/{roleName}/ownership")
	mPutResourceRoleOwnership.Comment("Set the resource ownership for the given role")
	mPutResourceRoleOwnership.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutResourceRoleOwnership.Input("roleName", "EntityName", true, "", "", false, nil, "name of the role")
	mPutResourceRoleOwnership.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutResourceRoleOwnership.Input("resourceOwnership", "ResourceRoleOwnership", false, "", "", false, nil, "resource ownership to be set for the given role")
	mPutResourceRoleOwnership.Auth("update", "{domainName}:meta.role.ownership.{roleName}", false, "")
	mPutResourceRoleOwnership.Expected("NO_CONTENT")
	mPutResourceRoleOwnership.Exception("BAD_REQUEST", "ResourceError", "")
	mPutResourceRoleOwnership.Exception("FORBIDDEN", "ResourceError", "")
	mPutResourceRoleOwnership.Exception("NOT_FOUND", "ResourceError", "")
	mPutResourceRoleOwnership.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutResourceRoleOwnership.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutResourceRoleOwnership.Build())

	mGetGroups := rdl.NewResourceBuilder("Groups", "GET", "/domain/{domainName}/groups")
	mGetGroups.Comment("Get the list of all groups in a domain with optional flag whether or not include members")
	mGetGroups.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetGroups.Input("members", "Bool", false, "members", "", true, false, "return list of members in the group")
	mGetGroups.Input("tagKey", "TagKey", false, "tagKey", "", true, nil, "flag to query all groups that have a given tagName")
	mGetGroups.Input("tagValue", "TagCompoundValue", false, "tagValue", "", true, nil, "flag to query all groups that have a given tag name and value")
	mGetGroups.Auth("", "", true, "")
	mGetGroups.Exception("BAD_REQUEST", "ResourceError", "")
	mGetGroups.Exception("NOT_FOUND", "ResourceError", "")
	mGetGroups.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetGroups.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetGroups.Build())

	mGetGroup := rdl.NewResourceBuilder("Group", "GET", "/domain/{domainName}/group/{groupName}")
	mGetGroup.Comment("Get the specified group in the domain.")
	mGetGroup.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetGroup.Input("groupName", "EntityName", true, "", "", false, nil, "name of the group to be retrieved")
	mGetGroup.Input("auditLog", "Bool", false, "auditLog", "", true, false, "flag to indicate whether or not to return group audit log")
	mGetGroup.Input("pending", "Bool", false, "pending", "", true, false, "include pending members")
	mGetGroup.Auth("", "", true, "")
	mGetGroup.Exception("BAD_REQUEST", "ResourceError", "")
	mGetGroup.Exception("FORBIDDEN", "ResourceError", "")
	mGetGroup.Exception("NOT_FOUND", "ResourceError", "")
	mGetGroup.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetGroup.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetGroup.Build())

	mPutGroup := rdl.NewResourceBuilder("Group", "PUT", "/domain/{domainName}/group/{groupName}")
	mPutGroup.Comment("Create/update the specified group.")
	mPutGroup.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutGroup.Input("groupName", "EntityName", true, "", "", false, nil, "name of the group to be added/updated")
	mPutGroup.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutGroup.Input("returnObj", "Bool", false, "", "Athenz-Return-Object", true, false, "Return object param updated object back.")
	mPutGroup.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mPutGroup.Input("group", "Group", false, "", "", false, nil, "Group object to be added/updated in the domain")
	mPutGroup.Auth("update", "{domainName}:group.{groupName}", false, "")
	mPutGroup.Expected("NO_CONTENT")
	mPutGroup.Exception("BAD_REQUEST", "ResourceError", "")
	mPutGroup.Exception("CONFLICT", "ResourceError", "")
	mPutGroup.Exception("FORBIDDEN", "ResourceError", "")
	mPutGroup.Exception("NOT_FOUND", "ResourceError", "")
	mPutGroup.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutGroup.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutGroup.Build())

	mDeleteGroup := rdl.NewResourceBuilder("Group", "DELETE", "/domain/{domainName}/group/{groupName}")
	mDeleteGroup.Comment("Delete the specified group. Upon successful completion of this delete request, the server will return NO_CONTENT status code without any data (no object will be returned).")
	mDeleteGroup.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mDeleteGroup.Input("groupName", "EntityName", true, "", "", false, nil, "name of the group to be deleted")
	mDeleteGroup.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mDeleteGroup.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mDeleteGroup.Auth("delete", "{domainName}:group.{groupName}", false, "")
	mDeleteGroup.Expected("NO_CONTENT")
	mDeleteGroup.Exception("BAD_REQUEST", "ResourceError", "")
	mDeleteGroup.Exception("CONFLICT", "ResourceError", "")
	mDeleteGroup.Exception("FORBIDDEN", "ResourceError", "")
	mDeleteGroup.Exception("NOT_FOUND", "ResourceError", "")
	mDeleteGroup.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeleteGroup.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeleteGroup.Build())

	mGetGroupMembership := rdl.NewResourceBuilder("GroupMembership", "GET", "/domain/{domainName}/group/{groupName}/member/{memberName}")
	mGetGroupMembership.Comment("Get the membership status for a specified user in a group.")
	mGetGroupMembership.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetGroupMembership.Input("groupName", "EntityName", true, "", "", false, nil, "name of the group")
	mGetGroupMembership.Input("memberName", "GroupMemberName", true, "", "", false, nil, "user name to be checked for membership")
	mGetGroupMembership.Input("expiration", "String", false, "expiration", "", true, nil, "the expiration timestamp")
	mGetGroupMembership.Auth("", "", true, "")
	mGetGroupMembership.Exception("BAD_REQUEST", "ResourceError", "")
	mGetGroupMembership.Exception("FORBIDDEN", "ResourceError", "")
	mGetGroupMembership.Exception("NOT_FOUND", "ResourceError", "")
	mGetGroupMembership.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetGroupMembership.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetGroupMembership.Build())

	mGetPrincipalGroups := rdl.NewResourceBuilder("DomainGroupMember", "GET", "/group")
	mGetPrincipalGroups.Comment("Fetch all the groups across domains by either calling or specified principal")
	mGetPrincipalGroups.Name("getPrincipalGroups")
	mGetPrincipalGroups.Input("principal", "EntityName", false, "principal", "", true, nil, "If not present, will return groups for the user making the call")
	mGetPrincipalGroups.Input("domainName", "DomainName", false, "domain", "", true, nil, "If not present, will return groups from all domains")
	mGetPrincipalGroups.Auth("", "", true, "")
	mGetPrincipalGroups.Exception("BAD_REQUEST", "ResourceError", "")
	mGetPrincipalGroups.Exception("FORBIDDEN", "ResourceError", "")
	mGetPrincipalGroups.Exception("NOT_FOUND", "ResourceError", "")
	mGetPrincipalGroups.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetPrincipalGroups.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetPrincipalGroups.Build())

	mPutGroupMembership := rdl.NewResourceBuilder("GroupMembership", "PUT", "/domain/{domainName}/group/{groupName}/member/{memberName}")
	mPutGroupMembership.Comment("Add the specified user to the group's member list. If the group is selfRenewEnabled, then an existing member may extend their expiration time by the configured number of minutes (selfRenewMins) by calling this API regardless or not the user is expired or active. If the group is neither auditEnabled nor selfserve, then it will use authorize (\"update\", \"{domainName}:group.{groupName}\") otherwise membership will be sent for approval to either designated delegates ( in case of auditEnabled groups ) or to domain admins ( in case of selfserve groups )")
	mPutGroupMembership.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutGroupMembership.Input("groupName", "EntityName", true, "", "", false, nil, "name of the group")
	mPutGroupMembership.Input("memberName", "GroupMemberName", true, "", "", false, nil, "name of the user to be added as a member")
	mPutGroupMembership.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutGroupMembership.Input("returnObj", "Bool", false, "", "Athenz-Return-Object", true, false, "Return object param updated object back.")
	mPutGroupMembership.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mPutGroupMembership.Input("membership", "GroupMembership", false, "", "", false, nil, "Membership object (must contain group/member names as specified in the URI)")
	mPutGroupMembership.Auth("", "", true, "")
	mPutGroupMembership.Expected("NO_CONTENT")
	mPutGroupMembership.Exception("BAD_REQUEST", "ResourceError", "")
	mPutGroupMembership.Exception("CONFLICT", "ResourceError", "")
	mPutGroupMembership.Exception("FORBIDDEN", "ResourceError", "")
	mPutGroupMembership.Exception("NOT_FOUND", "ResourceError", "")
	mPutGroupMembership.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutGroupMembership.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutGroupMembership.Build())

	mDeleteGroupMembership := rdl.NewResourceBuilder("GroupMembership", "DELETE", "/domain/{domainName}/group/{groupName}/member/{memberName}")
	mDeleteGroupMembership.Comment("Delete the specified group membership. Upon successful completion of this delete request, the server will return NO_CONTENT status code without any data (no object will be returned). The required authorization includes three options: 1. (\"update\", \"{domainName}:group.{groupName}\") 2. (\"update_members\", \"{domainName}:group.{groupName}\") 3. principal matches memberName")
	mDeleteGroupMembership.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mDeleteGroupMembership.Input("groupName", "EntityName", true, "", "", false, nil, "name of the group")
	mDeleteGroupMembership.Input("memberName", "GroupMemberName", true, "", "", false, nil, "name of the user to be removed as a member")
	mDeleteGroupMembership.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mDeleteGroupMembership.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mDeleteGroupMembership.Auth("", "", true, "")
	mDeleteGroupMembership.Expected("NO_CONTENT")
	mDeleteGroupMembership.Exception("BAD_REQUEST", "ResourceError", "")
	mDeleteGroupMembership.Exception("CONFLICT", "ResourceError", "")
	mDeleteGroupMembership.Exception("FORBIDDEN", "ResourceError", "")
	mDeleteGroupMembership.Exception("NOT_FOUND", "ResourceError", "")
	mDeleteGroupMembership.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeleteGroupMembership.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeleteGroupMembership.Build())

	mDeletePendingGroupMembership := rdl.NewResourceBuilder("GroupMembership", "DELETE", "/domain/{domainName}/group/{groupName}/pendingmember/{memberName}")
	mDeletePendingGroupMembership.Comment("Delete the specified pending group membership. Upon successful completion of this delete request, the server will return NO_CONTENT status code without any data (no object will be returned). Authorization will be completed within the server itself since there are two possibilities: 1) The domain admins can delete any pending requests 2) the requestor can also delete his/her own pending request.")
	mDeletePendingGroupMembership.Name("DeletePendingGroupMembership")
	mDeletePendingGroupMembership.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mDeletePendingGroupMembership.Input("groupName", "EntityName", true, "", "", false, nil, "name of the group")
	mDeletePendingGroupMembership.Input("memberName", "GroupMemberName", true, "", "", false, nil, "name of the user to be removed as a pending member")
	mDeletePendingGroupMembership.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mDeletePendingGroupMembership.Auth("", "", true, "")
	mDeletePendingGroupMembership.Expected("NO_CONTENT")
	mDeletePendingGroupMembership.Exception("BAD_REQUEST", "ResourceError", "")
	mDeletePendingGroupMembership.Exception("CONFLICT", "ResourceError", "")
	mDeletePendingGroupMembership.Exception("FORBIDDEN", "ResourceError", "")
	mDeletePendingGroupMembership.Exception("NOT_FOUND", "ResourceError", "")
	mDeletePendingGroupMembership.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeletePendingGroupMembership.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeletePendingGroupMembership.Build())

	mPutGroupSystemMeta := rdl.NewResourceBuilder("Group", "PUT", "/domain/{domainName}/group/{groupName}/meta/system/{attribute}")
	mPutGroupSystemMeta.Comment("Set the specified group metadata. Caller must have update privileges on the sys.auth domain. If the system attribute is one of the string attributes, then the caller must also have delete action on the same resource in order to reset the configured value")
	mPutGroupSystemMeta.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutGroupSystemMeta.Input("groupName", "EntityName", true, "", "", false, nil, "name of the group")
	mPutGroupSystemMeta.Input("attribute", "SimpleName", true, "", "", false, nil, "name of the system attribute to be modified")
	mPutGroupSystemMeta.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutGroupSystemMeta.Input("detail", "GroupSystemMeta", false, "", "", false, nil, "GroupSystemMeta object with updated attribute values")
	mPutGroupSystemMeta.Auth("update", "sys.auth:meta.group.{attribute}.{domainName}", false, "")
	mPutGroupSystemMeta.Expected("NO_CONTENT")
	mPutGroupSystemMeta.Exception("BAD_REQUEST", "ResourceError", "")
	mPutGroupSystemMeta.Exception("CONFLICT", "ResourceError", "")
	mPutGroupSystemMeta.Exception("FORBIDDEN", "ResourceError", "")
	mPutGroupSystemMeta.Exception("NOT_FOUND", "ResourceError", "")
	mPutGroupSystemMeta.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutGroupSystemMeta.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutGroupSystemMeta.Build())

	mPutGroupMeta := rdl.NewResourceBuilder("Group", "PUT", "/domain/{domainName}/group/{groupName}/meta")
	mPutGroupMeta.Comment("Update the specified group metadata. Caller must have update privileges on the domain itself.")
	mPutGroupMeta.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain to be updated")
	mPutGroupMeta.Input("groupName", "EntityName", true, "", "", false, nil, "name of the group")
	mPutGroupMeta.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutGroupMeta.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mPutGroupMeta.Input("detail", "GroupMeta", false, "", "", false, nil, "GroupMeta object with updated attribute values")
	mPutGroupMeta.Auth("update", "{domainName}:group.{groupName}", false, "")
	mPutGroupMeta.Expected("NO_CONTENT")
	mPutGroupMeta.Exception("BAD_REQUEST", "ResourceError", "")
	mPutGroupMeta.Exception("CONFLICT", "ResourceError", "")
	mPutGroupMeta.Exception("FORBIDDEN", "ResourceError", "")
	mPutGroupMeta.Exception("NOT_FOUND", "ResourceError", "")
	mPutGroupMeta.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutGroupMeta.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutGroupMeta.Build())

	mPutGroupMembershipDecision := rdl.NewResourceBuilder("GroupMembership", "PUT", "/domain/{domainName}/group/{groupName}/member/{memberName}/decision")
	mPutGroupMembershipDecision.Comment("Approve or Reject the request to add specified user to group membership. This endpoint will be used by 2 use cases: 1. Audit enabled groups with authorize (\"update\", \"sys.auth:meta.group.{attribute}.{domainName}\") 2. Selfserve groups in any domain with authorize (\"update\", \"{domainName}:\")")
	mPutGroupMembershipDecision.Name("PutGroupMembershipDecision")
	mPutGroupMembershipDecision.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutGroupMembershipDecision.Input("groupName", "EntityName", true, "", "", false, nil, "name of the group")
	mPutGroupMembershipDecision.Input("memberName", "GroupMemberName", true, "", "", false, nil, "name of the user to be added as a member")
	mPutGroupMembershipDecision.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutGroupMembershipDecision.Input("membership", "GroupMembership", false, "", "", false, nil, "GroupMembership object (must contain group/member names as specified in the URI)")
	mPutGroupMembershipDecision.Auth("", "", true, "")
	mPutGroupMembershipDecision.Expected("NO_CONTENT")
	mPutGroupMembershipDecision.Exception("BAD_REQUEST", "ResourceError", "")
	mPutGroupMembershipDecision.Exception("CONFLICT", "ResourceError", "")
	mPutGroupMembershipDecision.Exception("FORBIDDEN", "ResourceError", "")
	mPutGroupMembershipDecision.Exception("NOT_FOUND", "ResourceError", "")
	mPutGroupMembershipDecision.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutGroupMembershipDecision.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutGroupMembershipDecision.Build())

	mPutGroupReview := rdl.NewResourceBuilder("Group", "PUT", "/domain/{domainName}/group/{groupName}/review")
	mPutGroupReview.Comment("Review group membership and take action to either extend and/or delete existing members. The required authorization includes three options: 1. (\"update\", \"{domainName}:group.{groupName}\") 2. (\"update_members\", \"{domainName}:group.{groupName}\")")
	mPutGroupReview.Name("PutGroupReview")
	mPutGroupReview.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutGroupReview.Input("groupName", "EntityName", true, "", "", false, nil, "name of the group")
	mPutGroupReview.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutGroupReview.Input("returnObj", "Bool", false, "", "Athenz-Return-Object", true, false, "Return object param updated object back.")
	mPutGroupReview.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mPutGroupReview.Input("group", "Group", false, "", "", false, nil, "Group object with updated and/or deleted members")
	mPutGroupReview.Auth("", "", true, "")
	mPutGroupReview.Expected("NO_CONTENT")
	mPutGroupReview.Exception("BAD_REQUEST", "ResourceError", "")
	mPutGroupReview.Exception("CONFLICT", "ResourceError", "")
	mPutGroupReview.Exception("FORBIDDEN", "ResourceError", "")
	mPutGroupReview.Exception("NOT_FOUND", "ResourceError", "")
	mPutGroupReview.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutGroupReview.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutGroupReview.Build())

	mGetPendingDomainGroupMembersList := rdl.NewResourceBuilder("DomainGroupMembership", "GET", "/pending_group_members")
	mGetPendingDomainGroupMembersList.Comment("List of domains containing groups and corresponding members to be approved by either calling or specified principal")
	mGetPendingDomainGroupMembersList.Name("getPendingDomainGroupMembersList")
	mGetPendingDomainGroupMembersList.Input("principal", "EntityName", false, "principal", "", true, nil, "If present, return pending list for this principal")
	mGetPendingDomainGroupMembersList.Input("domainName", "String", false, "domain", "", true, nil, "If present, return pending list for this domain")
	mGetPendingDomainGroupMembersList.Auth("", "", true, "")
	mGetPendingDomainGroupMembersList.Exception("BAD_REQUEST", "ResourceError", "")
	mGetPendingDomainGroupMembersList.Exception("FORBIDDEN", "ResourceError", "")
	mGetPendingDomainGroupMembersList.Exception("NOT_FOUND", "ResourceError", "")
	mGetPendingDomainGroupMembersList.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetPendingDomainGroupMembersList.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetPendingDomainGroupMembersList.Build())

	mPutResourceGroupOwnership := rdl.NewResourceBuilder("ResourceGroupOwnership", "PUT", "/domain/{domainName}/group/{groupName}/ownership")
	mPutResourceGroupOwnership.Comment("Set the resource ownership for the given group")
	mPutResourceGroupOwnership.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutResourceGroupOwnership.Input("groupName", "EntityName", true, "", "", false, nil, "name of the group")
	mPutResourceGroupOwnership.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutResourceGroupOwnership.Input("resourceOwnership", "ResourceGroupOwnership", false, "", "", false, nil, "resource ownership to be set for the given group")
	mPutResourceGroupOwnership.Auth("update", "{domainName}:meta.group.ownership.{groupName}", false, "")
	mPutResourceGroupOwnership.Expected("NO_CONTENT")
	mPutResourceGroupOwnership.Exception("BAD_REQUEST", "ResourceError", "")
	mPutResourceGroupOwnership.Exception("FORBIDDEN", "ResourceError", "")
	mPutResourceGroupOwnership.Exception("NOT_FOUND", "ResourceError", "")
	mPutResourceGroupOwnership.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutResourceGroupOwnership.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutResourceGroupOwnership.Build())

	mGetDomainGroupMembers := rdl.NewResourceBuilder("DomainGroupMembers", "GET", "/domain/{domainName}/group/member")
	mGetDomainGroupMembers.Comment("Get list of principals defined in groups in the given domain")
	mGetDomainGroupMembers.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetDomainGroupMembers.Auth("", "", true, "")
	mGetDomainGroupMembers.Exception("BAD_REQUEST", "ResourceError", "")
	mGetDomainGroupMembers.Exception("FORBIDDEN", "ResourceError", "")
	mGetDomainGroupMembers.Exception("NOT_FOUND", "ResourceError", "")
	mGetDomainGroupMembers.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetDomainGroupMembers.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetDomainGroupMembers.Build())

	mGetPolicyList := rdl.NewResourceBuilder("PolicyList", "GET", "/domain/{domainName}/policy")
	mGetPolicyList.Comment("List policies provisioned in this namespace.")
	mGetPolicyList.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetPolicyList.Input("limit", "Int32", false, "limit", "", true, nil, "restrict the number of results in this call")
	mGetPolicyList.Input("skip", "String", false, "skip", "", true, nil, "restrict the set to those after the specified \"next\" token returned from a previous call")
	mGetPolicyList.Auth("", "", true, "")
	mGetPolicyList.Exception("BAD_REQUEST", "ResourceError", "")
	mGetPolicyList.Exception("FORBIDDEN", "ResourceError", "")
	mGetPolicyList.Exception("NOT_FOUND", "ResourceError", "")
	mGetPolicyList.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetPolicyList.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetPolicyList.Build())

	mGetPolicies := rdl.NewResourceBuilder("Policies", "GET", "/domain/{domainName}/policies")
	mGetPolicies.Comment("List policies provisioned in this namespace.")
	mGetPolicies.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetPolicies.Input("assertions", "Bool", false, "assertions", "", true, false, "return list of assertions in the policy")
	mGetPolicies.Input("includeNonActive", "Bool", false, "includeNonActive", "", true, false, "include non-active policy versions")
	mGetPolicies.Input("tagKey", "TagKey", false, "tagKey", "", true, nil, "flag to query all policies that have a given tagName")
	mGetPolicies.Input("tagValue", "TagCompoundValue", false, "tagValue", "", true, nil, "flag to query all policies that have a given tag name and value")
	mGetPolicies.Auth("", "", true, "")
	mGetPolicies.Exception("BAD_REQUEST", "ResourceError", "")
	mGetPolicies.Exception("NOT_FOUND", "ResourceError", "")
	mGetPolicies.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetPolicies.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetPolicies.Build())

	mGetPolicy := rdl.NewResourceBuilder("Policy", "GET", "/domain/{domainName}/policy/{policyName}")
	mGetPolicy.Comment("Read the specified policy.")
	mGetPolicy.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetPolicy.Input("policyName", "EntityName", true, "", "", false, nil, "name of the policy to be retrieved")
	mGetPolicy.Auth("", "", true, "")
	mGetPolicy.Exception("BAD_REQUEST", "ResourceError", "")
	mGetPolicy.Exception("FORBIDDEN", "ResourceError", "")
	mGetPolicy.Exception("NOT_FOUND", "ResourceError", "")
	mGetPolicy.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetPolicy.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetPolicy.Build())

	mPutPolicy := rdl.NewResourceBuilder("Policy", "PUT", "/domain/{domainName}/policy/{policyName}")
	mPutPolicy.Comment("Create or update the specified policy.")
	mPutPolicy.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutPolicy.Input("policyName", "EntityName", true, "", "", false, nil, "name of the policy to be added/updated")
	mPutPolicy.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutPolicy.Input("returnObj", "Bool", false, "", "Athenz-Return-Object", true, false, "Return object param updated object back.")
	mPutPolicy.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mPutPolicy.Input("policy", "Policy", false, "", "", false, nil, "Policy object to be added or updated in the domain")
	mPutPolicy.Auth("update", "{domainName}:policy.{policyName}", false, "")
	mPutPolicy.Expected("NO_CONTENT")
	mPutPolicy.Exception("BAD_REQUEST", "ResourceError", "")
	mPutPolicy.Exception("CONFLICT", "ResourceError", "")
	mPutPolicy.Exception("FORBIDDEN", "ResourceError", "")
	mPutPolicy.Exception("NOT_FOUND", "ResourceError", "")
	mPutPolicy.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutPolicy.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutPolicy.Build())

	mDeletePolicy := rdl.NewResourceBuilder("Policy", "DELETE", "/domain/{domainName}/policy/{policyName}")
	mDeletePolicy.Comment("Delete the specified policy. Upon successful completion of this delete request, the server will return NO_CONTENT status code without any data (no object will be returned).")
	mDeletePolicy.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mDeletePolicy.Input("policyName", "EntityName", true, "", "", false, nil, "name of the policy to be deleted")
	mDeletePolicy.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mDeletePolicy.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mDeletePolicy.Auth("delete", "{domainName}:policy.{policyName}", false, "")
	mDeletePolicy.Expected("NO_CONTENT")
	mDeletePolicy.Exception("BAD_REQUEST", "ResourceError", "")
	mDeletePolicy.Exception("CONFLICT", "ResourceError", "")
	mDeletePolicy.Exception("FORBIDDEN", "ResourceError", "")
	mDeletePolicy.Exception("NOT_FOUND", "ResourceError", "")
	mDeletePolicy.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeletePolicy.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeletePolicy.Build())

	mGetAssertion := rdl.NewResourceBuilder("Assertion", "GET", "/domain/{domainName}/policy/{policyName}/assertion/{assertionId}")
	mGetAssertion.Comment("Get the assertion details with specified id in the given policy")
	mGetAssertion.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetAssertion.Input("policyName", "EntityName", true, "", "", false, nil, "name of the policy")
	mGetAssertion.Input("assertionId", "Int64", true, "", "", false, nil, "assertion id")
	mGetAssertion.Auth("", "", true, "")
	mGetAssertion.Exception("BAD_REQUEST", "ResourceError", "")
	mGetAssertion.Exception("FORBIDDEN", "ResourceError", "")
	mGetAssertion.Exception("NOT_FOUND", "ResourceError", "")
	mGetAssertion.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetAssertion.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetAssertion.Build())

	mPutAssertion := rdl.NewResourceBuilder("Assertion", "PUT", "/domain/{domainName}/policy/{policyName}/assertion")
	mPutAssertion.Comment("Add the specified assertion to the given policy")
	mPutAssertion.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutAssertion.Input("policyName", "EntityName", true, "", "", false, nil, "name of the policy")
	mPutAssertion.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutAssertion.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mPutAssertion.Input("assertion", "Assertion", false, "", "", false, nil, "Assertion object to be added to the given policy")
	mPutAssertion.Auth("update", "{domainName}:policy.{policyName}", false, "")
	mPutAssertion.Exception("BAD_REQUEST", "ResourceError", "")
	mPutAssertion.Exception("CONFLICT", "ResourceError", "")
	mPutAssertion.Exception("FORBIDDEN", "ResourceError", "")
	mPutAssertion.Exception("NOT_FOUND", "ResourceError", "")
	mPutAssertion.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutAssertion.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutAssertion.Build())

	mPutAssertionPolicyVersion := rdl.NewResourceBuilder("Assertion", "PUT", "/domain/{domainName}/policy/{policyName}/version/{version}/assertion")
	mPutAssertionPolicyVersion.Comment("Add the specified assertion to the given policy version")
	mPutAssertionPolicyVersion.Name("putAssertionPolicyVersion")
	mPutAssertionPolicyVersion.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutAssertionPolicyVersion.Input("policyName", "EntityName", true, "", "", false, nil, "name of the policy")
	mPutAssertionPolicyVersion.Input("version", "SimpleName", true, "", "", false, nil, "name of the version")
	mPutAssertionPolicyVersion.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutAssertionPolicyVersion.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mPutAssertionPolicyVersion.Input("assertion", "Assertion", false, "", "", false, nil, "Assertion object to be added to the given policy version")
	mPutAssertionPolicyVersion.Auth("update", "{domainName}:policy.{policyName}", false, "")
	mPutAssertionPolicyVersion.Exception("BAD_REQUEST", "ResourceError", "")
	mPutAssertionPolicyVersion.Exception("CONFLICT", "ResourceError", "")
	mPutAssertionPolicyVersion.Exception("FORBIDDEN", "ResourceError", "")
	mPutAssertionPolicyVersion.Exception("NOT_FOUND", "ResourceError", "")
	mPutAssertionPolicyVersion.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutAssertionPolicyVersion.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutAssertionPolicyVersion.Build())

	mDeleteAssertion := rdl.NewResourceBuilder("Assertion", "DELETE", "/domain/{domainName}/policy/{policyName}/assertion/{assertionId}")
	mDeleteAssertion.Comment("Delete the specified policy assertion. Upon successful completion of this delete request, the server will return NO_CONTENT status code without any data (no object will be returned). The required authorization includes two options: 1. (\"update\", \"{domainName}:policy.{policyName}\") 2. (\"delete\", \"{domainName}:policy.{policyName}.assertion.{assertionId}\")")
	mDeleteAssertion.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mDeleteAssertion.Input("policyName", "EntityName", true, "", "", false, nil, "name of the policy")
	mDeleteAssertion.Input("assertionId", "Int64", true, "", "", false, nil, "assertion id")
	mDeleteAssertion.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mDeleteAssertion.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mDeleteAssertion.Auth("", "", true, "")
	mDeleteAssertion.Expected("NO_CONTENT")
	mDeleteAssertion.Exception("BAD_REQUEST", "ResourceError", "")
	mDeleteAssertion.Exception("CONFLICT", "ResourceError", "")
	mDeleteAssertion.Exception("FORBIDDEN", "ResourceError", "")
	mDeleteAssertion.Exception("NOT_FOUND", "ResourceError", "")
	mDeleteAssertion.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeleteAssertion.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeleteAssertion.Build())

	mDeleteAssertionPolicyVersion := rdl.NewResourceBuilder("Assertion", "DELETE", "/domain/{domainName}/policy/{policyName}/version/{version}/assertion/{assertionId}")
	mDeleteAssertionPolicyVersion.Comment("Delete the specified policy version assertion. Upon successful completion of this delete request, the server will return NO_CONTENT status code without any data (no object will be returned). The required authorization includes two options: 1. (\"update\", \"{domainName}:policy.{policyName}\") 2. (\"delete\", \"{domainName}:policy.{policyName}.assertion.{assertionId}\")")
	mDeleteAssertionPolicyVersion.Name("deleteAssertionPolicyVersion")
	mDeleteAssertionPolicyVersion.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mDeleteAssertionPolicyVersion.Input("policyName", "EntityName", true, "", "", false, nil, "name of the policy")
	mDeleteAssertionPolicyVersion.Input("version", "SimpleName", true, "", "", false, nil, "name of the version")
	mDeleteAssertionPolicyVersion.Input("assertionId", "Int64", true, "", "", false, nil, "assertion id")
	mDeleteAssertionPolicyVersion.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mDeleteAssertionPolicyVersion.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mDeleteAssertionPolicyVersion.Auth("", "", true, "")
	mDeleteAssertionPolicyVersion.Expected("NO_CONTENT")
	mDeleteAssertionPolicyVersion.Exception("BAD_REQUEST", "ResourceError", "")
	mDeleteAssertionPolicyVersion.Exception("CONFLICT", "ResourceError", "")
	mDeleteAssertionPolicyVersion.Exception("FORBIDDEN", "ResourceError", "")
	mDeleteAssertionPolicyVersion.Exception("NOT_FOUND", "ResourceError", "")
	mDeleteAssertionPolicyVersion.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeleteAssertionPolicyVersion.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeleteAssertionPolicyVersion.Build())

	mPutAssertionConditions := rdl.NewResourceBuilder("AssertionConditions", "PUT", "/domain/{domainName}/policy/{policyName}/assertion/{assertionId}/conditions")
	mPutAssertionConditions.Comment("Add the specified conditions to the given assertion")
	mPutAssertionConditions.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutAssertionConditions.Input("policyName", "EntityName", true, "", "", false, nil, "name of the policy")
	mPutAssertionConditions.Input("assertionId", "Int64", true, "", "", false, nil, "assertion id")
	mPutAssertionConditions.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutAssertionConditions.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mPutAssertionConditions.Input("assertionConditions", "AssertionConditions", false, "", "", false, nil, "Assertion conditions object to be added to the given assertion")
	mPutAssertionConditions.Auth("update", "{domainName}:policy.{policyName}", false, "")
	mPutAssertionConditions.Exception("BAD_REQUEST", "ResourceError", "")
	mPutAssertionConditions.Exception("CONFLICT", "ResourceError", "")
	mPutAssertionConditions.Exception("FORBIDDEN", "ResourceError", "")
	mPutAssertionConditions.Exception("NOT_FOUND", "ResourceError", "")
	mPutAssertionConditions.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutAssertionConditions.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutAssertionConditions.Build())

	mPutAssertionCondition := rdl.NewResourceBuilder("AssertionCondition", "PUT", "/domain/{domainName}/policy/{policyName}/assertion/{assertionId}/condition")
	mPutAssertionCondition.Comment("Add the specified condition to the existing assertion conditions of an assertion")
	mPutAssertionCondition.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutAssertionCondition.Input("policyName", "EntityName", true, "", "", false, nil, "name of the policy")
	mPutAssertionCondition.Input("assertionId", "Int64", true, "", "", false, nil, "assertion id")
	mPutAssertionCondition.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutAssertionCondition.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mPutAssertionCondition.Input("assertionCondition", "AssertionCondition", false, "", "", false, nil, "Assertion conditions object to be added to the given assertion")
	mPutAssertionCondition.Auth("update", "{domainName}:policy.{policyName}", false, "")
	mPutAssertionCondition.Exception("BAD_REQUEST", "ResourceError", "")
	mPutAssertionCondition.Exception("CONFLICT", "ResourceError", "")
	mPutAssertionCondition.Exception("FORBIDDEN", "ResourceError", "")
	mPutAssertionCondition.Exception("NOT_FOUND", "ResourceError", "")
	mPutAssertionCondition.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutAssertionCondition.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutAssertionCondition.Build())

	mDeleteAssertionConditions := rdl.NewResourceBuilder("AssertionConditions", "DELETE", "/domain/{domainName}/policy/{policyName}/assertion/{assertionId}/conditions")
	mDeleteAssertionConditions.Comment("Delete all assertion conditions for specified assertion id. Upon successful completion of this delete request, the server will return NO_CONTENT status code without any data (no object will be returned).")
	mDeleteAssertionConditions.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mDeleteAssertionConditions.Input("policyName", "EntityName", true, "", "", false, nil, "name of the policy")
	mDeleteAssertionConditions.Input("assertionId", "Int64", true, "", "", false, nil, "assertion id")
	mDeleteAssertionConditions.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mDeleteAssertionConditions.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mDeleteAssertionConditions.Auth("update", "{domainName}:policy.{policyName}", false, "")
	mDeleteAssertionConditions.Expected("NO_CONTENT")
	mDeleteAssertionConditions.Exception("BAD_REQUEST", "ResourceError", "")
	mDeleteAssertionConditions.Exception("CONFLICT", "ResourceError", "")
	mDeleteAssertionConditions.Exception("FORBIDDEN", "ResourceError", "")
	mDeleteAssertionConditions.Exception("NOT_FOUND", "ResourceError", "")
	mDeleteAssertionConditions.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeleteAssertionConditions.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeleteAssertionConditions.Build())

	mDeleteAssertionCondition := rdl.NewResourceBuilder("AssertionCondition", "DELETE", "/domain/{domainName}/policy/{policyName}/assertion/{assertionId}/condition/{conditionId}")
	mDeleteAssertionCondition.Comment("Delete the assertion condition(s) for specified assertion id and condition id. Upon successful completion of this delete request, the server will return NO_CONTENT status code without any data (no object will be returned).")
	mDeleteAssertionCondition.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mDeleteAssertionCondition.Input("policyName", "EntityName", true, "", "", false, nil, "name of the policy")
	mDeleteAssertionCondition.Input("assertionId", "Int64", true, "", "", false, nil, "assertion id")
	mDeleteAssertionCondition.Input("conditionId", "Int32", true, "", "", false, nil, "condition id")
	mDeleteAssertionCondition.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mDeleteAssertionCondition.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mDeleteAssertionCondition.Auth("update", "{domainName}:policy.{policyName}", false, "")
	mDeleteAssertionCondition.Expected("NO_CONTENT")
	mDeleteAssertionCondition.Exception("BAD_REQUEST", "ResourceError", "")
	mDeleteAssertionCondition.Exception("CONFLICT", "ResourceError", "")
	mDeleteAssertionCondition.Exception("FORBIDDEN", "ResourceError", "")
	mDeleteAssertionCondition.Exception("NOT_FOUND", "ResourceError", "")
	mDeleteAssertionCondition.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeleteAssertionCondition.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeleteAssertionCondition.Build())

	mGetPolicyVersionList := rdl.NewResourceBuilder("PolicyList", "GET", "/domain/{domainName}/policy/{policyName}/version")
	mGetPolicyVersionList.Comment("List policy versions.")
	mGetPolicyVersionList.Name("getPolicyVersionList")
	mGetPolicyVersionList.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetPolicyVersionList.Input("policyName", "EntityName", true, "", "", false, nil, "name of the policy")
	mGetPolicyVersionList.Auth("", "", true, "")
	mGetPolicyVersionList.Exception("BAD_REQUEST", "ResourceError", "")
	mGetPolicyVersionList.Exception("FORBIDDEN", "ResourceError", "")
	mGetPolicyVersionList.Exception("NOT_FOUND", "ResourceError", "")
	mGetPolicyVersionList.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetPolicyVersionList.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetPolicyVersionList.Build())

	mGetPolicyVersion := rdl.NewResourceBuilder("Policy", "GET", "/domain/{domainName}/policy/{policyName}/version/{version}")
	mGetPolicyVersion.Comment("Get the specified policy version.")
	mGetPolicyVersion.Name("getPolicyVersion")
	mGetPolicyVersion.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetPolicyVersion.Input("policyName", "EntityName", true, "", "", false, nil, "name of the policy")
	mGetPolicyVersion.Input("version", "SimpleName", true, "", "", false, nil, "name of the version to be retrieved")
	mGetPolicyVersion.Auth("", "", true, "")
	mGetPolicyVersion.Exception("BAD_REQUEST", "ResourceError", "")
	mGetPolicyVersion.Exception("FORBIDDEN", "ResourceError", "")
	mGetPolicyVersion.Exception("NOT_FOUND", "ResourceError", "")
	mGetPolicyVersion.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetPolicyVersion.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetPolicyVersion.Build())

	mPutPolicyVersion := rdl.NewResourceBuilder("Policy", "PUT", "/domain/{domainName}/policy/{policyName}/version/create")
	mPutPolicyVersion.Comment("Create a new disabled policy version based on active policy")
	mPutPolicyVersion.Name("putPolicyVersion")
	mPutPolicyVersion.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutPolicyVersion.Input("policyName", "EntityName", true, "", "", false, nil, "name of the policy to be added/updated")
	mPutPolicyVersion.Input("policyOptions", "PolicyOptions", false, "", "", false, nil, "name of the source version to copy from and name of new version")
	mPutPolicyVersion.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutPolicyVersion.Input("returnObj", "Bool", false, "", "Athenz-Return-Object", true, false, "Return object param updated object back.")
	mPutPolicyVersion.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mPutPolicyVersion.Auth("update", "{domainName}:policy.{policyName}", false, "")
	mPutPolicyVersion.Expected("NO_CONTENT")
	mPutPolicyVersion.Exception("BAD_REQUEST", "ResourceError", "")
	mPutPolicyVersion.Exception("CONFLICT", "ResourceError", "")
	mPutPolicyVersion.Exception("FORBIDDEN", "ResourceError", "")
	mPutPolicyVersion.Exception("NOT_FOUND", "ResourceError", "")
	mPutPolicyVersion.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutPolicyVersion.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutPolicyVersion.Build())

	mSetActivePolicyVersion := rdl.NewResourceBuilder("Policy", "PUT", "/domain/{domainName}/policy/{policyName}/version/active")
	mSetActivePolicyVersion.Comment("Mark the specified policy version as active")
	mSetActivePolicyVersion.Name("setActivePolicyVersion")
	mSetActivePolicyVersion.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mSetActivePolicyVersion.Input("policyName", "EntityName", true, "", "", false, nil, "name of the policy")
	mSetActivePolicyVersion.Input("policyOptions", "PolicyOptions", false, "", "", false, nil, "name of the version")
	mSetActivePolicyVersion.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mSetActivePolicyVersion.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mSetActivePolicyVersion.Auth("update", "{domainName}:policy.{policyName}", false, "")
	mSetActivePolicyVersion.Expected("NO_CONTENT")
	mSetActivePolicyVersion.Exception("BAD_REQUEST", "ResourceError", "")
	mSetActivePolicyVersion.Exception("CONFLICT", "ResourceError", "")
	mSetActivePolicyVersion.Exception("FORBIDDEN", "ResourceError", "")
	mSetActivePolicyVersion.Exception("NOT_FOUND", "ResourceError", "")
	mSetActivePolicyVersion.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mSetActivePolicyVersion.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mSetActivePolicyVersion.Build())

	mDeletePolicyVersion := rdl.NewResourceBuilder("Policy", "DELETE", "/domain/{domainName}/policy/{policyName}/version/{version}")
	mDeletePolicyVersion.Comment("Delete the specified policy version. Upon successful completion of this delete request, the server will return NO_CONTENT status code without any data (no object will be returned).")
	mDeletePolicyVersion.Name("deletePolicyVersion")
	mDeletePolicyVersion.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mDeletePolicyVersion.Input("policyName", "EntityName", true, "", "", false, nil, "name of the policy")
	mDeletePolicyVersion.Input("version", "SimpleName", true, "", "", false, nil, "name of the version to be deleted")
	mDeletePolicyVersion.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mDeletePolicyVersion.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mDeletePolicyVersion.Auth("delete", "{domainName}:policy.{policyName}", false, "")
	mDeletePolicyVersion.Expected("NO_CONTENT")
	mDeletePolicyVersion.Exception("BAD_REQUEST", "ResourceError", "")
	mDeletePolicyVersion.Exception("CONFLICT", "ResourceError", "")
	mDeletePolicyVersion.Exception("FORBIDDEN", "ResourceError", "")
	mDeletePolicyVersion.Exception("NOT_FOUND", "ResourceError", "")
	mDeletePolicyVersion.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeletePolicyVersion.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeletePolicyVersion.Build())

	mPutResourcePolicyOwnership := rdl.NewResourceBuilder("ResourcePolicyOwnership", "PUT", "/domain/{domainName}/policy/{policyName}/ownership")
	mPutResourcePolicyOwnership.Comment("Set the resource ownership for the given policy")
	mPutResourcePolicyOwnership.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutResourcePolicyOwnership.Input("policyName", "EntityName", true, "", "", false, nil, "name of the policy")
	mPutResourcePolicyOwnership.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutResourcePolicyOwnership.Input("resourceOwnership", "ResourcePolicyOwnership", false, "", "", false, nil, "resource ownership to be set for the given policy")
	mPutResourcePolicyOwnership.Auth("update", "{domainName}:meta.policy.ownership.{policyName}", false, "")
	mPutResourcePolicyOwnership.Expected("NO_CONTENT")
	mPutResourcePolicyOwnership.Exception("BAD_REQUEST", "ResourceError", "")
	mPutResourcePolicyOwnership.Exception("FORBIDDEN", "ResourceError", "")
	mPutResourcePolicyOwnership.Exception("NOT_FOUND", "ResourceError", "")
	mPutResourcePolicyOwnership.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutResourcePolicyOwnership.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutResourcePolicyOwnership.Build())

	mPutServiceIdentity := rdl.NewResourceBuilder("ServiceIdentity", "PUT", "/domain/{domain}/service/{service}")
	mPutServiceIdentity.Comment("Register the specified ServiceIdentity in the specified domain")
	mPutServiceIdentity.Input("domain", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutServiceIdentity.Input("service", "SimpleName", true, "", "", false, nil, "name of the service")
	mPutServiceIdentity.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutServiceIdentity.Input("returnObj", "Bool", false, "", "Athenz-Return-Object", true, false, "Return object param updated object back.")
	mPutServiceIdentity.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mPutServiceIdentity.Input("detail", "ServiceIdentity", false, "", "", false, nil, "ServiceIdentity object to be added/updated in the domain")
	mPutServiceIdentity.Auth("update", "{domain}:service.{service}", false, "")
	mPutServiceIdentity.Expected("NO_CONTENT")
	mPutServiceIdentity.Exception("BAD_REQUEST", "ResourceError", "")
	mPutServiceIdentity.Exception("CONFLICT", "ResourceError", "")
	mPutServiceIdentity.Exception("FORBIDDEN", "ResourceError", "")
	mPutServiceIdentity.Exception("NOT_FOUND", "ResourceError", "")
	mPutServiceIdentity.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutServiceIdentity.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutServiceIdentity.Build())

	mGetServiceIdentity := rdl.NewResourceBuilder("ServiceIdentity", "GET", "/domain/{domain}/service/{service}")
	mGetServiceIdentity.Comment("Get info for the specified ServiceIdentity.")
	mGetServiceIdentity.Input("domain", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetServiceIdentity.Input("service", "SimpleName", true, "", "", false, nil, "name of the service to be retrieved")
	mGetServiceIdentity.Auth("", "", true, "")
	mGetServiceIdentity.Exception("BAD_REQUEST", "ResourceError", "")
	mGetServiceIdentity.Exception("FORBIDDEN", "ResourceError", "")
	mGetServiceIdentity.Exception("NOT_FOUND", "ResourceError", "")
	mGetServiceIdentity.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetServiceIdentity.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetServiceIdentity.Build())

	mDeleteServiceIdentity := rdl.NewResourceBuilder("ServiceIdentity", "DELETE", "/domain/{domain}/service/{service}")
	mDeleteServiceIdentity.Comment("Delete the specified ServiceIdentity. Upon successful completion of this delete request, the server will return NO_CONTENT status code without any data (no object will be returned).")
	mDeleteServiceIdentity.Input("domain", "DomainName", true, "", "", false, nil, "name of the domain")
	mDeleteServiceIdentity.Input("service", "SimpleName", true, "", "", false, nil, "name of the service to be deleted")
	mDeleteServiceIdentity.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mDeleteServiceIdentity.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mDeleteServiceIdentity.Auth("delete", "{domain}:service.{service}", false, "")
	mDeleteServiceIdentity.Expected("NO_CONTENT")
	mDeleteServiceIdentity.Exception("BAD_REQUEST", "ResourceError", "")
	mDeleteServiceIdentity.Exception("CONFLICT", "ResourceError", "")
	mDeleteServiceIdentity.Exception("FORBIDDEN", "ResourceError", "")
	mDeleteServiceIdentity.Exception("NOT_FOUND", "ResourceError", "")
	mDeleteServiceIdentity.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeleteServiceIdentity.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeleteServiceIdentity.Build())

	mGetServiceIdentities := rdl.NewResourceBuilder("ServiceIdentities", "GET", "/domain/{domainName}/services")
	mGetServiceIdentities.Comment("Retrieve list of service identities")
	mGetServiceIdentities.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetServiceIdentities.Input("publickeys", "Bool", false, "publickeys", "", true, false, "return list of public keys in the service")
	mGetServiceIdentities.Input("hosts", "Bool", false, "hosts", "", true, false, "return list of hosts in the service")
	mGetServiceIdentities.Input("tagKey", "TagKey", false, "tagKey", "", true, nil, "flag to query all services that have a given tagName")
	mGetServiceIdentities.Input("tagValue", "TagCompoundValue", false, "tagValue", "", true, nil, "flag to query all services that have a given tag name and value")
	mGetServiceIdentities.Auth("", "", true, "")
	mGetServiceIdentities.Exception("BAD_REQUEST", "ResourceError", "")
	mGetServiceIdentities.Exception("NOT_FOUND", "ResourceError", "")
	mGetServiceIdentities.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetServiceIdentities.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetServiceIdentities.Build())

	mGetServiceIdentityList := rdl.NewResourceBuilder("ServiceIdentityList", "GET", "/domain/{domainName}/service")
	mGetServiceIdentityList.Comment("Enumerate services provisioned in this domain.")
	mGetServiceIdentityList.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetServiceIdentityList.Input("limit", "Int32", false, "limit", "", true, nil, "restrict the number of results in this call")
	mGetServiceIdentityList.Input("skip", "String", false, "skip", "", true, nil, "restrict the set to those after the specified \"next\" token returned from a previous call")
	mGetServiceIdentityList.Auth("", "", true, "")
	mGetServiceIdentityList.Exception("BAD_REQUEST", "ResourceError", "")
	mGetServiceIdentityList.Exception("FORBIDDEN", "ResourceError", "")
	mGetServiceIdentityList.Exception("NOT_FOUND", "ResourceError", "")
	mGetServiceIdentityList.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetServiceIdentityList.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetServiceIdentityList.Build())

	mGetPublicKeyEntry := rdl.NewResourceBuilder("PublicKeyEntry", "GET", "/domain/{domain}/service/{service}/publickey/{id}")
	mGetPublicKeyEntry.Comment("Retrieve the specified public key from the service.")
	mGetPublicKeyEntry.Input("domain", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetPublicKeyEntry.Input("service", "SimpleName", true, "", "", false, nil, "name of the service")
	mGetPublicKeyEntry.Input("id", "String", true, "", "", false, nil, "the identifier of the public key to be retrieved")
	mGetPublicKeyEntry.Auth("", "", true, "")
	mGetPublicKeyEntry.Exception("BAD_REQUEST", "ResourceError", "")
	mGetPublicKeyEntry.Exception("FORBIDDEN", "ResourceError", "")
	mGetPublicKeyEntry.Exception("NOT_FOUND", "ResourceError", "")
	mGetPublicKeyEntry.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetPublicKeyEntry.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetPublicKeyEntry.Build())

	mPutPublicKeyEntry := rdl.NewResourceBuilder("PublicKeyEntry", "PUT", "/domain/{domain}/service/{service}/publickey/{id}")
	mPutPublicKeyEntry.Comment("Add the specified public key to the service.")
	mPutPublicKeyEntry.Input("domain", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutPublicKeyEntry.Input("service", "SimpleName", true, "", "", false, nil, "name of the service")
	mPutPublicKeyEntry.Input("id", "String", true, "", "", false, nil, "the identifier of the public key to be added")
	mPutPublicKeyEntry.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutPublicKeyEntry.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mPutPublicKeyEntry.Input("publicKeyEntry", "PublicKeyEntry", false, "", "", false, nil, "PublicKeyEntry object to be added/updated in the service")
	mPutPublicKeyEntry.Auth("update", "{domain}:service.{service}", false, "")
	mPutPublicKeyEntry.Expected("NO_CONTENT")
	mPutPublicKeyEntry.Exception("BAD_REQUEST", "ResourceError", "")
	mPutPublicKeyEntry.Exception("CONFLICT", "ResourceError", "")
	mPutPublicKeyEntry.Exception("FORBIDDEN", "ResourceError", "")
	mPutPublicKeyEntry.Exception("NOT_FOUND", "ResourceError", "")
	mPutPublicKeyEntry.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutPublicKeyEntry.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutPublicKeyEntry.Build())

	mDeletePublicKeyEntry := rdl.NewResourceBuilder("PublicKeyEntry", "DELETE", "/domain/{domain}/service/{service}/publickey/{id}")
	mDeletePublicKeyEntry.Comment("Remove the specified public key from the service. Upon successful completion of this delete request, the server will return NO_CONTENT status code without any data (no object will be returned).")
	mDeletePublicKeyEntry.Input("domain", "DomainName", true, "", "", false, nil, "name of the domain")
	mDeletePublicKeyEntry.Input("service", "SimpleName", true, "", "", false, nil, "name of the service")
	mDeletePublicKeyEntry.Input("id", "String", true, "", "", false, nil, "the identifier of the public key to be deleted")
	mDeletePublicKeyEntry.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mDeletePublicKeyEntry.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mDeletePublicKeyEntry.Auth("update", "{domain}:service.{service}", false, "")
	mDeletePublicKeyEntry.Expected("NO_CONTENT")
	mDeletePublicKeyEntry.Exception("BAD_REQUEST", "ResourceError", "")
	mDeletePublicKeyEntry.Exception("CONFLICT", "ResourceError", "")
	mDeletePublicKeyEntry.Exception("FORBIDDEN", "ResourceError", "")
	mDeletePublicKeyEntry.Exception("NOT_FOUND", "ResourceError", "")
	mDeletePublicKeyEntry.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeletePublicKeyEntry.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeletePublicKeyEntry.Build())

	mPutServiceIdentitySystemMeta := rdl.NewResourceBuilder("ServiceIdentity", "PUT", "/domain/{domain}/service/{service}/meta/system/{attribute}")
	mPutServiceIdentitySystemMeta.Comment("Set the specified service metadata. Caller must have update privileges on the sys.auth domain.")
	mPutServiceIdentitySystemMeta.Input("domain", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutServiceIdentitySystemMeta.Input("service", "SimpleName", true, "", "", false, nil, "name of the service")
	mPutServiceIdentitySystemMeta.Input("attribute", "SimpleName", true, "", "", false, nil, "name of the system attribute to be modified")
	mPutServiceIdentitySystemMeta.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutServiceIdentitySystemMeta.Input("detail", "ServiceIdentitySystemMeta", false, "", "", false, nil, "ServiceIdentitySystemMeta object with updated attribute values")
	mPutServiceIdentitySystemMeta.Auth("update", "sys.auth:meta.service.{attribute}.{domain}", false, "")
	mPutServiceIdentitySystemMeta.Expected("NO_CONTENT")
	mPutServiceIdentitySystemMeta.Exception("BAD_REQUEST", "ResourceError", "")
	mPutServiceIdentitySystemMeta.Exception("CONFLICT", "ResourceError", "")
	mPutServiceIdentitySystemMeta.Exception("FORBIDDEN", "ResourceError", "")
	mPutServiceIdentitySystemMeta.Exception("NOT_FOUND", "ResourceError", "")
	mPutServiceIdentitySystemMeta.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutServiceIdentitySystemMeta.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutServiceIdentitySystemMeta.Build())

	mPutResourceServiceIdentityOwnership := rdl.NewResourceBuilder("ResourceServiceIdentityOwnership", "PUT", "/domain/{domainName}/service/{service}/ownership")
	mPutResourceServiceIdentityOwnership.Comment("Set the resource ownership for the given service")
	mPutResourceServiceIdentityOwnership.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutResourceServiceIdentityOwnership.Input("service", "SimpleName", true, "", "", false, nil, "name of the service")
	mPutResourceServiceIdentityOwnership.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutResourceServiceIdentityOwnership.Input("resourceOwnership", "ResourceServiceIdentityOwnership", false, "", "", false, nil, "resource ownership to be set for the given service")
	mPutResourceServiceIdentityOwnership.Auth("update", "{domainName}:meta.service.ownership.{service}", false, "")
	mPutResourceServiceIdentityOwnership.Expected("NO_CONTENT")
	mPutResourceServiceIdentityOwnership.Exception("BAD_REQUEST", "ResourceError", "")
	mPutResourceServiceIdentityOwnership.Exception("FORBIDDEN", "ResourceError", "")
	mPutResourceServiceIdentityOwnership.Exception("NOT_FOUND", "ResourceError", "")
	mPutResourceServiceIdentityOwnership.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutResourceServiceIdentityOwnership.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutResourceServiceIdentityOwnership.Build())

	mSearchServiceIdentities := rdl.NewResourceBuilder("ServiceIdentities", "GET", "/service/{serviceName}")
	mSearchServiceIdentities.Comment("Search for all services across all domains that match the specified service name. The service name can be a substring match based on the option substringMatch query parameter. The domainFilter query parameter can be used to limit the domain names.")
	mSearchServiceIdentities.Name("searchServiceIdentities")
	mSearchServiceIdentities.Input("serviceName", "SimpleName", true, "", "", false, nil, "name of the service (could be substring)")
	mSearchServiceIdentities.Input("substringMatch", "Bool", false, "substringMatch", "", true, false, "substring match for service name")
	mSearchServiceIdentities.Input("domainFilter", "DomainName", false, "domainFilter", "", true, nil, "domain filter match for service name")
	mSearchServiceIdentities.Auth("", "", true, "")
	mSearchServiceIdentities.Exception("BAD_REQUEST", "ResourceError", "")
	mSearchServiceIdentities.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	sb.AddResource(mSearchServiceIdentities.Build())

	mPutServiceCredsEntry := rdl.NewResourceBuilder("CredsEntry", "PUT", "/domain/{domain}/service/{service}/creds")
	mPutServiceCredsEntry.Comment("Add the specified credentials for the service.")
	mPutServiceCredsEntry.Name("PutServiceCredsEntry")
	mPutServiceCredsEntry.Input("domain", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutServiceCredsEntry.Input("service", "SimpleName", true, "", "", false, nil, "name of the service")
	mPutServiceCredsEntry.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutServiceCredsEntry.Input("resourceOwner", "String", false, "", "Athenz-Resource-Owner", false, nil, "Resource owner for the request")
	mPutServiceCredsEntry.Input("credEntry", "CredsEntry", false, "", "", false, nil, "CredsEntry object to be added/updated in the service")
	mPutServiceCredsEntry.Auth("update", "{domain}:service.{service}", false, "")
	mPutServiceCredsEntry.Expected("NO_CONTENT")
	mPutServiceCredsEntry.Exception("BAD_REQUEST", "ResourceError", "")
	mPutServiceCredsEntry.Exception("CONFLICT", "ResourceError", "")
	mPutServiceCredsEntry.Exception("FORBIDDEN", "ResourceError", "")
	mPutServiceCredsEntry.Exception("NOT_FOUND", "ResourceError", "")
	mPutServiceCredsEntry.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutServiceCredsEntry.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutServiceCredsEntry.Build())

	mPutTenancy := rdl.NewResourceBuilder("Tenancy", "PUT", "/domain/{domain}/tenancy/{service}")
	mPutTenancy.Comment("Register the provider service in the tenant's domain.")
	mPutTenancy.Input("domain", "DomainName", true, "", "", false, nil, "name of the tenant domain")
	mPutTenancy.Input("service", "ServiceName", true, "", "", false, nil, "name of the provider service")
	mPutTenancy.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutTenancy.Input("detail", "Tenancy", false, "", "", false, nil, "tenancy object")
	mPutTenancy.Auth("update", "{domain}:tenancy", false, "")
	mPutTenancy.Expected("NO_CONTENT")
	mPutTenancy.Exception("BAD_REQUEST", "ResourceError", "")
	mPutTenancy.Exception("CONFLICT", "ResourceError", "")
	mPutTenancy.Exception("FORBIDDEN", "ResourceError", "")
	mPutTenancy.Exception("NOT_FOUND", "ResourceError", "")
	mPutTenancy.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutTenancy.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutTenancy.Build())

	mDeleteTenancy := rdl.NewResourceBuilder("Tenancy", "DELETE", "/domain/{domain}/tenancy/{service}")
	mDeleteTenancy.Comment("Delete the provider service from the specified tenant domain. Upon successful completion of this delete request, the server will return NO_CONTENT status code without any data (no object will be returned).")
	mDeleteTenancy.Input("domain", "DomainName", true, "", "", false, nil, "name of the tenant domain")
	mDeleteTenancy.Input("service", "ServiceName", true, "", "", false, nil, "name of the provider service")
	mDeleteTenancy.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mDeleteTenancy.Auth("delete", "{domain}:tenancy", false, "")
	mDeleteTenancy.Expected("NO_CONTENT")
	mDeleteTenancy.Exception("BAD_REQUEST", "ResourceError", "")
	mDeleteTenancy.Exception("CONFLICT", "ResourceError", "")
	mDeleteTenancy.Exception("FORBIDDEN", "ResourceError", "")
	mDeleteTenancy.Exception("NOT_FOUND", "ResourceError", "")
	mDeleteTenancy.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeleteTenancy.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeleteTenancy.Build())

	mPutTenant := rdl.NewResourceBuilder("Tenancy", "PUT", "/domain/{domain}/service/{service}/tenant/{tenantDomain}")
	mPutTenant.Comment("Register a tenant domain for given provider service")
	mPutTenant.Name("PutTenant")
	mPutTenant.Input("domain", "DomainName", true, "", "", false, nil, "name of the provider domain")
	mPutTenant.Input("service", "SimpleName", true, "", "", false, nil, "name of the provider service")
	mPutTenant.Input("tenantDomain", "DomainName", true, "", "", false, nil, "name of the tenant domain")
	mPutTenant.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutTenant.Input("detail", "Tenancy", false, "", "", false, nil, "tenancy object")
	mPutTenant.Auth("update", "{domain}:tenant.{service}", false, "")
	mPutTenant.Expected("NO_CONTENT")
	mPutTenant.Exception("BAD_REQUEST", "ResourceError", "")
	mPutTenant.Exception("CONFLICT", "ResourceError", "")
	mPutTenant.Exception("FORBIDDEN", "ResourceError", "")
	mPutTenant.Exception("NOT_FOUND", "ResourceError", "")
	mPutTenant.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutTenant.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutTenant.Build())

	mDeleteTenant := rdl.NewResourceBuilder("Tenancy", "DELETE", "/domain/{domain}/service/{service}/tenant/{tenantDomain}")
	mDeleteTenant.Comment("Delete the tenant domain from the provider service. Upon successful completion of this delete request, the server will return NO_CONTENT status code without any data (no object will be returned).")
	mDeleteTenant.Name("DeleteTenant")
	mDeleteTenant.Input("domain", "DomainName", true, "", "", false, nil, "name of the provider domain")
	mDeleteTenant.Input("service", "SimpleName", true, "", "", false, nil, "name of the provider service")
	mDeleteTenant.Input("tenantDomain", "DomainName", true, "", "", false, nil, "name of the tenant domain")
	mDeleteTenant.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mDeleteTenant.Auth("delete", "{domain}:tenant.{service}", false, "")
	mDeleteTenant.Expected("NO_CONTENT")
	mDeleteTenant.Exception("BAD_REQUEST", "ResourceError", "")
	mDeleteTenant.Exception("CONFLICT", "ResourceError", "")
	mDeleteTenant.Exception("FORBIDDEN", "ResourceError", "")
	mDeleteTenant.Exception("NOT_FOUND", "ResourceError", "")
	mDeleteTenant.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeleteTenant.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeleteTenant.Build())

	mPutTenantResourceGroupRoles := rdl.NewResourceBuilder("TenantResourceGroupRoles", "PUT", "/domain/{domain}/service/{service}/tenant/{tenantDomain}/resourceGroup/{resourceGroup}")
	mPutTenantResourceGroupRoles.Comment("Create/update set of roles for a given tenant and resource group")
	mPutTenantResourceGroupRoles.Input("domain", "DomainName", true, "", "", false, nil, "name of the provider domain")
	mPutTenantResourceGroupRoles.Input("service", "SimpleName", true, "", "", false, nil, "name of the provider service")
	mPutTenantResourceGroupRoles.Input("tenantDomain", "DomainName", true, "", "", false, nil, "name of the tenant domain")
	mPutTenantResourceGroupRoles.Input("resourceGroup", "EntityName", true, "", "", false, nil, "tenant resource group")
	mPutTenantResourceGroupRoles.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutTenantResourceGroupRoles.Input("detail", "TenantResourceGroupRoles", false, "", "", false, nil, "list of roles to be added/updated for the tenant")
	mPutTenantResourceGroupRoles.Auth("update", "{domain}:tenant.{service}", false, "")
	mPutTenantResourceGroupRoles.Exception("BAD_REQUEST", "ResourceError", "")
	mPutTenantResourceGroupRoles.Exception("CONFLICT", "ResourceError", "")
	mPutTenantResourceGroupRoles.Exception("FORBIDDEN", "ResourceError", "")
	mPutTenantResourceGroupRoles.Exception("NOT_FOUND", "ResourceError", "")
	mPutTenantResourceGroupRoles.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutTenantResourceGroupRoles.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutTenantResourceGroupRoles.Build())

	mGetTenantResourceGroupRoles := rdl.NewResourceBuilder("TenantResourceGroupRoles", "GET", "/domain/{domain}/service/{service}/tenant/{tenantDomain}/resourceGroup/{resourceGroup}")
	mGetTenantResourceGroupRoles.Comment("Retrieve the configured set of roles for the tenant and resource group")
	mGetTenantResourceGroupRoles.Input("domain", "DomainName", true, "", "", false, nil, "name of the provider domain")
	mGetTenantResourceGroupRoles.Input("service", "SimpleName", true, "", "", false, nil, "name of the provider service")
	mGetTenantResourceGroupRoles.Input("tenantDomain", "DomainName", true, "", "", false, nil, "name of the tenant domain")
	mGetTenantResourceGroupRoles.Input("resourceGroup", "EntityName", true, "", "", false, nil, "tenant resource group")
	mGetTenantResourceGroupRoles.Auth("", "", true, "")
	mGetTenantResourceGroupRoles.Exception("BAD_REQUEST", "ResourceError", "")
	mGetTenantResourceGroupRoles.Exception("FORBIDDEN", "ResourceError", "")
	mGetTenantResourceGroupRoles.Exception("NOT_FOUND", "ResourceError", "")
	mGetTenantResourceGroupRoles.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetTenantResourceGroupRoles.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetTenantResourceGroupRoles.Build())

	mDeleteTenantResourceGroupRoles := rdl.NewResourceBuilder("TenantResourceGroupRoles", "DELETE", "/domain/{domain}/service/{service}/tenant/{tenantDomain}/resourceGroup/{resourceGroup}")
	mDeleteTenantResourceGroupRoles.Comment("Delete the configured set of roles for the tenant and resource group")
	mDeleteTenantResourceGroupRoles.Input("domain", "DomainName", true, "", "", false, nil, "name of the provider domain")
	mDeleteTenantResourceGroupRoles.Input("service", "SimpleName", true, "", "", false, nil, "name of the provider service")
	mDeleteTenantResourceGroupRoles.Input("tenantDomain", "DomainName", true, "", "", false, nil, "name of the tenant domain")
	mDeleteTenantResourceGroupRoles.Input("resourceGroup", "EntityName", true, "", "", false, nil, "tenant resource group")
	mDeleteTenantResourceGroupRoles.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mDeleteTenantResourceGroupRoles.Auth("update", "{domain}:tenant.{service}", false, "")
	mDeleteTenantResourceGroupRoles.Expected("NO_CONTENT")
	mDeleteTenantResourceGroupRoles.Exception("BAD_REQUEST", "ResourceError", "")
	mDeleteTenantResourceGroupRoles.Exception("CONFLICT", "ResourceError", "")
	mDeleteTenantResourceGroupRoles.Exception("FORBIDDEN", "ResourceError", "")
	mDeleteTenantResourceGroupRoles.Exception("NOT_FOUND", "ResourceError", "")
	mDeleteTenantResourceGroupRoles.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeleteTenantResourceGroupRoles.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeleteTenantResourceGroupRoles.Build())

	mPutProviderResourceGroupRoles := rdl.NewResourceBuilder("ProviderResourceGroupRoles", "PUT", "/domain/{tenantDomain}/provDomain/{provDomain}/provService/{provService}/resourceGroup/{resourceGroup}")
	mPutProviderResourceGroupRoles.Comment("Create/update set of roles for a given provider and resource group")
	mPutProviderResourceGroupRoles.Input("tenantDomain", "DomainName", true, "", "", false, nil, "name of the tenant domain")
	mPutProviderResourceGroupRoles.Input("provDomain", "DomainName", true, "", "", false, nil, "name of the provider domain")
	mPutProviderResourceGroupRoles.Input("provService", "SimpleName", true, "", "", false, nil, "name of the provider service")
	mPutProviderResourceGroupRoles.Input("resourceGroup", "EntityName", true, "", "", false, nil, "tenant resource group")
	mPutProviderResourceGroupRoles.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutProviderResourceGroupRoles.Input("detail", "ProviderResourceGroupRoles", false, "", "", false, nil, "list of roles to be added/updated for the provider")
	mPutProviderResourceGroupRoles.Auth("update", "{tenantDomain}:tenancy.{provDomain}.{provService}", false, "")
	mPutProviderResourceGroupRoles.Exception("BAD_REQUEST", "ResourceError", "")
	mPutProviderResourceGroupRoles.Exception("CONFLICT", "ResourceError", "")
	mPutProviderResourceGroupRoles.Exception("FORBIDDEN", "ResourceError", "")
	mPutProviderResourceGroupRoles.Exception("NOT_FOUND", "ResourceError", "")
	mPutProviderResourceGroupRoles.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutProviderResourceGroupRoles.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutProviderResourceGroupRoles.Build())

	mGetProviderResourceGroupRoles := rdl.NewResourceBuilder("ProviderResourceGroupRoles", "GET", "/domain/{tenantDomain}/provDomain/{provDomain}/provService/{provService}/resourceGroup/{resourceGroup}")
	mGetProviderResourceGroupRoles.Comment("Retrieve the configured set of roles for the provider and resource group")
	mGetProviderResourceGroupRoles.Input("tenantDomain", "DomainName", true, "", "", false, nil, "name of the tenant domain")
	mGetProviderResourceGroupRoles.Input("provDomain", "DomainName", true, "", "", false, nil, "name of the provider domain")
	mGetProviderResourceGroupRoles.Input("provService", "SimpleName", true, "", "", false, nil, "name of the provider service")
	mGetProviderResourceGroupRoles.Input("resourceGroup", "EntityName", true, "", "", false, nil, "tenant resource group")
	mGetProviderResourceGroupRoles.Auth("", "", true, "")
	mGetProviderResourceGroupRoles.Exception("BAD_REQUEST", "ResourceError", "")
	mGetProviderResourceGroupRoles.Exception("FORBIDDEN", "ResourceError", "")
	mGetProviderResourceGroupRoles.Exception("NOT_FOUND", "ResourceError", "")
	mGetProviderResourceGroupRoles.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetProviderResourceGroupRoles.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetProviderResourceGroupRoles.Build())

	mDeleteProviderResourceGroupRoles := rdl.NewResourceBuilder("ProviderResourceGroupRoles", "DELETE", "/domain/{tenantDomain}/provDomain/{provDomain}/provService/{provService}/resourceGroup/{resourceGroup}")
	mDeleteProviderResourceGroupRoles.Comment("Delete the configured set of roles for the provider and resource group")
	mDeleteProviderResourceGroupRoles.Input("tenantDomain", "DomainName", true, "", "", false, nil, "name of the tenant domain")
	mDeleteProviderResourceGroupRoles.Input("provDomain", "DomainName", true, "", "", false, nil, "name of the provider domain")
	mDeleteProviderResourceGroupRoles.Input("provService", "SimpleName", true, "", "", false, nil, "name of the provider service")
	mDeleteProviderResourceGroupRoles.Input("resourceGroup", "EntityName", true, "", "", false, nil, "tenant resource group")
	mDeleteProviderResourceGroupRoles.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mDeleteProviderResourceGroupRoles.Auth("update", "{tenantDomain}:tenancy.{provDomain}.{provService}", false, "")
	mDeleteProviderResourceGroupRoles.Expected("NO_CONTENT")
	mDeleteProviderResourceGroupRoles.Exception("BAD_REQUEST", "ResourceError", "")
	mDeleteProviderResourceGroupRoles.Exception("CONFLICT", "ResourceError", "")
	mDeleteProviderResourceGroupRoles.Exception("FORBIDDEN", "ResourceError", "")
	mDeleteProviderResourceGroupRoles.Exception("NOT_FOUND", "ResourceError", "")
	mDeleteProviderResourceGroupRoles.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeleteProviderResourceGroupRoles.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeleteProviderResourceGroupRoles.Build())

	mGetAccess := rdl.NewResourceBuilder("Access", "GET", "/access/{action}/{resource}")
	mGetAccess.Comment("Check access for the specified operation on the specified resource for the currently authenticated user. This is the slow centralized access for control-plane purposes. Use distributed mechanisms for decentralized (data-plane) access by fetching signed policies and role tokens for users. With this endpoint the resource is part of the uri and restricted to its strict definition of resource name. If needed, you can use the GetAccessExt api that allows resource name to be less restrictive.")
	mGetAccess.Input("action", "ActionName", true, "", "", false, nil, "action as specified in the policy assertion, i.e. update or read")
	mGetAccess.Input("resource", "ResourceName", true, "", "", false, nil, "the resource to check access against, i.e. \"media.news:articles\"")
	mGetAccess.Input("domain", "DomainName", false, "domain", "", true, nil, "usually null. If present, it specifies an alternate domain for cross-domain trust relation")
	mGetAccess.Input("checkPrincipal", "EntityName", false, "principal", "", true, nil, "usually null. If present, carry out the access check for this principal")
	mGetAccess.Auth("", "", true, "")
	mGetAccess.Exception("BAD_REQUEST", "ResourceError", "")
	mGetAccess.Exception("FORBIDDEN", "ResourceError", "")
	mGetAccess.Exception("NOT_FOUND", "ResourceError", "")
	mGetAccess.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetAccess.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetAccess.Build())

	mGetAccessExt := rdl.NewResourceBuilder("Access", "GET", "/access/{action}")
	mGetAccessExt.Comment("Check access for the specified operation on the specified resource for the currently authenticated user. This is the slow centralized access for control-plane purposes.")
	mGetAccessExt.Name("GetAccessExt")
	mGetAccessExt.Input("action", "ActionName", true, "", "", false, nil, "action as specified in the policy assertion, i.e. update or read")
	mGetAccessExt.Input("resource", "String", false, "resource", "", false, nil, "the resource to check access against, i.e. \"media.news:articles\"")
	mGetAccessExt.Input("domain", "DomainName", false, "domain", "", true, nil, "usually null. If present, it specifies an alternate domain for cross-domain trust relation")
	mGetAccessExt.Input("checkPrincipal", "EntityName", false, "principal", "", true, nil, "usually null. If present, carry out the access check for this principal")
	mGetAccessExt.Auth("", "", true, "")
	mGetAccessExt.Exception("BAD_REQUEST", "ResourceError", "")
	mGetAccessExt.Exception("FORBIDDEN", "ResourceError", "")
	mGetAccessExt.Exception("NOT_FOUND", "ResourceError", "")
	mGetAccessExt.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetAccessExt.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetAccessExt.Build())

	mGetResourceAccessList := rdl.NewResourceBuilder("ResourceAccessList", "GET", "/resource")
	mGetResourceAccessList.Comment("Return list of resources that the given principal has access to. Even though the principal is marked as optional, it must be specified")
	mGetResourceAccessList.Input("principal", "ResourceName", false, "principal", "", true, nil, "specifies principal to query the resource list for")
	mGetResourceAccessList.Input("action", "ActionName", false, "action", "", true, nil, "action as specified in the policy assertion")
	mGetResourceAccessList.Input("filter", "String", false, "filter", "", true, nil, "resource filter for specific subset of resources")
	mGetResourceAccessList.Auth("", "", true, "")
	mGetResourceAccessList.Exception("BAD_REQUEST", "ResourceError", "")
	mGetResourceAccessList.Exception("FORBIDDEN", "ResourceError", "")
	mGetResourceAccessList.Exception("NOT_FOUND", "ResourceError", "")
	mGetResourceAccessList.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetResourceAccessList.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetResourceAccessList.Build())

	mGetSignedDomains := rdl.NewResourceBuilder("SignedDomains", "GET", "/sys/modified_domains")
	mGetSignedDomains.Comment("Retrieve the list of modified domains since the specified timestamp. The server will return the list of all modified domains and the latest modification timestamp as the value of the ETag header. The client will need to use this value during its next call to request the changes since the previous request. When metaonly set to true, don't add roles, policies or services, don't sign")
	mGetSignedDomains.Input("domain", "DomainName", false, "domain", "", true, nil, "filter the domain list only to the specified name")
	mGetSignedDomains.Input("metaOnly", "String", false, "metaonly", "", true, nil, "valid values are \"true\" or \"false\"")
	mGetSignedDomains.Input("metaAttr", "SimpleName", false, "metaattr", "", true, nil, "domain meta attribute to filter/return, valid values \"account\", \"ypmId\", or \"all\"")
	mGetSignedDomains.Input("master", "Bool", false, "master", "", true, nil, "for system principals only - request data from master data store and not read replicas if any are configured")
	mGetSignedDomains.Input("conditions", "Bool", false, "conditions", "", true, nil, "for specific purpose only. If this flag is passed, assertion id and assertion conditions will be included in the response assertions if available")
	mGetSignedDomains.Input("matchingTag", "String", false, "", "If-None-Match", false, nil, "Retrieved from the previous request, this timestamp specifies to the server to return any domains modified since this time")
	mGetSignedDomains.Output("tag", "String", "ETag", false, "The current latest modification timestamp is returned in this header")
	mGetSignedDomains.Auth("", "", true, "")
	mGetSignedDomains.Exception("BAD_REQUEST", "ResourceError", "")
	mGetSignedDomains.Exception("FORBIDDEN", "ResourceError", "")
	mGetSignedDomains.Exception("NOT_FOUND", "ResourceError", "")
	mGetSignedDomains.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetSignedDomains.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetSignedDomains.Build())

	mGetJWSDomain := rdl.NewResourceBuilder("JWSDomain", "GET", "/domain/{name}/signed")
	mGetJWSDomain.Input("name", "DomainName", true, "", "", false, nil, "name of the domain to be retrieved")
	mGetJWSDomain.Input("signatureP1363Format", "Bool", false, "signaturep1363format", "", true, nil, "true if signature must be in P1363 format instead of ASN.1 DER")
	mGetJWSDomain.Input("matchingTag", "String", false, "", "If-None-Match", false, nil, "Retrieved from the previous request, this timestamp specifies to the server to return if the domain was modified since this time")
	mGetJWSDomain.Output("tag", "String", "ETag", false, "The current latest modification timestamp is returned in this header")
	mGetJWSDomain.Auth("", "", true, "")
	mGetJWSDomain.Exception("BAD_REQUEST", "ResourceError", "")
	mGetJWSDomain.Exception("NOT_FOUND", "ResourceError", "")
	mGetJWSDomain.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetJWSDomain.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetJWSDomain.Build())

	mGetUserToken := rdl.NewResourceBuilder("UserToken", "GET", "/user/{userName}/token")
	mGetUserToken.Comment("Return a user/principal token for the specified authenticated user. Typical authenticated users with their native credentials are not allowed to update their domain data. They must first obtain a UserToken and then use that token for authentication and authorization of their update requests.")
	mGetUserToken.Input("userName", "SimpleName", true, "", "", false, nil, "name of the user")
	mGetUserToken.Input("serviceNames", "String", false, "services", "", true, nil, "comma separated list of on-behalf-of service names")
	mGetUserToken.Input("header", "Bool", false, "header", "", true, false, "include Authorization header name in response")
	mGetUserToken.Auth("", "", true, "")
	mGetUserToken.Exception("FORBIDDEN", "ResourceError", "")
	mGetUserToken.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetUserToken.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetUserToken.Build())

	mOptionsUserToken := rdl.NewResourceBuilder("UserToken", "OPTIONS", "/user/{userName}/token")
	mOptionsUserToken.Comment("CORS (Cross-Origin Resource Sharing) support to allow Provider Services to obtain AuthorizedService Tokens on behalf of Tenant administrators")
	mOptionsUserToken.Input("userName", "SimpleName", true, "", "", false, nil, "name of the user")
	mOptionsUserToken.Input("serviceNames", "String", false, "services", "", true, nil, "comma separated list of on-behalf-of service names")
	mOptionsUserToken.Exception("BAD_REQUEST", "ResourceError", "")
	mOptionsUserToken.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mOptionsUserToken.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mOptionsUserToken.Build())

	mGetServicePrincipal := rdl.NewResourceBuilder("ServicePrincipal", "GET", "/principal")
	mGetServicePrincipal.Comment("Return a ServicePrincipal object if the serviceToken is valid. This request provides a simple operation that an external application can execute to validate a service token.")
	mGetServicePrincipal.Auth("", "", true, "")
	mGetServicePrincipal.Exception("BAD_REQUEST", "ResourceError", "")
	mGetServicePrincipal.Exception("FORBIDDEN", "ResourceError", "")
	mGetServicePrincipal.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetServicePrincipal.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetServicePrincipal.Build())

	mGetServerTemplateList := rdl.NewResourceBuilder("ServerTemplateList", "GET", "/template")
	mGetServerTemplateList.Comment("Get the list of solution templates defined in the server")
	mGetServerTemplateList.Auth("", "", true, "")
	mGetServerTemplateList.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetServerTemplateList.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetServerTemplateList.Build())

	mGetTemplate := rdl.NewResourceBuilder("Template", "GET", "/template/{template}")
	mGetTemplate.Comment("Get solution template details. Includes the roles and policies that will be automatically provisioned when the template is applied to a domain")
	mGetTemplate.Input("template", "SimpleName", true, "", "", false, nil, "name of the solution template")
	mGetTemplate.Auth("", "", true, "")
	mGetTemplate.Exception("BAD_REQUEST", "ResourceError", "")
	mGetTemplate.Exception("NOT_FOUND", "ResourceError", "")
	mGetTemplate.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetTemplate.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetTemplate.Build())

	mGetDomainTemplateDetailsList := rdl.NewResourceBuilder("DomainTemplateDetailsList", "GET", "/domain/{name}/templatedetails")
	mGetDomainTemplateDetailsList.Comment("Get a list of Solution templates with meta data details given a domain name")
	mGetDomainTemplateDetailsList.Input("name", "DomainName", true, "", "", false, nil, "List of templates given a domain name")
	mGetDomainTemplateDetailsList.Auth("", "", true, "")
	mGetDomainTemplateDetailsList.Exception("BAD_REQUEST", "ResourceError", "")
	mGetDomainTemplateDetailsList.Exception("NOT_FOUND", "ResourceError", "")
	mGetDomainTemplateDetailsList.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetDomainTemplateDetailsList.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetDomainTemplateDetailsList.Build())

	mGetServerTemplateDetailsList := rdl.NewResourceBuilder("DomainTemplateDetailsList", "GET", "/templatedetails")
	mGetServerTemplateDetailsList.Comment("Get a list of Solution templates with meta data details defined in the server")
	mGetServerTemplateDetailsList.Name("GetServerTemplateDetailsList")
	mGetServerTemplateDetailsList.Auth("", "", true, "")
	mGetServerTemplateDetailsList.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetServerTemplateDetailsList.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetServerTemplateDetailsList.Build())

	mGetUserList := rdl.NewResourceBuilder("UserList", "GET", "/user")
	mGetUserList.Comment("Enumerate users that are registered as principals in the system This will return only the principals with \"<user-domain>.\" prefix")
	mGetUserList.Input("domainName", "DomainName", false, "domain", "", true, nil, "name of the allowed user-domains and/or aliases")
	mGetUserList.Auth("", "", true, "")
	mGetUserList.Exception("BAD_REQUEST", "ResourceError", "")
	mGetUserList.Exception("NOT_FOUND", "ResourceError", "")
	mGetUserList.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetUserList.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetUserList.Build())

	mDeleteUser := rdl.NewResourceBuilder("User", "DELETE", "/user/{name}")
	mDeleteUser.Comment("Delete the specified user. This command will delete the home.<name> domain and all of its sub-domains (if they exist) and remove the user.<name> from all the roles in the system that it's member of. Upon successful completion of this delete request, the server will return NO_CONTENT status code without any data (no object will be returned).")
	mDeleteUser.Input("name", "SimpleName", true, "", "", false, nil, "name of the user")
	mDeleteUser.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit reference")
	mDeleteUser.Auth("delete", "sys.auth:user", false, "")
	mDeleteUser.Expected("NO_CONTENT")
	mDeleteUser.Exception("BAD_REQUEST", "ResourceError", "")
	mDeleteUser.Exception("CONFLICT", "ResourceError", "")
	mDeleteUser.Exception("FORBIDDEN", "ResourceError", "")
	mDeleteUser.Exception("NOT_FOUND", "ResourceError", "")
	mDeleteUser.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeleteUser.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeleteUser.Build())

	mDeleteDomainRoleMember := rdl.NewResourceBuilder("DomainRoleMember", "DELETE", "/domain/{domainName}/member/{memberName}")
	mDeleteDomainRoleMember.Comment("Delete the specified role member from the given domain. This command will remove the member from all the roles in the domain that it's member of. Upon successful completion of this delete request, the server will return NO_CONTENT status code without any data (no object will be returned).")
	mDeleteDomainRoleMember.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mDeleteDomainRoleMember.Input("memberName", "MemberName", true, "", "", false, nil, "name of the role member/principal")
	mDeleteDomainRoleMember.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit reference")
	mDeleteDomainRoleMember.Auth("update", "{domainName}:", false, "")
	mDeleteDomainRoleMember.Expected("NO_CONTENT")
	mDeleteDomainRoleMember.Exception("BAD_REQUEST", "ResourceError", "")
	mDeleteDomainRoleMember.Exception("CONFLICT", "ResourceError", "")
	mDeleteDomainRoleMember.Exception("FORBIDDEN", "ResourceError", "")
	mDeleteDomainRoleMember.Exception("NOT_FOUND", "ResourceError", "")
	mDeleteDomainRoleMember.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeleteDomainRoleMember.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeleteDomainRoleMember.Build())

	mGetQuota := rdl.NewResourceBuilder("Quota", "GET", "/domain/{name}/quota")
	mGetQuota.Comment("Retrieve the quota object defined for the domain")
	mGetQuota.Input("name", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetQuota.Auth("", "", true, "")
	mGetQuota.Exception("BAD_REQUEST", "ResourceError", "")
	mGetQuota.Exception("NOT_FOUND", "ResourceError", "")
	mGetQuota.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetQuota.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetQuota.Build())

	mPutQuota := rdl.NewResourceBuilder("Quota", "PUT", "/domain/{name}/quota")
	mPutQuota.Comment("Update the specified domain's quota object")
	mPutQuota.Input("name", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutQuota.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit reference")
	mPutQuota.Input("quota", "Quota", false, "", "", false, nil, "Quota object with limits for the domain")
	mPutQuota.Auth("update", "sys.auth:quota", false, "")
	mPutQuota.Expected("NO_CONTENT")
	mPutQuota.Exception("BAD_REQUEST", "ResourceError", "")
	mPutQuota.Exception("CONFLICT", "ResourceError", "")
	mPutQuota.Exception("FORBIDDEN", "ResourceError", "")
	mPutQuota.Exception("NOT_FOUND", "ResourceError", "")
	mPutQuota.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutQuota.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutQuota.Build())

	mDeleteQuota := rdl.NewResourceBuilder("Quota", "DELETE", "/domain/{name}/quota")
	mDeleteQuota.Comment("Delete the specified domain's quota")
	mDeleteQuota.Input("name", "DomainName", true, "", "", false, nil, "name of the domain")
	mDeleteQuota.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit reference")
	mDeleteQuota.Auth("update", "sys.auth:quota", false, "")
	mDeleteQuota.Expected("NO_CONTENT")
	mDeleteQuota.Exception("BAD_REQUEST", "ResourceError", "")
	mDeleteQuota.Exception("CONFLICT", "ResourceError", "")
	mDeleteQuota.Exception("FORBIDDEN", "ResourceError", "")
	mDeleteQuota.Exception("NOT_FOUND", "ResourceError", "")
	mDeleteQuota.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeleteQuota.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeleteQuota.Build())

	mGetStatus := rdl.NewResourceBuilder("Status", "GET", "/status")
	mGetStatus.Comment("Retrieve the server status")
	mGetStatus.Auth("", "", true, "")
	mGetStatus.Exception("BAD_REQUEST", "ResourceError", "")
	mGetStatus.Exception("NOT_FOUND", "ResourceError", "")
	mGetStatus.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetStatus.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetStatus.Build())

	mGetPendingDomainRoleMembersList := rdl.NewResourceBuilder("DomainRoleMembership", "GET", "/pending_members")
	mGetPendingDomainRoleMembersList.Comment("List of domains containing roles and corresponding members to be approved by either calling or specified principal")
	mGetPendingDomainRoleMembersList.Name("getPendingDomainRoleMembersList")
	mGetPendingDomainRoleMembersList.Input("principal", "EntityName", false, "principal", "", true, nil, "If present, return pending list for this principal")
	mGetPendingDomainRoleMembersList.Input("domainName", "String", false, "domain", "", true, nil, "If present, return pending list for this domain")
	mGetPendingDomainRoleMembersList.Auth("", "", true, "")
	mGetPendingDomainRoleMembersList.Exception("BAD_REQUEST", "ResourceError", "")
	mGetPendingDomainRoleMembersList.Exception("FORBIDDEN", "ResourceError", "")
	mGetPendingDomainRoleMembersList.Exception("NOT_FOUND", "ResourceError", "")
	mGetPendingDomainRoleMembersList.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetPendingDomainRoleMembersList.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetPendingDomainRoleMembersList.Build())

	mGetUserAuthorityAttributeMap := rdl.NewResourceBuilder("UserAuthorityAttributeMap", "GET", "/authority/user/attribute")
	mGetUserAuthorityAttributeMap.Comment("Map of type to attribute values for the user authority")
	mGetUserAuthorityAttributeMap.Auth("", "", true, "")
	mGetUserAuthorityAttributeMap.Exception("BAD_REQUEST", "ResourceError", "")
	mGetUserAuthorityAttributeMap.Exception("NOT_FOUND", "ResourceError", "")
	mGetUserAuthorityAttributeMap.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetUserAuthorityAttributeMap.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetUserAuthorityAttributeMap.Build())

	mGetStats := rdl.NewResourceBuilder("Stats", "GET", "/domain/{name}/stats")
	mGetStats.Comment("Retrieve the stats object defined for the domain")
	mGetStats.Input("name", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetStats.Auth("", "", true, "")
	mGetStats.Exception("BAD_REQUEST", "ResourceError", "")
	mGetStats.Exception("NOT_FOUND", "ResourceError", "")
	mGetStats.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetStats.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetStats.Build())

	mGetSystemStats := rdl.NewResourceBuilder("Stats", "GET", "/sys/stats")
	mGetSystemStats.Comment("Retrieve the stats object defined for the system")
	mGetSystemStats.Name("getSystemStats")
	mGetSystemStats.Auth("get", "sys.auth:stats", false, "")
	mGetSystemStats.Exception("BAD_REQUEST", "ResourceError", "")
	mGetSystemStats.Exception("FORBIDDEN", "ResourceError", "")
	mGetSystemStats.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetSystemStats.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetSystemStats.Build())

	mPutDomainDependency := rdl.NewResourceBuilder("DependentService", "PUT", "/dependency/domain/{domainName}")
	mPutDomainDependency.Comment("Register domain as a dependency to service There are two possible authorization checks for this endpoint: 1) System Administrator 2) Authorized Service Provider")
	mPutDomainDependency.Name("putDomainDependency")
	mPutDomainDependency.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mPutDomainDependency.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutDomainDependency.Input("service", "DependentService", false, "", "", false, nil, "Dependent service provider details")
	mPutDomainDependency.Auth("", "", true, "")
	mPutDomainDependency.Expected("NO_CONTENT")
	mPutDomainDependency.Exception("BAD_REQUEST", "ResourceError", "")
	mPutDomainDependency.Exception("CONFLICT", "ResourceError", "")
	mPutDomainDependency.Exception("FORBIDDEN", "ResourceError", "")
	mPutDomainDependency.Exception("NOT_FOUND", "ResourceError", "")
	mPutDomainDependency.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutDomainDependency.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutDomainDependency.Build())

	mDeleteDomainDependency := rdl.NewResourceBuilder("ServiceName", "DELETE", "/dependency/domain/{domainName}/service/{service}")
	mDeleteDomainDependency.Comment("De-register domain as a dependency to service There are two possible authorization checks for this endpoint: 1) System Administrator 2) Authorized Service Provider")
	mDeleteDomainDependency.Name("deleteDomainDependency")
	mDeleteDomainDependency.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mDeleteDomainDependency.Input("service", "ServiceName", true, "", "", false, nil, "name of the service")
	mDeleteDomainDependency.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mDeleteDomainDependency.Auth("", "", true, "")
	mDeleteDomainDependency.Expected("NO_CONTENT")
	mDeleteDomainDependency.Exception("BAD_REQUEST", "ResourceError", "")
	mDeleteDomainDependency.Exception("CONFLICT", "ResourceError", "")
	mDeleteDomainDependency.Exception("FORBIDDEN", "ResourceError", "")
	mDeleteDomainDependency.Exception("NOT_FOUND", "ResourceError", "")
	mDeleteDomainDependency.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mDeleteDomainDependency.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mDeleteDomainDependency.Build())

	mGetDependentServiceList := rdl.NewResourceBuilder("ServiceIdentityList", "GET", "/dependency/domain/{domainName}")
	mGetDependentServiceList.Comment("List registered services for domain")
	mGetDependentServiceList.Name("getDependentServiceList")
	mGetDependentServiceList.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetDependentServiceList.Auth("", "", true, "")
	mGetDependentServiceList.Exception("BAD_REQUEST", "ResourceError", "")
	mGetDependentServiceList.Exception("NOT_FOUND", "ResourceError", "")
	mGetDependentServiceList.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetDependentServiceList.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetDependentServiceList.Build())

	mGetDependentServiceResourceGroupList := rdl.NewResourceBuilder("DependentServiceResourceGroupList", "GET", "/dependency/domain/{domainName}/resourceGroup")
	mGetDependentServiceResourceGroupList.Comment("List registered services and resource groups for domain")
	mGetDependentServiceResourceGroupList.Name("getDependentServiceResourceGroupList")
	mGetDependentServiceResourceGroupList.Input("domainName", "DomainName", true, "", "", false, nil, "name of the domain")
	mGetDependentServiceResourceGroupList.Auth("", "", true, "")
	mGetDependentServiceResourceGroupList.Exception("BAD_REQUEST", "ResourceError", "")
	mGetDependentServiceResourceGroupList.Exception("NOT_FOUND", "ResourceError", "")
	mGetDependentServiceResourceGroupList.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetDependentServiceResourceGroupList.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetDependentServiceResourceGroupList.Build())

	mGetDependentDomainList := rdl.NewResourceBuilder("DomainList", "GET", "/dependency/service/{service}")
	mGetDependentDomainList.Comment("List dependent domains for service")
	mGetDependentDomainList.Name("getDependentDomainList")
	mGetDependentDomainList.Input("service", "ServiceName", true, "", "", false, nil, "name of the service")
	mGetDependentDomainList.Auth("", "", true, "")
	mGetDependentDomainList.Exception("BAD_REQUEST", "ResourceError", "")
	mGetDependentDomainList.Exception("NOT_FOUND", "ResourceError", "")
	mGetDependentDomainList.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetDependentDomainList.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetDependentDomainList.Build())

	mGetRolesForReview := rdl.NewResourceBuilder("ReviewObjects", "GET", "/review/role")
	mGetRolesForReview.Comment("Fetch all the roles across domains for either the caller or specified principal that require a review based on the last reviewed date and configured attributes. The method requires the caller to be either the principal or authorized in system to carry out the operation for any principal (typically this would be system administrators) 1. authenticated principal is the same as the check principal 2. system authorized (\"access\", \"sys.auth:meta.review.lookup\")")
	mGetRolesForReview.Name("GetRolesForReview")
	mGetRolesForReview.Input("principal", "ResourceName", false, "principal", "", true, nil, "If not present, will return roles for the user making the call")
	mGetRolesForReview.Auth("", "", true, "")
	mGetRolesForReview.Exception("BAD_REQUEST", "ResourceError", "")
	mGetRolesForReview.Exception("FORBIDDEN", "ResourceError", "")
	mGetRolesForReview.Exception("NOT_FOUND", "ResourceError", "")
	mGetRolesForReview.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetRolesForReview.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetRolesForReview.Build())

	mGetGroupsForReview := rdl.NewResourceBuilder("ReviewObjects", "GET", "/review/group")
	mGetGroupsForReview.Comment("Fetch all the groups across domains for either the caller or specified principal that require a review based on the last reviewed date and configured attributes. The method requires the caller to be either the principal or authorized in system to carry out the operation for any principal (typically this would be system administrators) 1. authenticated principal is the same as the check principal 2. system authorized (\"access\", \"sys.auth:meta.review.lookup\")")
	mGetGroupsForReview.Name("GetGroupsForReview")
	mGetGroupsForReview.Input("principal", "ResourceName", false, "principal", "", true, nil, "If not present, will return groups for the user making the call")
	mGetGroupsForReview.Auth("", "", true, "")
	mGetGroupsForReview.Exception("BAD_REQUEST", "ResourceError", "")
	mGetGroupsForReview.Exception("FORBIDDEN", "ResourceError", "")
	mGetGroupsForReview.Exception("NOT_FOUND", "ResourceError", "")
	mGetGroupsForReview.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetGroupsForReview.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetGroupsForReview.Build())

	mGetInfo := rdl.NewResourceBuilder("Info", "GET", "/sys/info")
	mGetInfo.Comment("Retrieve the server info. Since we're exposing server version details, the request will require authorization")
	mGetInfo.Auth("get", "sys.auth:info", false, "")
	mGetInfo.Exception("BAD_REQUEST", "ResourceError", "")
	mGetInfo.Exception("FORBIDDEN", "ResourceError", "")
	mGetInfo.Exception("NOT_FOUND", "ResourceError", "")
	mGetInfo.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mGetInfo.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mGetInfo.Build())

	mPutPrincipalState := rdl.NewResourceBuilder("PrincipalState", "PUT", "/principal/{principalName}/state")
	mPutPrincipalState.Comment("Update the state of the principal - currently only the suspended state is supported Suspension can be enforced through the User Authority or by Athenz administrators. The suspended state is used to disable a principal from accessing the Athenz services The required authorization includes the following two options: 1. (\"update\", \"{domainName}:service.{serviceName}\") for the domain administrators where the domainName and serviceName are extracted from the principalName 2. (\"update\", \"sys.auth:state.{principalName}\") for the Athenz administrators")
	mPutPrincipalState.Input("principalName", "MemberName", true, "", "", false, nil, "name of the principal")
	mPutPrincipalState.Input("auditRef", "String", false, "", "Y-Audit-Ref", false, nil, "Audit param required(not empty) if domain auditEnabled is true.")
	mPutPrincipalState.Input("principalState", "PrincipalState", false, "", "", false, nil, "Principal state indicating if the principal is suspended or not")
	mPutPrincipalState.Auth("", "", true, "")
	mPutPrincipalState.Expected("NO_CONTENT")
	mPutPrincipalState.Exception("BAD_REQUEST", "ResourceError", "")
	mPutPrincipalState.Exception("CONFLICT", "ResourceError", "")
	mPutPrincipalState.Exception("FORBIDDEN", "ResourceError", "")
	mPutPrincipalState.Exception("NOT_FOUND", "ResourceError", "")
	mPutPrincipalState.Exception("TOO_MANY_REQUESTS", "ResourceError", "")
	mPutPrincipalState.Exception("UNAUTHORIZED", "ResourceError", "")
	sb.AddResource(mPutPrincipalState.Build())

	mGetRdlSchema := rdl.NewResourceBuilder("rdl.Schema", "GET", "/schema")
	mGetRdlSchema.Comment("Get RDL Schema")
	mGetRdlSchema.Auth("", "", true, "")
	sb.AddResource(mGetRdlSchema.Build())

	var err error
	schema, err = sb.BuildParanoid()
	if err != nil {
		log.Fatalf("rdl: schema build failed: %s", err)
	}
}

func ZMSSchema() *rdl.Schema {
	return schema
}
