package com.l7tech.gateway.api;

import com.l7tech.gateway.api.impl.AccessorSupport;
import com.l7tech.gateway.api.impl.AttributeExtensibleReferenceList;
import com.l7tech.gateway.api.impl.AttributeExtensibleType;
import com.l7tech.gateway.api.impl.ElementExtensionSupport;
import com.l7tech.gateway.api.impl.ManagedObjectReference;
import com.l7tech.gateway.api.impl.PropertiesMapType;
import com.l7tech.util.CollectionUtils;
import com.l7tech.util.Functions;
import com.l7tech.util.Functions.Nullary;
import jakarta.xml.bind.annotation.XmlAnyElement;
import jakarta.xml.bind.annotation.XmlElement;
import jakarta.xml.bind.annotation.XmlElements;
import jakarta.xml.bind.annotation.XmlEnum;
import jakarta.xml.bind.annotation.XmlEnumValue;
import jakarta.xml.bind.annotation.XmlRootElement;
import jakarta.xml.bind.annotation.XmlSeeAlso;
import jakarta.xml.bind.annotation.XmlType;
import jakarta.xml.bind.annotation.XmlValue;
import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import javax.xml.namespace.QName;

@XmlRootElement(name = "IdentityProvider")
@XmlType(name = "IdentityProviderType", propOrder = {"nameValue", "identityProviderTypeValue", "properties", "identityProviderExtension", "extensions"})
@AccessorSupport.AccessibleResource(name = "identityProviders")
public class IdentityProviderMO extends SecurityZoneableObject {
   private AttributeExtensibleType.AttributeExtensibleString h;
   private IdentityProviderMO.AttributeExtensibleIdentityProviderType i;
   private Map<String, Object> j;
   private IdentityProviderMO.IdentityProviderExtension k;

   IdentityProviderMO() {
   }

   public String getName() {
      return AttributeExtensibleType.get(this.h);
   }

   public void setName(String var1) {
      this.h = AttributeExtensibleType.set(this.h, var1);
   }

   public IdentityProviderMO.IdentityProviderType getIdentityProviderType() {
      return AttributeExtensibleType.get(this.i);
   }

   public void setIdentityProviderType(IdentityProviderMO.IdentityProviderType var1) {
      IdentityProviderMO var10000;
      IdentityProviderMO.AttributeExtensibleIdentityProviderType var10001;
      label16: {
         try {
            var10000 = this;
            if (this.i == null) {
               var10001 = new IdentityProviderMO.AttributeExtensibleIdentityProviderType();
               break label16;
            }
         } catch (ManagementRuntimeException var2) {
            throw var2;
         }

         var10001 = this.i;
      }

      var10000.i = AttributeExtensibleType.setNonNull(var10001, var1);
   }

   @XmlElement(name = "Properties")
   @XmlJavaTypeAdapter(PropertiesMapType.PropertiesMapTypeAdapter.class)
   public Map<String, Object> getProperties() {
      return this.j;
   }

   public void setProperties(Map<String, Object> var1) {
      this.j = var1;
   }

   public IdentityProviderMO.LdapIdentityProviderDetail getLdapIdentityProviderDetail() {
      return this.a(IdentityProviderMO.LdapIdentityProviderDetail.class);
   }

   public IdentityProviderMO.BindOnlyLdapIdentityProviderDetail getBindOnlyLdapIdentityProviderDetail() {
      return this.a(IdentityProviderMO.BindOnlyLdapIdentityProviderDetail.class);
   }

   public IdentityProviderMO.FederatedIdentityProviderDetail getFederatedIdentityProviderDetail() {
      return this.a(IdentityProviderMO.FederatedIdentityProviderDetail.class);
   }

   public IdentityProviderMO.PolicyBackedIdentityProviderDetail getPolicyBackedIdentityProviderDetail() {
      return this.a(IdentityProviderMO.PolicyBackedIdentityProviderDetail.class);
   }

