export declare namespace PostConfigInfoDeclare {
    namespace $parameters {
        interface JsonObject {
            serialVersionUID?: number;
            DEFAULT_INITIAL_CAPACITY?: number;
            map?: Map;
            defaultTimeZone?: DefaultTimeZone;
            defaultLocale?: DefaultLocale;
            DEFAULT_TYPE_KEY?: string;
            emptyFilters?: Array<Result43>;
            DEFFAULT_DATE_FORMAT?: string;
            DEFAULT_PARSER_FEATURE?: number;
            DEFAULT_GENERATE_FEATURE?: number;
            bytesLocal?: BytesLocal;
            charsLocal?: CharsLocal;
            VERSION?: string;
        }
        interface Map {
        }
        interface DefaultTimeZone {
            SHORT?: number;
            LONG?: number;
            ONE_MINUTE?: number;
            ONE_HOUR?: number;
            ONE_DAY?: number;
            serialVersionUID?: number;
            nO_TIMEZONE?: NO_TIMEZONE;
            ID?: string;
            zoneId?: ZoneId;
            defaultTimeZone?: DefaultTimeZone1;
            GMT_ID?: string;
            GMT_ID_LENGTH?: number;
            $assertionsDisabled?: boolean;
        }
        interface NO_TIMEZONE {
        }
        interface ZoneId {
            sHORT_IDS?: SHORT_IDS;
            serialVersionUID?: number;
        }
        interface SHORT_IDS {
        }
        interface DefaultTimeZone1 {
        }
        interface DefaultLocale {
            lOCALECACHE?: LOCALECACHE;
            eNGLISH?: ENGLISH;
            fRENCH?: FRENCH;
            gERMAN?: GERMAN;
            iTALIAN?: ITALIAN;
            jAPANESE?: JAPANESE;
            kOREAN?: KOREAN;
            cHINESE?: CHINESE;
            sIMPLIFIED_CHINESE?: SIMPLIFIED_CHINESE;
            tRADITIONAL_CHINESE?: TRADITIONAL_CHINESE;
            fRANCE?: FRANCE;
            gERMANY?: GERMANY;
            iTALY?: ITALY;
            jAPAN?: JAPAN;
            kOREA?: KOREA;
            cHINA?: CHINA;
            pRC?: PRC;
            tAIWAN?: TAIWAN;
            uK?: UK;
            uS?: US;
            cANADA?: CANADA;
            cANADA_FRENCH?: CANADA_FRENCH;
            rOOT?: ROOT;
            pRIVATE_USE_EXTENSION?: PRIVATE_USE_EXTENSION;
            uNICODE_LOCALE_EXTENSION?: UNICODE_LOCALE_EXTENSION;
            serialVersionUID?: number;
            DISPLAY_LANGUAGE?: number;
            DISPLAY_COUNTRY?: number;
            DISPLAY_VARIANT?: number;
            DISPLAY_SCRIPT?: number;
            DISPLAY_UEXT_KEY?: number;
            DISPLAY_UEXT_TYPE?: number;
            baseLocale?: BaseLocale;
            localeExtensions?: LocaleExtensions;
            hashCodeValue?: number;
            defaultLocale?: DefaultLocale1;
            defaultDisplayLocale?: DefaultDisplayLocale;
            defaultFormatLocale?: DefaultFormatLocale;
            languageTag?: string;
            serialPersistentFields?: Array<Result>;
            isoLanguages?: Array<string>;
            isoCountries?: Array<string>;
            $assertionsDisabled?: boolean;
        }
        interface LOCALECACHE {
            map?: Map1;
            queue?: Queue;
        }
        interface Map1 {
        }
        interface Queue {
            nULL?: NULL;
            eNQUEUED?: ENQUEUED;
            lock?: Lock;
            head?: Head;
            queueLength?: number;
            $assertionsDisabled?: boolean;
        }
        interface NULL {
        }
        interface ENQUEUED {
        }
        interface Lock {
        }
        interface Head {
            referent?: Referent;
            queue?: Queue1;
            next?: Next;
            discovered?: Discovered;
            processPendingLock?: ProcessPendingLock;
            processPendingActive?: boolean;
        }
        interface Referent {
        }
        interface Queue1 {
        }
        interface Next {
        }
        interface Discovered {
        }
        interface ProcessPendingLock {
        }
        interface ENGLISH {
        }
        interface FRENCH {
        }
        interface GERMAN {
        }
        interface ITALIAN {
        }
        interface JAPANESE {
        }
        interface KOREAN {
        }
        interface CHINESE {
        }
        interface SIMPLIFIED_CHINESE {
        }
        interface TRADITIONAL_CHINESE {
        }
        interface FRANCE {
        }
        interface GERMANY {
        }
        interface ITALY {
        }
        interface JAPAN {
        }
        interface KOREA {
        }
        interface CHINA {
        }
        interface PRC {
        }
        interface TAIWAN {
        }
        interface UK {
        }
        interface US {
        }
        interface CANADA {
        }
        interface CANADA_FRENCH {
        }
        interface ROOT {
        }
        interface PRIVATE_USE_EXTENSION {
        }
        interface UNICODE_LOCALE_EXTENSION {
        }
        interface BaseLocale {
            SEP?: string;
            cACHE?: CACHE;
            language?: string;
            script?: string;
            region?: string;
            variant?: string;
            hash?: number;
        }
        interface CACHE {
            map?: Map2;
            queue?: Queue2;
        }
        interface Map2 {
        }
        interface Queue2 {
        }
        interface LocaleExtensions {
            extensionMap?: ExtensionMap;
            id?: string;
            cALENDAR_JAPANESE?: CALENDAR_JAPANESE;
            nUMBER_THAI?: NUMBER_THAI;
            $assertionsDisabled?: boolean;
        }
        interface ExtensionMap {
        }
        interface CALENDAR_JAPANESE {
        }
        interface NUMBER_THAI {
        }
        interface DefaultLocale1 {
        }
        interface DefaultDisplayLocale {
        }
        interface DefaultFormatLocale {
        }
        interface Result {
            name?: string;
            signature?: string;
            type?: Type;
            typeSignature?: string;
            unshared?: boolean;
            field?: Field;
            offset?: number;
        }
        interface Type {
            ANNOTATION?: number;
            ENUM?: number;
            SYNTHETIC?: number;
            cachedConstructor?: CachedConstructor;
            newInstanceCallerCache?: NewInstanceCallerCache;
            name?: string;
            module?: Module;
            packageName?: string;
            componentType?: ComponentType;
            allPermDomain?: AllPermDomain;
            reflectionData?: ReflectionData;
            classRedefinedCount?: number;
            genericInfo?: GenericInfo2;
            EMPTY_CLASS_ARRAY?: Array<Result37>;
            serialVersionUID?: number;
            serialPersistentFields?: Array<Result38>;
            reflectionFactory?: ReflectionFactory3;
            enumConstants?: Array<Result39>;
            enumConstantDirectory?: EnumConstantDirectory;
            annotationData?: AnnotationData;
            annotationType?: AnnotationType;
            classValueMap?: ClassValueMap;
        }
        interface CachedConstructor {
            clazz?: Clazz;
            slot?: number;
            parameterTypes?: Array<Result1>;
            exceptionTypes?: Array<Result2>;
            modifiers?: number;
            signature?: string;
            genericInfo?: GenericInfo;
            annotations?: Array<Result6>;
            parameterAnnotations?: Array<Result7>;
            constructorAccessor?: ConstructorAccessor;
            root?: Root;
            hasRealParameterData?: boolean;
            parameters?: Array<Result8>;
            declaredAnnotations?: DeclaredAnnotations3;
            override?: boolean;
            reflectionFactory?: ReflectionFactory2;
            securityCheckCache?: SecurityCheckCache2;
            printStackWhenAccessFails?: boolean;
            printStackPropertiesSet?: boolean;
        }
        interface Clazz {
        }
        interface Result1 {
        }
        interface Result2 {
        }
        interface GenericInfo {
            parameterTypes?: Array<Result3>;
            exceptionTypes?: Array<Result4>;
            typeParameters?: Array<Result5>;
            factory?: Factory;
            tree?: Tree;
        }
        interface Result3 {
        }
        interface Result4 {
        }
        interface Result5 {
        }
        interface Factory {
        }
        interface Tree {
        }
        interface Result6 {
        }
        interface Result7 {
        }
        interface ConstructorAccessor {
        }
        interface Root {
        }
        interface Result8 {
            name?: string;
            modifiers?: number;
            executable?: Executable;
            index?: number;
            parameterTypeCache?: ParameterTypeCache;
            parameterClassCache?: ParameterClassCache;
            declaredAnnotations?: DeclaredAnnotations2;
        }
        interface Executable {
            hasRealParameterData?: boolean;
            parameters?: Array<Result9>;
            declaredAnnotations?: DeclaredAnnotations;
            override?: boolean;
            reflectionFactory?: ReflectionFactory;
            securityCheckCache?: SecurityCheckCache1;
            printStackWhenAccessFails?: boolean;
            printStackPropertiesSet?: boolean;
        }
        interface Result9 {
        }
        interface DeclaredAnnotations {
        }
        interface ReflectionFactory {
            initted?: boolean;
            soleInstance?: SoleInstance;
            langReflectAccess?: LangReflectAccess;
            hasStaticInitializerMethod?: HasStaticInitializerMethod;
            noInflation?: boolean;
            inflationThreshold?: number;
            disableSerialConstructorChecks?: boolean;
            $assertionsDisabled?: boolean;
        }
        interface SoleInstance {
        }
        interface LangReflectAccess {
        }
        interface HasStaticInitializerMethod {
            clazz?: Clazz1;
            slot?: number;
            name?: string;
            returnType?: ReturnType;
            parameterTypes?: Array<Result10>;
            exceptionTypes?: Array<Result11>;
            modifiers?: number;
            signature?: string;
            genericInfo?: GenericInfo1;
            annotations?: Array<Result15>;
            parameterAnnotations?: Array<Result16>;
            annotationDefault?: Array<Result17>;
            methodAccessor?: MethodAccessor;
            root?: Root1;
            hasRealParameterData?: boolean;
            parameters?: Array<Result18>;
            declaredAnnotations?: DeclaredAnnotations1;
            override?: boolean;
            reflectionFactory?: ReflectionFactory1;
            securityCheckCache?: SecurityCheckCache;
            printStackWhenAccessFails?: boolean;
            printStackPropertiesSet?: boolean;
        }
        interface Clazz1 {
        }
        interface ReturnType {
        }
        interface Result10 {
        }
        interface Result11 {
        }
        interface GenericInfo1 {
            returnType?: ReturnType1;
            parameterTypes?: Array<Result12>;
            exceptionTypes?: Array<Result13>;
            typeParameters?: Array<Result14>;
            factory?: Factory1;
            tree?: Tree1;
        }
        interface ReturnType1 {
        }
        interface Result12 {
        }
        interface Result13 {
        }
        interface Result14 {
        }
        interface Factory1 {
        }
        interface Tree1 {
        }
        interface Result15 {
        }
        interface Result16 {
        }
        interface Result17 {
        }
        interface MethodAccessor {
        }
        interface Root1 {
        }
        interface Result18 {
        }
        interface DeclaredAnnotations1 {
        }
        interface ReflectionFactory1 {
        }
        interface SecurityCheckCache {
        }
        interface SecurityCheckCache1 {
        }
        interface ParameterTypeCache {
        }
        interface ParameterClassCache {
        }
        interface DeclaredAnnotations2 {
        }
        interface DeclaredAnnotations3 {
        }
        interface ReflectionFactory2 {
        }
        interface SecurityCheckCache2 {
        }
        interface NewInstanceCallerCache {
        }
        interface Module {
            layer?: Layer;
            name?: string;
            loader?: Loader;
            descriptor?: Descriptor;
            aLL_UNNAMED_MODULE?: ALL_UNNAMED_MODULE;
            aLL_UNNAMED_MODULE_SET?: ALL_UNNAMED_MODULE_SET;
            eVERYONE_MODULE?: EVERYONE_MODULE;
            eVERYONE_SET?: EVERYONE_SET;
            reads?: Reads;
            openPackages?: OpenPackages;
            exportedPackages?: ExportedPackages;
            moduleInfoClass?: ModuleInfoClass;
            $assertionsDisabled?: boolean;
        }
        interface Layer {
            eMPTY_LAYER?: EMPTY_LAYER;
            cf?: Cf;
            parents?: Array<any>;
            nameToModule?: NameToModule1;
            allLayers?: Array<any>;
            modules?: Modules1;
            servicesCatalog?: ServicesCatalog;
            cLV?: CLV1;
        }
        interface EMPTY_LAYER {
        }
        interface Cf {
            eMPTY_CONFIGURATION?: EMPTY_CONFIGURATION;
            parents?: Array<any>;
            graph?: Graph;
            modules?: Modules;
            nameToModule?: NameToModule;
            targetPlatform?: string;
            allConfigurations?: Array<any>;
            $assertionsDisabled?: boolean;
        }
        interface EMPTY_CONFIGURATION {
        }
        interface Graph {
        }
        interface Modules {
        }
        interface NameToModule {
        }
        interface NameToModule1 {
        }
        interface Modules1 {
        }
        interface ServicesCatalog {
            map?: Map3;
            cLV?: CLV;
        }
        interface Map3 {
        }
        interface CLV {
            jLA?: JLA;
        }
        interface JLA {
        }
        interface CLV1 {
        }
        interface Loader {
            parent?: Parent;
            name?: string;
            unnamedModule?: UnnamedModule;
            nameAndId?: string;
            parallelLockMap?: ParallelLockMap;
            package2certs?: Package2certs;
            nocerts?: Array<Result22>;
            classes?: Array<any>;
            defaultDomain?: DefaultDomain;
            packages?: Packages;
            scl?: Scl;
            usr_paths?: Array<string>;
            sys_paths?: Array<string>;
            loadedLibraryNames?: LoadedLibraryNames;
            systemNativeLibraries?: SystemNativeLibraries;
            nativeLibraries?: NativeLibraries;
            assertionLock?: AssertionLock;
            defaultAssertionStatus?: boolean;
            packageAssertionStatus?: PackageAssertionStatus;
            classAssertionStatus?: ClassAssertionStatus;
            classLoaderValueMap?: ClassLoaderValueMap;
            $assertionsDisabled?: boolean;
        }
        interface Parent {
        }
        interface UnnamedModule {
        }
        interface ParallelLockMap {
            serialVersionUID?: number;
            MAXIMUM_CAPACITY?: number;
            DEFAULT_CAPACITY?: number;
            MAX_ARRAY_SIZE?: number;
            DEFAULT_CONCURRENCY_LEVEL?: number;
            LOAD_FACTOR?: number;
            TREEIFY_THRESHOLD?: number;
            UNTREEIFY_THRESHOLD?: number;
            MIN_TREEIFY_CAPACITY?: number;
            MIN_TRANSFER_STRIDE?: number;
            RESIZE_STAMP_BITS?: number;
            MAX_RESIZERS?: number;
            RESIZE_STAMP_SHIFT?: number;
            MOVED?: number;
            TREEBIN?: number;
            RESERVED?: number;
            HASH_BITS?: number;
            NCPU?: number;
            serialPersistentFields?: Array<Result19>;
            nextTable?: Array<Result20>;
            baseCount?: number;
            sizeCtl?: number;
            transferIndex?: number;
            cellsBusy?: number;
            counterCells?: Array<Result21>;
            keySet?: KeySet;
            values?: Values;
            entrySet?: EntrySet;
            u?: U;
            SIZECTL?: number;
            TRANSFERINDEX?: number;
            BASECOUNT?: number;
            CELLSBUSY?: number;
            CELLVALUE?: number;
            ABASE?: number;
            ASHIFT?: number;
        }
        interface Result19 {
        }
        interface Result20 {
            hash?: number;
            key?: Key;
            val?: Val;
            next?: Next1;
        }
        interface Key {
        }
        interface Val {
        }
        interface Next1 {
        }
        interface Result21 {
            value?: number;
        }
        interface KeySet {
            serialVersionUID?: number;
            value?: Value;
            map?: Map4;
            OOME_MSG?: string;
        }
        interface Value {
        }
        interface Map4 {
        }
        interface Values {
            serialVersionUID?: number;
            map?: Map5;
            OOME_MSG?: string;
        }
        interface Map5 {
        }
        interface EntrySet {
            serialVersionUID?: number;
            map?: Map6;
            OOME_MSG?: string;
        }
        interface Map6 {
        }
        interface U {
            theUnsafe?: TheUnsafe;
            INVALID_FIELD_OFFSET?: number;
            ARRAY_BOOLEAN_BASE_OFFSET?: number;
            ARRAY_BYTE_BASE_OFFSET?: number;
            ARRAY_SHORT_BASE_OFFSET?: number;
            ARRAY_CHAR_BASE_OFFSET?: number;
            ARRAY_INT_BASE_OFFSET?: number;
            ARRAY_LONG_BASE_OFFSET?: number;
            ARRAY_FLOAT_BASE_OFFSET?: number;
            ARRAY_DOUBLE_BASE_OFFSET?: number;
            ARRAY_OBJECT_BASE_OFFSET?: number;
            ARRAY_BOOLEAN_INDEX_SCALE?: number;
            ARRAY_BYTE_INDEX_SCALE?: number;
            ARRAY_SHORT_INDEX_SCALE?: number;
            ARRAY_CHAR_INDEX_SCALE?: number;
            ARRAY_INT_INDEX_SCALE?: number;
            ARRAY_LONG_INDEX_SCALE?: number;
            ARRAY_FLOAT_INDEX_SCALE?: number;
            ARRAY_DOUBLE_INDEX_SCALE?: number;
            ARRAY_OBJECT_INDEX_SCALE?: number;
            ADDRESS_SIZE?: number;
            BE?: boolean;
            unalignedAccess?: boolean;
        }
        interface TheUnsafe {
        }
        interface KeySet1 {
        }
        interface Values1 {
        }
        interface Package2certs {
        }
        interface Result22 {
            serialVersionUID?: number;
            type?: string;
            hash?: number;
        }
        interface DefaultDomain {
            filePermCompatInPD?: boolean;
            codesource?: Codesource;
            classloader?: Classloader;
            principals?: Array<Result34>;
            permissions?: Permissions;
            hasAllPerm?: boolean;
            staticPermissions?: boolean;
            key?: Key2;
        }
        interface Codesource {
            serialVersionUID?: number;
            location?: Location;
            signers?: Array<Result26>;
            certs?: Array<Result27>;
            sp?: Sp;
            factory?: Factory3;
            locationNoFragString?: string;
        }
        interface Location {
            BUILTIN_HANDLERS_PREFIX?: string;
            serialVersionUID?: number;
            protocolPathProp?: string;
            protocol?: string;
            host?: string;
            port?: number;
            file?: string;
            query?: string;
            authority?: string;
            path?: string;
            userInfo?: string;
            ref?: string;
            hostAddress?: HostAddress;
            handler?: Handler;
            hashCode?: number;
            tempState?: TempState;
            factory?: Factory2;
            defaultFactory?: DefaultFactory;
            gate?: Gate;
            handlers?: Handlers;
            streamHandlerLock?: StreamHandlerLock;
            serialPersistentFields?: Array<Result25>;
        }
        interface HostAddress {
            PREFER_IPV4_VALUE?: number;
            PREFER_IPV6_VALUE?: number;
            PREFER_SYSTEM_VALUE?: number;
            IPv4?: number;
            IPv6?: number;
            preferIPv6Address?: number;
            holder?: Holder;
            nameService?: NameService;
            canonicalHostName?: string;
            serialVersionUID?: number;
            cache?: Cache;
            expirySet?: ExpirySet;
            impl?: Impl;
            cachedLocalHost?: CachedLocalHost;
            uNSAFE?: UNSAFE;
            FIELDS_OFFSET?: number;
            serialPersistentFields?: Array<Result23>;
        }
        interface Holder {
            originalHostName?: string;
            hostName?: string;
            address?: number;
            family?: number;
        }
        interface NameService {
        }
        interface Cache {
        }
        interface ExpirySet {
        }
        interface Impl {
        }
        interface CachedLocalHost {
            host?: string;
            addr?: Addr;
            expiryTime?: number;
        }
        interface Addr {
        }
        interface UNSAFE {
        }
        interface Result23 {
        }
        interface Handler {
        }
        interface TempState {
            protocol?: string;
            host?: string;
            port?: number;
            authority?: string;
            file?: string;
            ref?: string;
            hashCode?: number;
        }
        interface Factory2 {
        }
        interface DefaultFactory {
        }
        interface Gate {
            threadLocalHashCode?: number;
            nextHashCode?: NextHashCode;
            HASH_INCREMENT?: number;
        }
        interface NextHashCode {
            serialVersionUID?: number;
            u?: U1;
            VALUE?: number;
            value?: number;
        }
        interface U1 {
        }
        interface Handlers {
            table?: Array<Result24>;
            count?: number;
            threshold?: number;
            loadFactor?: number;
            modCount?: number;
            serialVersionUID?: number;
            MAX_ARRAY_SIZE?: number;
            keySet?: KeySet2;
            entrySet?: EntrySet1;
            values?: Values2;
            KEYS?: number;
            VALUES?: number;
            ENTRIES?: number;
        }
        interface Result24 {
            hash?: number;
            key?: Key1;
            value?: Value1;
            next?: Next2;
        }
        interface Key1 {
        }
        interface Value1 {
        }
        interface Next2 {
        }
        interface KeySet2 {
        }
        interface EntrySet1 {
        }
        interface Values2 {
        }
        interface StreamHandlerLock {
        }
        interface Result25 {
        }
        interface Result26 {
            serialVersionUID?: number;
            signerCertPath?: SignerCertPath;
            timestamp?: Timestamp;
            myhash?: number;
        }
        interface SignerCertPath {
            serialVersionUID?: number;
            type?: string;
        }
        interface Timestamp {
            serialVersionUID?: number;
            timestamp?: Date;
            signerCertPath?: SignerCertPath1;
            myhash?: number;
        }
        interface SignerCertPath1 {
        }
        interface Result27 {
        }
        interface Sp {
            serialVersionUID?: number;
            CONNECT?: number;
            LISTEN?: number;
            ACCEPT?: number;
            RESOLVE?: number;
            NONE?: number;
            ALL?: number;
            PORT_MIN?: number;
            PORT_MAX?: number;
            PRIV_PORT_MAX?: number;
            DEF_EPH_LOW?: number;
            mask?: number;
            actions?: string;
            hostname?: string;
            cname?: string;
            addresses?: Array<Result28>;
            wildcard?: boolean;
            init_with_ip?: boolean;
            invalid?: boolean;
            portrange?: Array<number>;
            defaultDeny?: boolean;
            untrusted?: boolean;
            trusted?: boolean;
            trustNameService?: boolean;
            debug?: Debug;
            debugInit?: boolean;
            cdomain?: string;
            hdomain?: string;
            name?: string;
        }
        interface Result28 {
        }
        interface Debug {
            prefix?: string;
            args?: string;
            hexDigits?: Array<Result29>;
        }
        interface Result29 {
        }
        interface Factory3 {
            type?: string;
            provider?: Provider;
            certFacSpi?: CertFacSpi;
        }
        interface Provider {
            serialVersionUID?: number;
            debug?: Debug1;
            name?: string;
            info?: string;
            version?: number;
            versionStr?: string;
            entrySet?: EntrySet2;
            entrySetCallCount?: number;
            initialized?: boolean;
            legacyChanged?: boolean;
            servicesChanged?: boolean;
            legacyStrings?: LegacyStrings;
            serviceMap?: ServiceMap;
            prngAlgos?: PrngAlgos;
            legacyMap?: LegacyMap;
            serviceSet?: ServiceSet;
            ALIAS_PREFIX?: string;
            ALIAS_PREFIX_LOWER?: string;
            ALIAS_LENGTH?: number;
            previousKey?: PreviousKey;
            knownEngines?: KnownEngines;
            uNSAFE?: UNSAFE1;
            defaults?: Defaults;
            map?: Map8;
            hexDigit?: Array<Result32>;
            table?: Array<Result33>;
            count?: number;
            threshold?: number;
            loadFactor?: number;
            modCount?: number;
            MAX_ARRAY_SIZE?: number;
            keySet?: KeySet4;
            values?: Values4;
            KEYS?: number;
            VALUES?: number;
            ENTRIES?: number;
        }
        interface Debug1 {
        }
        interface EntrySet2 {
        }
        interface LegacyStrings {
        }
        interface ServiceMap {
        }
        interface PrngAlgos {
        }
        interface LegacyMap {
        }
        interface ServiceSet {
        }
        interface PreviousKey {
            type?: string;
            algorithm?: string;
            originalAlgorithm?: string;
        }
        interface KnownEngines {
        }
        interface UNSAFE1 {
        }
        interface Defaults {
            serialVersionUID?: number;
            uNSAFE?: UNSAFE2;
            defaults?: Defaults1;
            map?: Map7;
            hexDigit?: Array<Result30>;
            table?: Array<Result31>;
            count?: number;
            threshold?: number;
            loadFactor?: number;
            modCount?: number;
            MAX_ARRAY_SIZE?: number;
            keySet?: KeySet3;
            entrySet?: EntrySet3;
            values?: Values3;
            KEYS?: number;
            VALUES?: number;
            ENTRIES?: number;
        }
        interface UNSAFE2 {
        }
        interface Defaults1 {
        }
        interface Map7 {
        }
        interface Result30 {
        }
        interface Result31 {
        }
        interface KeySet3 {
        }
        interface EntrySet3 {
        }
        interface Values3 {
        }
        interface Map8 {
        }
        interface Result32 {
        }
        interface Result33 {
        }
        interface KeySet4 {
        }
        interface EntrySet4 {
        }
        interface Values4 {
        }
        interface CertFacSpi {
        }
        interface Classloader {
        }
        interface Result34 {
        }
        interface Permissions {
            serialVersionUID?: number;
            readOnly?: boolean;
        }
        interface Key2 {
            this$0?: This$0;
        }
        interface This$0 {
        }
        interface Packages {
        }
        interface Scl {
        }
        interface LoadedLibraryNames {
        }
        interface SystemNativeLibraries {
        }
        interface NativeLibraries {
        }
        interface AssertionLock {
        }
        interface PackageAssertionStatus {
        }
        interface ClassAssertionStatus {
        }
        interface ClassLoaderValueMap {
        }
        interface Descriptor {
            name?: string;
            version?: Version;
            rawVersionString?: string;
            modifiers?: Modifiers;
            open?: boolean;
            automatic?: boolean;
            requires?: Requires;
            exports?: Exports;
            opens?: Opens;
            uses?: Uses;
            provides?: Provides;
            packages?: Packages1;
            mainClass?: string;
            hash?: number;
            $assertionsDisabled?: boolean;
        }
        interface Version {
            version?: string;
            sequence?: Array<any>;
            pre?: Array<any>;
            build?: Array<any>;
        }
        interface Modifiers {
        }
        interface Requires {
        }
        interface Exports {
        }
        interface Opens {
        }
        interface Uses {
        }
        interface Provides {
        }
        interface Packages1 {
        }
        interface ALL_UNNAMED_MODULE {
        }
        interface ALL_UNNAMED_MODULE_SET {
        }
        interface EVERYONE_MODULE {
        }
        interface EVERYONE_SET {
        }
        interface Reads {
        }
        interface OpenPackages {
        }
        interface ExportedPackages {
        }
        interface ModuleInfoClass {
        }
        interface ComponentType {
        }
        interface AllPermDomain {
        }
        interface ReflectionData {
            clock?: number;
            timestamp?: number;
            referent?: Referent1;
            queue?: Queue3;
            next?: Next3;
            discovered?: Discovered1;
            processPendingLock?: ProcessPendingLock1;
            processPendingActive?: boolean;
        }
        interface Referent1 {
        }
        interface Queue3 {
        }
        interface Next3 {
        }
        interface Discovered1 {
        }
        interface ProcessPendingLock1 {
        }
        interface GenericInfo2 {
            nONE?: NONE;
            superclass?: Superclass;
            superInterfaces?: Array<Result35>;
            typeParameters?: Array<Result36>;
            factory?: Factory4;
            tree?: Tree2;
        }
        interface NONE {
        }
        interface Superclass {
        }
        interface Result35 {
        }
        interface Result36 {
        }
        interface Factory4 {
        }
        interface Tree2 {
        }
        interface Result37 {
        }
        interface Result38 {
        }
        interface ReflectionFactory3 {
        }
        interface Result39 {
        }
        interface EnumConstantDirectory {
        }
        interface AnnotationData {
            annotations?: Annotations;
            declaredAnnotations?: DeclaredAnnotations4;
            redefinedCount?: number;
        }
        interface Annotations {
        }
        interface DeclaredAnnotations4 {
        }
        interface AnnotationType {
            memberTypes?: MemberTypes;
            memberDefaults?: MemberDefaults;
            members?: Members;
            retention?: Retention;
            inherited?: boolean;
            $assertionsDisabled?: boolean;
        }
        interface MemberTypes {
        }
        interface MemberDefaults {
        }
        interface Members {
        }
        interface Retention {
            sOURCE?: SOURCE;
            cLASS?: CLASS;
            rUNTIME?: RUNTIME;
            $VALUES?: Array<Result40>;
            name?: string;
            ordinal?: number;
        }
        interface SOURCE {
        }
        interface CLASS {
        }
        interface RUNTIME {
        }
        interface Result40 {
        }
        interface ClassValueMap {
            cacheArray?: Array<Result41>;
            cacheLoad?: number;
            cacheLoadLimit?: number;
            INITIAL_ENTRIES?: number;
            CACHE_LOAD_LIMIT?: number;
            PROBE_LIMIT?: number;
            $assertionsDisabled?: boolean;
            DEFAULT_INITIAL_CAPACITY?: number;
            MAXIMUM_CAPACITY?: number;
            DEFAULT_LOAD_FACTOR?: number;
            size?: number;
            threshold?: number;
            loadFactor?: number;
            queue?: Queue5;
            modCount?: number;
            nULL_KEY?: NULL_KEY;
            entrySet?: EntrySet5;
            keySet?: KeySet5;
            values?: Values5;
        }
        interface Result41 {
            value?: Value2;
            dEAD_ENTRY?: DEAD_ENTRY;
            $assertionsDisabled?: boolean;
            referent?: Referent2;
            queue?: Queue4;
            next?: Next4;
            discovered?: Discovered2;
            processPendingLock?: ProcessPendingLock2;
            processPendingActive?: boolean;
        }
        interface Value2 {
        }
        interface DEAD_ENTRY {
        }
        interface Referent2 {
        }
        interface Queue4 {
        }
        interface Next4 {
        }
        interface Discovered2 {
        }
        interface ProcessPendingLock2 {
        }
        interface Queue5 {
        }
        interface NULL_KEY {
        }
        interface EntrySet5 {
        }
        interface KeySet5 {
        }
        interface Values5 {
        }
        interface Field {
            clazz?: Clazz2;
            slot?: number;
            name?: string;
            type?: Type1;
            modifiers?: number;
            signature?: string;
            genericInfo?: GenericInfo3;
            annotations?: Array<Result42>;
            fieldAccessor?: FieldAccessor;
            overrideFieldAccessor?: OverrideFieldAccessor;
            root?: Root2;
            declaredAnnotations?: DeclaredAnnotations5;
            override?: boolean;
            reflectionFactory?: ReflectionFactory4;
            securityCheckCache?: SecurityCheckCache3;
            printStackWhenAccessFails?: boolean;
            printStackPropertiesSet?: boolean;
        }
        interface Clazz2 {
        }
        interface Type1 {
        }
        interface GenericInfo3 {
            genericType?: GenericType;
            factory?: Factory5;
            tree?: Tree3;
        }
        interface GenericType {
        }
        interface Factory5 {
        }
        interface Tree3 {
        }
        interface Result42 {
        }
        interface FieldAccessor {
        }
        interface OverrideFieldAccessor {
        }
        interface Root2 {
        }
        interface DeclaredAnnotations5 {
        }
        interface ReflectionFactory4 {
        }
        interface SecurityCheckCache3 {
        }
        interface Result43 {
        }
        interface BytesLocal {
        }
        interface CharsLocal {
        }
    }
    namespace $results {
        interface Result {
            resCode?: string;
            msg?: string;
            data?: string;
        }
    }
    type Parameters = $parameters.JsonObject;
    type Result = $results.Result;
}
export declare type Parameters = PostConfigInfoDeclare.Parameters;
export declare type Result = PostConfigInfoDeclare.Result;