   @XmlElement(name = "Name", required = true)
   protected AttributeExtensibleType.AttributeExtensibleString getNameValue() {
      return this.h;
   }

   protected void setNameValue(AttributeExtensibleType.AttributeExtensibleString var1) {
      this.h = var1;
   }

   @XmlElement(name = "IdentityProviderType", required = true)
   protected IdentityProviderMO.AttributeExtensibleIdentityProviderType getIdentityProviderTypeValue() {
      return this.i;
   }

   protected void setIdentityProviderTypeValue(IdentityProviderMO.AttributeExtensibleIdentityProviderType var1) {
      this.i = var1;
   }

   @XmlElement(name = "Extension")
   protected IdentityProviderMO.IdentityProviderExtension getIdentityProviderExtension() {
      return this.k;
   }

   protected void setIdentityProviderExtension(IdentityProviderMO.IdentityProviderExtension var1) {
      this.k = var1;
   }

   @XmlAnyElement(lax = true)
   @Override
   protected List<Object> getExtensions() {
      return super.getExtensions();
   }

   private <DT extends IdentityProviderMO.IdentityProviderDetail> DT a(Class<DT> var1) {
      IdentityProviderMO.IdentityProviderDetail var2 = null;

      try {
         if (this.k != null && var1.isInstance(this.k.getIdentityProviderDetail())) {
            return (DT)this.k.getIdentityProviderDetail();
         }
      } catch (InstantiationException var5) {
         throw var5;
      }

      if (this.k == null) {
         this.k = new IdentityProviderMO.IdentityProviderExtension();

         try {
            var2 = (IdentityProviderMO.IdentityProviderDetail)var1.getDeclaredConstructor().newInstance();
         } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException var4) {
            throw new ManagementRuntimeException(var4);
         }

         this.k.setIdentityProviderDetail(var2);
      }

      return (DT)var2;
   }

   @XmlType(name = "IdentityProviderTypePropertyType")
   protected static class AttributeExtensibleIdentityProviderType extends AttributeExtensibleType.AttributeExtensible<IdentityProviderMO.IdentityProviderType> {
      private IdentityProviderMO.IdentityProviderType b;

      @XmlValue
      public IdentityProviderMO.IdentityProviderType getValue() {
         return this.b;
      }

      public void setValue(IdentityProviderMO.IdentityProviderType var1) {
         this.b = var1;
      }
   }

   @XmlType(name = "LdapIdentityProviderMappingListPropertyType", propOrder = "value")
   protected static class AttributeExtensibleLdapIdentityProviderMappingList
      extends AttributeExtensibleType.AttributeExtensible<List<IdentityProviderMO.LdapIdentityProviderMapping>> {
      private static final Nullary<IdentityProviderMO.AttributeExtensibleLdapIdentityProviderMappingList> b = new g();
      private List<IdentityProviderMO.LdapIdentityProviderMapping> c;

      @XmlElement(name = "Mapping")
      public List<IdentityProviderMO.LdapIdentityProviderMapping> getValue() {
         return this.c;
      }

      public void setValue(List<IdentityProviderMO.LdapIdentityProviderMapping> var1) {
         this.c = var1;
      }
   }

   @XmlType(
      name = "BindOnlyLdapIdentityProviderDetailType",
      propOrder = {"serverUrlValues", "useSslClientAuthenticationValue", "sslKeyReferenceValue", "bindPatternPrefixValue", "bindPatternSuffixValue"}
   )
   public static class BindOnlyLdapIdentityProviderDetail extends IdentityProviderMO.IdentityProviderDetail {
      private AttributeExtensibleType.AttributeExtensibleStringList d;
      private AttributeExtensibleType.AttributeExtensibleBoolean e;
      private ManagedObjectReference f;
      private AttributeExtensibleType.AttributeExtensibleString g;
      private AttributeExtensibleType.AttributeExtensibleString h;

      protected BindOnlyLdapIdentityProviderDetail() {
      }

      public List<String> getServerUrls() {
         return AttributeExtensibleType.unwrap(AttributeExtensibleType.get(this.d, new ArrayList()));
      }

      public void setServerUrls(List<String> var1) {
         this.d = AttributeExtensibleType.set(this.d, AttributeExtensibleType.wrap(var1, AttributeExtensibleType.AttributeExtensibleStringBuilder));
      }

      public boolean isUseSslClientClientAuthentication() {
         return AttributeExtensibleType.get(this.e, Boolean.FALSE);
      }

      public void setUseSslClientAuthentication(boolean var1) {
         this.e = AttributeExtensibleType.set(this.e, var1);
      }

      public String getSslKeyId() {
         return this.f == null ? null : this.f.getId();
      }

      public void setSslKeyId(String var1) {
         if (var1 != null) {
            if (this.f == null) {
               this.f = new ManagedObjectReference();
            }

            this.f.setId(var1);
            this.f.setResourceType(PrivateKeyMO.class);
         } else {
            this.f = null;
         }
      }

      public String getBindPatternPrefix() {
         return AttributeExtensibleType.get(this.g);
      }

      public void setBindPatternPrefix(String var1) {
         this.g = AttributeExtensibleType.set(this.g, var1);
      }

      public String getBindPatternSuffix() {
         return AttributeExtensibleType.get(this.h);
      }

      public void setBindPatternSuffix(String var1) {
         this.h = AttributeExtensibleType.set(this.h, var1);
      }

      @XmlElement(name = "ServerUrls", required = true)
      protected AttributeExtensibleType.AttributeExtensibleStringList getServerUrlValues() {
         return this.d;
      }

      protected void setServerUrlValues(AttributeExtensibleType.AttributeExtensibleStringList var1) {
         this.d = var1;
      }

      @XmlElement(name = "UseSslClientAuthentication")
      protected AttributeExtensibleType.AttributeExtensibleBoolean getUseSslClientAuthenticationValue() {
         return this.e;
      }

      protected void setUseSslClientAuthenticationValue(AttributeExtensibleType.AttributeExtensibleBoolean var1) {
         this.e = var1;
      }

      @XmlElement(name = "SslKeyReference")
      protected ManagedObjectReference getSslKeyReferenceValue() {
         return this.f;
      }

      protected void setSslKeyReferenceValue(ManagedObjectReference var1) {
         this.f = var1;
      }

      @XmlElement(name = "BindPatternPrefix", required = true)
      protected AttributeExtensibleType.AttributeExtensibleString getBindPatternPrefixValue() {
         return this.g;
      }

      protected void setBindPatternPrefixValue(AttributeExtensibleType.AttributeExtensibleString var1) {
         this.g = var1;
      }

      @XmlElement(name = "BindPatternSuffix", required = true)
      protected AttributeExtensibleType.AttributeExtensibleString getBindPatternSuffixValue() {
         return this.h;
      }

      protected void setBindPatternSuffixValue(AttributeExtensibleType.AttributeExtensibleString var1) {
         this.h = var1;
      }
   }

   @XmlType(name = "FederatedIdentityProviderDetailType", propOrder = "certificateReferencesValue")
   public static class FederatedIdentityProviderDetail extends IdentityProviderMO.IdentityProviderDetail {
      private AttributeExtensibleReferenceList d;

      protected FederatedIdentityProviderDetail() {
      }

      public List<String> getCertificateReferences() {
         return Functions.map(Arrays.asList(AttributeExtensibleType.get(this.d, new ManagedObjectReference[0])), new h(this));
      }

      public void setCertificateReferences(List<String> var1) {
         if (var1 != null && !var1.isEmpty()) {
            if (this.d == null) {
               this.d = new AttributeExtensibleReferenceList();
            }

            List var2 = ManagedObjectReference.asReferences(var1);
            this.d.setReferenceType(TrustedCertificateMO.class);
            this.d.setValue(var2.toArray(new ManagedObjectReference[var2.size()]));
         } else {
            this.d = null;
         }
      }

      @XmlElement(name = "CertificateReferences")
      protected AttributeExtensibleReferenceList getCertificateReferencesValue() {
         return this.d;
      }

      protected void setCertificateReferencesValue(AttributeExtensibleReferenceList var1) {
         this.d = var1;
      }
   }

   @XmlType(name = "IdentityProviderDetailType", propOrder = {"extension", "extensions"})
   @XmlSeeAlso({IdentityProviderMO.FederatedIdentityProviderDetail.class, IdentityProviderMO.LdapIdentityProviderDetail.class})
   protected abstract static class IdentityProviderDetail extends ElementExtensionSupport {
   }

   @XmlType(name = "IdentityProviderExtensionType", propOrder = {"identityProviderDetail", "extension", "extensions"})
   protected static class IdentityProviderExtension extends ElementExtensionSupport {
      private IdentityProviderMO.IdentityProviderDetail d;

      @XmlElements(
         {
               @XmlElement(name = "FederatedIdentityProviderDetail", type = IdentityProviderMO.FederatedIdentityProviderDetail.class),
               @XmlElement(name = "LdapIdentityProviderDetail", type = IdentityProviderMO.LdapIdentityProviderDetail.class),
               @XmlElement(name = "BindOnlyLdapIdentityProviderDetail", type = IdentityProviderMO.BindOnlyLdapIdentityProviderDetail.class),
               @XmlElement(name = "PolicyBackedIdentityProviderDetail", type = IdentityProviderMO.PolicyBackedIdentityProviderDetail.class)
         }
      )
      protected IdentityProviderMO.IdentityProviderDetail getIdentityProviderDetail() {
         return this.d;
      }

      protected void setIdentityProviderDetail(IdentityProviderMO.IdentityProviderDetail var1) {
         this.d = var1;
      }
   }

   @XmlEnum(String.class)
   @XmlType(name = "IdentityProviderTypeType")
   public enum IdentityProviderType {
      @XmlEnumValue("Internal")
      INTERNAL,
      @XmlEnumValue("LDAP")
      LDAP,
      @XmlEnumValue("Federated")
      FEDERATED,
      @XmlEnumValue("Simple LDAP")
      BIND_ONLY_LDAP,
      @XmlEnumValue("Policy-Backed")
      POLICY_BACKED;

      // $VF: Failed to inline enum fields
      // Please report this to the Vineflower issue tracker, at https://github.com/Vineflower/vineflower/issues with a copy of the class file (if you have the rights to distribute it!)
      static {
         String[] var0 = new String[5];
         int var4 = 0;
         String var3 = "\u0000%()PPI\u000e59!K^W\b\u000b\"2(]QF\u000e\u0004\u000e('=";
         int var5 = "\u0000%()PPI\u000e59!K^W\b\u000b\"2(]QF\u000e\u0004\u000e('=".length();
         char var2 = 14;
         int var7 = -1;

         label25:
         while (true) {
            String var10000 = var3.substring(++var7, var7 + var2);
            byte var10001 = -1;

            while (true) {
               String var12 = a(a(var10000));
               switch (var10001) {
                  case 0:
                     var0[var4++] = var12;
                     if ((var7 += var2) >= var5) {
                        INTERNAL = new IdentityProviderMO.IdentityProviderType();
                        LDAP = new IdentityProviderMO.IdentityProviderType();
                        FEDERATED = new IdentityProviderMO.IdentityProviderType();
                        BIND_ONLY_LDAP = new IdentityProviderMO.IdentityProviderType();
                        POLICY_BACKED = new IdentityProviderMO.IdentityProviderType();
                        return;
                     }

                     var2 = var3.charAt(var7);
                     break;
                  default:
                     var0[var4++] = var12;
                     if ((var7 += var2) < var5) {
                        var2 = var3.charAt(var7);
                        continue label25;
                     }

                     var3 = "\u0004)\"(]^S\u0007(\r\u0012#*$LFX\u0000-%&J[";
                     var5 = "\u0004)\"(]^S\u0007(\r\u0012#*$LFX\u0000-%&J[".length();
                     var2 = '\t';
                     var7 = -1;
               }

               var10000 = var3.substring(++var7, var7 + var2);
               var10001 = 0;
            }
         }
      }

      private static char[] a(String var0) {
         char[] var10000 = var0.toCharArray();
         if (var10000.length < 2) {
            var10000[0] = (char)(var10000[0] ^ 7);
         }

         return var10000;
      }

      private static String a(char[] var0) {
         int var10002 = var0.length;
         char[] var10001 = var0;
         int var10000 = var10002;

         for (int var1 = 0; var10000 > var1; var1++) {
            var10001[var1] = (char)(var10001[var1] ^ switch (var1 % 7) {
               case 0 -> 66;
               case 1 -> 108;
               case 2 -> 102;
               case 3 -> 109;
               case 4 -> 15;
               case 5 -> 31;
               default -> 7;
            });
         }

         return new String(var10001).intern();
      }
   }

   @XmlType(
      name = "LdapIdentityProviderDetailType",
      propOrder = {
            "sourceTypeValue",
            "serverUrlValues",
            "useSslClientAuthenticationValue",
            "sslKeyReferenceValue",
            "searchBaseValue",
            "bindDnValue",
            "bindPasswordValue",
            "writableValue",
            "writeBaseValue",
            "userMappingValues",
            "groupMappingValues",
            "specifiedAttributeValues",
            "ntlmProperties"
      }
   )
   public static class LdapIdentityProviderDetail extends IdentityProviderMO.IdentityProviderDetail {
      private AttributeExtensibleType.AttributeExtensibleString d;
      private AttributeExtensibleType.AttributeExtensibleStringList e;
      private AttributeExtensibleType.AttributeExtensibleBoolean f;
      private ManagedObjectReference g;
      private AttributeExtensibleType.AttributeExtensibleString h;
      private AttributeExtensibleType.AttributeExtensibleString i;
      private AttributeExtensibleType.AttributeExtensibleString j;
      private AttributeExtensibleType.AttributeExtensibleBoolean k;
      private AttributeExtensibleType.AttributeExtensibleString l;
      private AttributeExtensibleType.AttributeExtensibleLong m;
      private IdentityProviderMO.AttributeExtensibleLdapIdentityProviderMappingList n;
      private IdentityProviderMO.AttributeExtensibleLdapIdentityProviderMappingList o;
      private AttributeExtensibleType.AttributeExtensibleStringList p;
      private Map<String, Object> q;
      private static final String[] r;

      protected LdapIdentityProviderDetail() {
      }

      public String getSourceType() {
         return AttributeExtensibleType.get(this.d);
      }

      public void setSourceType(String var1) {
         this.d = AttributeExtensibleType.set(this.d, var1);
      }

      public List<String> getServerUrls() {
         return AttributeExtensibleType.unwrap(AttributeExtensibleType.get(this.e, new ArrayList()));
      }

      public void setServerUrls(List<String> var1) {
         this.e = AttributeExtensibleType.set(this.e, AttributeExtensibleType.wrap(var1, AttributeExtensibleType.AttributeExtensibleStringBuilder));
      }

      public boolean isUseSslClientClientAuthentication() {
         return AttributeExtensibleType.get(this.f, Boolean.FALSE);
      }

      public void setUseSslClientAuthentication(boolean var1) {
         this.f = AttributeExtensibleType.set(this.f, var1);
      }

      public String getSslKeyId() {
         return this.g == null ? null : this.g.getId();
      }

      public void setSslKeyId(String var1) {
         if (var1 != null) {
            if (this.g == null) {
               this.g = new ManagedObjectReference();
            }

            this.g.setId(var1);
            this.g.setResourceType(PrivateKeyMO.class);
         } else {
            this.g = null;
         }
      }

      public String getSearchBase() {
         return AttributeExtensibleType.get(this.h);
      }

      public void setSearchBase(String var1) {
         this.h = AttributeExtensibleType.set(this.h, var1);
      }

      public String getBindDn() {
         return AttributeExtensibleType.get(this.i);
      }

      public void setBindDn(String var1) {
         this.i = AttributeExtensibleType.set(this.i, var1);
      }

      public String getBindPassword() {
         return AttributeExtensibleType.get(this.j);
      }

      public void setBindPassword(String var1) {
         this.j = AttributeExtensibleType.set(this.j, var1);
      }

      public boolean isWritable() {
         return AttributeExtensibleType.get(this.k) == null ? false : AttributeExtensibleType.get(this.k);
      }

      public void setWritable(boolean var1) {
         this.k = AttributeExtensibleType.set(this.k, var1);
      }

      public String getWriteBase() {
         return AttributeExtensibleType.get(this.l);
      }

      public void setWriteBase(String var1) {
         this.l = AttributeExtensibleType.set(this.l, var1);
      }

      public Long getReconnectTimeout() {
         return AttributeExtensibleType.get(this.m);
      }

      public void setReconnectTimeout(Long var1) {
         this.m = AttributeExtensibleType.set(this.m, var1);
      }

      public void setBindPassword(String var1, String var2) {
         this.j = new AttributeExtensibleType.AttributeExtensibleString();
         this.j.setValue(var1);
         this.j.setAttributeExtensions(CollectionUtils.mapBuilder().put(new QName(r[1]), var2).map());
      }

      public String getBindPasswordBundleKey() {
         return this.j != null && this.j.getAttributeExtensions() != null ? (String)this.j.getAttributeExtensions().get(new QName(r[0])) : null;
      }

      public boolean hasUserMappings() {
         return this.n != null && this.n.c != null;
      }

      public List<IdentityProviderMO.LdapIdentityProviderMapping> getUserMappings() {
         return AttributeExtensibleType.get(this.n, new ArrayList<>());
      }

      public void setUserMappings(List<IdentityProviderMO.LdapIdentityProviderMapping> var1) {
         this.n = AttributeExtensibleType.set(this.n, var1, IdentityProviderMO.AttributeExtensibleLdapIdentityProviderMappingList.b);
      }

      public boolean hasGroupMappings() {
         return this.o != null && this.o.c != null;
      }

      public List<IdentityProviderMO.LdapIdentityProviderMapping> getGroupMappings() {
         return AttributeExtensibleType.get(this.o, new ArrayList<>());
      }

      public void setGroupMappings(List<IdentityProviderMO.LdapIdentityProviderMapping> var1) {
         this.o = AttributeExtensibleType.set(this.o, var1, IdentityProviderMO.AttributeExtensibleLdapIdentityProviderMappingList.b);
      }

      public List<String> getSpecifiedAttributes() {
         return AttributeExtensibleType.unwrap(AttributeExtensibleType.get(this.p, null));
      }

      public void setSpecifiedAttributes(List<String> var1) {
         this.p = AttributeExtensibleType.set(this.p, AttributeExtensibleType.wrap(var1, AttributeExtensibleType.AttributeExtensibleStringBuilder));
      }

      @XmlElement(name = "NtlmProperties")
      @XmlJavaTypeAdapter(PropertiesMapType.PropertiesMapTypeAdapter.class)
      public Map<String, Object> getNtlmProperties() {
         return this.q;
      }

      public void setNtlmProperties(Map<String, Object> var1) {
         this.q = var1;
      }

      @XmlElement(name = "SourceType")
      protected AttributeExtensibleType.AttributeExtensibleString getSourceTypeValue() {
         return this.d;
      }

      protected void setSourceTypeValue(AttributeExtensibleType.AttributeExtensibleString var1) {
         this.d = var1;
      }

      @XmlElement(name = "ServerUrls", required = true)
      protected AttributeExtensibleType.AttributeExtensibleStringList getServerUrlValues() {
         return this.e;
      }

      protected void setServerUrlValues(AttributeExtensibleType.AttributeExtensibleStringList var1) {
         this.e = var1;
      }

      @XmlElement(name = "UseSslClientAuthentication")
      protected AttributeExtensibleType.AttributeExtensibleBoolean getUseSslClientAuthenticationValue() {
         return this.f;
      }

      protected void setUseSslClientAuthenticationValue(AttributeExtensibleType.AttributeExtensibleBoolean var1) {
         this.f = var1;
      }

      @XmlElement(name = "SslKeyReference")
      protected ManagedObjectReference getSslKeyReferenceValue() {
         return this.g;
      }

      protected void setSslKeyReferenceValue(ManagedObjectReference var1) {
         this.g = var1;
      }

      @XmlElement(name = "SearchBase", required = true)
      protected AttributeExtensibleType.AttributeExtensibleString getSearchBaseValue() {
         return this.h;
      }

      protected void setSearchBaseValue(AttributeExtensibleType.AttributeExtensibleString var1) {
         this.h = var1;
      }

      @XmlElement(name = "BindDn", required = true)
      protected AttributeExtensibleType.AttributeExtensibleString getBindDnValue() {
         return this.i;
      }

      protected void setBindDnValue(AttributeExtensibleType.AttributeExtensibleString var1) {
         this.i = var1;
      }

      @XmlElement(name = "BindPassword")
      protected AttributeExtensibleType.AttributeExtensibleString getBindPasswordValue() {
         return this.j;
      }

      protected void setBindPasswordValue(AttributeExtensibleType.AttributeExtensibleString var1) {
         this.j = var1;
      }

      @XmlElement(name = "Writable")
      protected AttributeExtensibleType.AttributeExtensibleBoolean getWritableValue() {
         return this.k;
      }

      protected void setWritableValue(AttributeExtensibleType.AttributeExtensibleBoolean var1) {
         this.k = var1;
      }

      @XmlElement(name = "WriteBase")
      protected AttributeExtensibleType.AttributeExtensibleString getWriteBaseValue() {
         return this.l;
      }

      protected void setWriteBaseValue(AttributeExtensibleType.AttributeExtensibleString var1) {
         this.l = var1;
      }

      @XmlElement(name = "UserMappings")
      protected IdentityProviderMO.AttributeExtensibleLdapIdentityProviderMappingList getUserMappingValues() {
         return this.n;
      }

      protected void setUserMappingValues(IdentityProviderMO.AttributeExtensibleLdapIdentityProviderMappingList var1) {
         this.n = var1;
      }

      @XmlElement(name = "GroupMappings")
      protected IdentityProviderMO.AttributeExtensibleLdapIdentityProviderMappingList getGroupMappingValues() {
         return this.o;
      }

      protected void setGroupMappingValues(IdentityProviderMO.AttributeExtensibleLdapIdentityProviderMappingList var1) {
         this.o = var1;
      }

      @XmlElement(name = "SpecifiedAttributes")
      protected AttributeExtensibleType.AttributeExtensibleStringList getSpecifiedAttributeValues() {
         return this.p;
      }

      protected void setSpecifiedAttributeValues(AttributeExtensibleType.AttributeExtensibleStringList var1) {
         this.p = var1;
      }

      static {
         String[] var5 = new String[2];
         int var3 = 0;
         String var2 = "<\u00172\u0014;\n\u0012;\u001b\t<\u00172\u0014;\n\u0012;\u001b";
         int var4 = "<\u00172\u0014;\n\u0012;\u001b\t<\u00172\u0014;\n\u0012;\u001b".length();
         char var1 = '\t';
         int var0 = -1;

         while (true) {
            String var10002 = b(b(var2.substring(++var0, var0 + var1)));
            byte var10001 = -1;
            var5[var3++] = var10002;
            if ((var0 += var1) >= var4) {
               r = var5;
               return;
            }

            var1 = var2.charAt(var0);
         }
      }

      private static char[] b(String var0) {
         char[] var10000 = var0.toCharArray();
         if (var10000.length < 2) {
            var10000[0] = (char)(var10000[0] ^ 89);
         }

         return var10000;
      }

      private static String b(char[] var0) {
         int var10002 = var0.length;
         char[] var10001 = var0;
         int var10000 = var10002;

         for (int var1 = 0; var10000 > var1; var1++) {
            var10001[var1] = (char)(var10001[var1] ^ switch (var1 % 7) {
               case 0 -> 94;
               case 1 -> 98;
               case 2 -> 92;
               case 3 -> 112;
               case 4 -> 87;
               case 5 -> 111;
               default -> 89;
            });
         }

         return new String(var10001).intern();
      }
   }

   @XmlType(name = "LdapIdentityProviderMappingType", propOrder = {"objectClassValue", "mappings", "properties", "extension", "extensions"})
   public static class LdapIdentityProviderMapping extends ElementExtensionSupport {
      private AttributeExtensibleType.AttributeExtensibleString d;
      private Map<String, Object> e;
      private Map<String, Object> f;

      LdapIdentityProviderMapping() {
      }

      public String getObjectClass() {
         return AttributeExtensibleType.get(this.d);
      }

      public void setObjectClass(String var1) {
         this.d = AttributeExtensibleType.set(this.d, var1);
      }

      @XmlElement(name = "Mappings", required = true)
      @XmlJavaTypeAdapter(PropertiesMapType.PropertiesMapTypeAdapter.class)
      public Map<String, Object> getMappings() {
         return this.e;
      }

      public void setMappings(Map<String, Object> var1) {
         this.e = var1;
      }

      @XmlElement(name = "Properties")
      @XmlJavaTypeAdapter(PropertiesMapType.PropertiesMapTypeAdapter.class)
      public Map<String, Object> getProperties() {
         return this.f;
      }

      public void setProperties(Map<String, Object> var1) {
         this.f = var1;
      }

      @XmlElement(name = "ObjectClass", required = true)
      protected AttributeExtensibleType.AttributeExtensibleString getObjectClassValue() {
         return this.d;
      }

      protected void setObjectClassValue(AttributeExtensibleType.AttributeExtensibleString var1) {
         this.d = var1;
      }
   }

   @XmlType(name = "PolicyBackedIdentityProviderDetailType", propOrder = {"authenticationPolicyIdValue", "defaultRoleAssignmentIdValue"})
   public static class PolicyBackedIdentityProviderDetail extends IdentityProviderMO.IdentityProviderDetail {
      private AttributeExtensibleType.AttributeExtensibleString d;
      private AttributeExtensibleType.AttributeExtensibleString e;

      protected PolicyBackedIdentityProviderDetail() {
      }

      public String getAuthenticationPolicyId() {
         return AttributeExtensibleType.get(this.d);
      }

      public void setAuthenticationPolicyId(String var1) {
         this.d = AttributeExtensibleType.set(this.d, var1);
      }

      public String getDefaultRoleAssignmentId() {
         return AttributeExtensibleType.get(this.e);
      }

      public void setDefaultRoleAssignmentId(String var1) {
         this.e = AttributeExtensibleType.set(this.e, var1);
      }

      @XmlElement(name = "AuthenticationPolicyId", required = true)
      protected AttributeExtensibleType.AttributeExtensibleString getAuthenticationPolicyIdValue() {
         return this.d;
      }

      protected void setAuthenticationPolicyIdValue(AttributeExtensibleType.AttributeExtensibleString var1) {
         this.d = var1;
      }

      @XmlElement(name = "DefaultRoleAssignmentId")
      protected AttributeExtensibleType.AttributeExtensibleString getDefaultRoleAssignmentIdValue() {
         return this.e;
      }

      protected void setDefaultRoleAssignmentIdValue(AttributeExtensibleType.AttributeExtensibleString var1) {
         this.e = var1;
      }
   }
}