import { File } from '../mslib/File'
import { OpResult } from '../mslib/OpResult'

export namespace PostPayFeeInfoDeclare {
        export namespace $parameters {
            export 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
            }


            export interface Map{
            }


            export 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
            }


            export interface NO_TIMEZONE{
            }


            export interface ZoneId{
                sHORT_IDS?: SHORT_IDS
                serialVersionUID?: number
            }


            export interface SHORT_IDS{
            }


            export interface DefaultTimeZone1{
            }


            export 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
            }


            export interface LOCALECACHE{
                map?: Map1
                queue?: Queue
            }


            export interface Map1{
            }


            export interface Queue{
                nULL?: NULL
                eNQUEUED?: ENQUEUED
                lock?: Lock
                head?: Head
                queueLength?: number
                $assertionsDisabled?: boolean
            }


            export interface NULL{
            }


            export interface ENQUEUED{
            }


            export interface Lock{
            }


            export interface Head{
                referent?: Referent
                queue?: Queue1
                next?: Next
                discovered?: Discovered
                processPendingLock?: ProcessPendingLock
                processPendingActive?: boolean
            }


            export interface Referent{
            }


            export interface Queue1{
            }


            export interface Next{
            }


            export interface Discovered{
            }


            export interface ProcessPendingLock{
            }


            export interface ENGLISH{
            }


            export interface FRENCH{
            }


            export interface GERMAN{
            }


            export interface ITALIAN{
            }


            export interface JAPANESE{
            }


            export interface KOREAN{
            }


            export interface CHINESE{
            }


            export interface SIMPLIFIED_CHINESE{
            }


            export interface TRADITIONAL_CHINESE{
            }


            export interface FRANCE{
            }


            export interface GERMANY{
            }


            export interface ITALY{
            }


            export interface JAPAN{
            }


            export interface KOREA{
            }


            export interface CHINA{
            }


            export interface PRC{
            }


            export interface TAIWAN{
            }


            export interface UK{
            }


            export interface US{
            }


            export interface CANADA{
            }


            export interface CANADA_FRENCH{
            }


            export interface ROOT{
            }


            export interface PRIVATE_USE_EXTENSION{
            }


            export interface UNICODE_LOCALE_EXTENSION{
            }


            export interface BaseLocale{
                SEP?: string
                cACHE?: CACHE
                language?: string
                script?: string
                region?: string
                variant?: string
                hash?: number
            }


            export interface CACHE{
                map?: Map2
                queue?: Queue2
            }


            export interface Map2{
            }


            export interface Queue2{
            }


            export interface LocaleExtensions{
                extensionMap?: ExtensionMap
                id?: string
                cALENDAR_JAPANESE?: CALENDAR_JAPANESE
                nUMBER_THAI?: NUMBER_THAI
                $assertionsDisabled?: boolean
            }


            export interface ExtensionMap{
            }


            export interface CALENDAR_JAPANESE{
            }


            export interface NUMBER_THAI{
            }


            export interface DefaultLocale1{
            }


            export interface DefaultDisplayLocale{
            }


            export interface DefaultFormatLocale{
            }


            export interface Result{
                name?: string
                signature?: string
                type?: Type
                typeSignature?: string
                unshared?: boolean
                field?: Field
                offset?: number
            }


            export 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
            }


            export 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
            }


            export interface Clazz{
            }


            export interface Result1{
            }


            export interface Result2{
            }


            export interface GenericInfo{
                parameterTypes?: Array<Result3>
                exceptionTypes?: Array<Result4>
                typeParameters?: Array<Result5>
                factory?: Factory
                tree?: Tree
            }


            export interface Result3{
            }


            export interface Result4{
            }


            export interface Result5{
            }


            export interface Factory{
            }


            export interface Tree{
            }


            export interface Result6{
            }


            export interface Result7{
            }


            export interface ConstructorAccessor{
            }


            export interface Root{
            }


            export interface Result8{
                name?: string
                modifiers?: number
                executable?: Executable
                index?: number
                parameterTypeCache?: ParameterTypeCache
                parameterClassCache?: ParameterClassCache
                declaredAnnotations?: DeclaredAnnotations2
            }


            export interface Executable{
                hasRealParameterData?: boolean
                parameters?: Array<Result9>
                declaredAnnotations?: DeclaredAnnotations
                override?: boolean
                reflectionFactory?: ReflectionFactory
                securityCheckCache?: SecurityCheckCache1
                printStackWhenAccessFails?: boolean
                printStackPropertiesSet?: boolean
            }


            export interface Result9{
            }


            export interface DeclaredAnnotations{
            }


            export interface ReflectionFactory{
                initted?: boolean
                soleInstance?: SoleInstance
                langReflectAccess?: LangReflectAccess
                hasStaticInitializerMethod?: HasStaticInitializerMethod
                noInflation?: boolean
                inflationThreshold?: number
                disableSerialConstructorChecks?: boolean
                $assertionsDisabled?: boolean
            }


            export interface SoleInstance{
            }


            export interface LangReflectAccess{
            }


            export 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
            }


            export interface Clazz1{
            }


            export interface ReturnType{
            }


            export interface Result10{
            }


            export interface Result11{
            }


            export interface GenericInfo1{
                returnType?: ReturnType1
                parameterTypes?: Array<Result12>
                exceptionTypes?: Array<Result13>
                typeParameters?: Array<Result14>
                factory?: Factory1
                tree?: Tree1
            }


            export interface ReturnType1{
            }


            export interface Result12{
            }


            export interface Result13{
            }


            export interface Result14{
            }


            export interface Factory1{
            }


            export interface Tree1{
            }


            export interface Result15{
            }


            export interface Result16{
            }


            export interface Result17{
            }


            export interface MethodAccessor{
            }


            export interface Root1{
            }


            export interface Result18{
            }


            export interface DeclaredAnnotations1{
            }


            export interface ReflectionFactory1{
            }


            export interface SecurityCheckCache{
            }


            export interface SecurityCheckCache1{
            }


            export interface ParameterTypeCache{
            }


            export interface ParameterClassCache{
            }


            export interface DeclaredAnnotations2{
            }


            export interface DeclaredAnnotations3{
            }


            export interface ReflectionFactory2{
            }


            export interface SecurityCheckCache2{
            }


            export interface NewInstanceCallerCache{
            }


            export 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
            }


            export interface Layer{
                eMPTY_LAYER?: EMPTY_LAYER
                cf?: Cf
                parents?: Array<any>
                nameToModule?: NameToModule1
                allLayers?: Array<any>
                modules?: Modules1
                servicesCatalog?: ServicesCatalog
                cLV?: CLV1
            }


            export interface EMPTY_LAYER{
            }


            export interface Cf{
                eMPTY_CONFIGURATION?: EMPTY_CONFIGURATION
                parents?: Array<any>
                graph?: Graph
                modules?: Modules
                nameToModule?: NameToModule
                targetPlatform?: string
                allConfigurations?: Array<any>
                $assertionsDisabled?: boolean
            }


            export interface EMPTY_CONFIGURATION{
            }


            export interface Graph{
            }


            export interface Modules{
            }


            export interface NameToModule{
            }


            export interface NameToModule1{
            }


            export interface Modules1{
            }


            export interface ServicesCatalog{
                map?: Map3
                cLV?: CLV
            }


            export interface Map3{
            }


            export interface CLV{
                jLA?: JLA
            }


            export interface JLA{
            }


            export interface CLV1{
            }


            export 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
            }


            export interface Parent{
            }


            export interface UnnamedModule{
            }


            export 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
            }


            export interface Result19{
            }


            export interface Result20{
                hash?: number
                key?: Key
                val?: Val
                next?: Next1
            }


            export interface Key{
            }


            export interface Val{
            }


            export interface Next1{
            }


            export interface Result21{
                value?: number
            }


            export interface KeySet{
                serialVersionUID?: number
                value?: Value
                map?: Map4
                OOME_MSG?: string
            }


            export interface Value{
            }


            export interface Map4{
            }


            export interface Values{
                serialVersionUID?: number
                map?: Map5
                OOME_MSG?: string
            }


            export interface Map5{
            }


            export interface EntrySet{
                serialVersionUID?: number
                map?: Map6
                OOME_MSG?: string
            }


            export interface Map6{
            }


            export 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
            }


            export interface TheUnsafe{
            }


            export interface KeySet1{
            }


            export interface Values1{
            }


            export interface Package2certs{
            }


            export interface Result22{
                serialVersionUID?: number
                type?: string
                hash?: number
            }


            export interface DefaultDomain{
                filePermCompatInPD?: boolean
                codesource?: Codesource
                classloader?: Classloader
                principals?: Array<Result34>
                permissions?: Permissions
                hasAllPerm?: boolean
                staticPermissions?: boolean
                key?: Key2
            }


            export interface Codesource{
                serialVersionUID?: number
                location?: Location
                signers?: Array<Result26>
                certs?: Array<Result27>
                sp?: Sp
                factory?: Factory3
                locationNoFragString?: string
            }


            export 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>
            }


            export 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>
            }


            export interface Holder{
                originalHostName?: string
                hostName?: string
                address?: number
                family?: number
            }


            export interface NameService{
            }


            export interface Cache{
            }


            export interface ExpirySet{
            }


            export interface Impl{
            }


            export interface CachedLocalHost{
                host?: string
                addr?: Addr
                expiryTime?: number
            }


            export interface Addr{
            }


            export interface UNSAFE{
            }


            export interface Result23{
            }


            export interface Handler{
            }


            export interface TempState{
                protocol?: string
                host?: string
                port?: number
                authority?: string
                file?: string
                ref?: string
                hashCode?: number
            }


            export interface Factory2{
            }


            export interface DefaultFactory{
            }


            export interface Gate{
                threadLocalHashCode?: number
                nextHashCode?: NextHashCode
                HASH_INCREMENT?: number
            }


            export interface NextHashCode{
                serialVersionUID?: number
                u?: U1
                VALUE?: number
                value?: number
            }


            export interface U1{
            }


            export 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
            }


            export interface Result24{
                hash?: number
                key?: Key1
                value?: Value1
                next?: Next2
            }


            export interface Key1{
            }


            export interface Value1{
            }


            export interface Next2{
            }


            export interface KeySet2{
            }


            export interface EntrySet1{
            }


            export interface Values2{
            }


            export interface StreamHandlerLock{
            }


            export interface Result25{
            }


            export interface Result26{
                serialVersionUID?: number
                signerCertPath?: SignerCertPath
                timestamp?: Timestamp
                myhash?: number
            }


            export interface SignerCertPath{
                serialVersionUID?: number
                type?: string
            }


            export interface Timestamp{
                serialVersionUID?: number
                timestamp?: Date
                signerCertPath?: SignerCertPath1
                myhash?: number
            }


            export interface SignerCertPath1{
            }


            export interface Result27{
            }


            export 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
            }


            export interface Result28{
            }


            export interface Debug{
                prefix?: string
                args?: string
                hexDigits?: Array<Result29>
            }


            export interface Result29{
            }


            export interface Factory3{
                type?: string
                provider?: Provider
                certFacSpi?: CertFacSpi
            }


            export 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
            }


            export interface Debug1{
            }


            export interface EntrySet2{
            }


            export interface LegacyStrings{
            }


            export interface ServiceMap{
            }


            export interface PrngAlgos{
            }


            export interface LegacyMap{
            }


            export interface ServiceSet{
            }


            export interface PreviousKey{
                type?: string
                algorithm?: string
                originalAlgorithm?: string
            }


            export interface KnownEngines{
            }


            export interface UNSAFE1{
            }


            export 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
            }


            export interface UNSAFE2{
            }


            export interface Defaults1{
            }


            export interface Map7{
            }


            export interface Result30{
            }


            export interface Result31{
            }


            export interface KeySet3{
            }


            export interface EntrySet3{
            }


            export interface Values3{
            }


            export interface Map8{
            }


            export interface Result32{
            }


            export interface Result33{
            }


            export interface KeySet4{
            }


            export interface EntrySet4{
            }


            export interface Values4{
            }


            export interface CertFacSpi{
            }


            export interface Classloader{
            }


            export interface Result34{
            }


            export interface Permissions{
                serialVersionUID?: number
                readOnly?: boolean
            }


            export interface Key2{
                this$0?: This$0
            }


            export interface This$0{
            }


            export interface Packages{
            }


            export interface Scl{
            }


            export interface LoadedLibraryNames{
            }


            export interface SystemNativeLibraries{
            }


            export interface NativeLibraries{
            }


            export interface AssertionLock{
            }


            export interface PackageAssertionStatus{
            }


            export interface ClassAssertionStatus{
            }


            export interface ClassLoaderValueMap{
            }


            export 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
            }


            export interface Version{
                version?: string
                sequence?: Array<any>
                pre?: Array<any>
                build?: Array<any>
            }


            export interface Modifiers{
            }


            export interface Requires{
            }


            export interface Exports{
            }


            export interface Opens{
            }


            export interface Uses{
            }


            export interface Provides{
            }


            export interface Packages1{
            }


            export interface ALL_UNNAMED_MODULE{
            }


            export interface ALL_UNNAMED_MODULE_SET{
            }


            export interface EVERYONE_MODULE{
            }


            export interface EVERYONE_SET{
            }


            export interface Reads{
            }


            export interface OpenPackages{
            }


            export interface ExportedPackages{
            }


            export interface ModuleInfoClass{
            }


            export interface ComponentType{
            }


            export interface AllPermDomain{
            }


            export interface ReflectionData{
                clock?: number
                timestamp?: number
                referent?: Referent1
                queue?: Queue3
                next?: Next3
                discovered?: Discovered1
                processPendingLock?: ProcessPendingLock1
                processPendingActive?: boolean
            }


            export interface Referent1{
            }


            export interface Queue3{
            }


            export interface Next3{
            }


            export interface Discovered1{
            }


            export interface ProcessPendingLock1{
            }


            export interface GenericInfo2{
                nONE?: NONE
                superclass?: Superclass
                superInterfaces?: Array<Result35>
                typeParameters?: Array<Result36>
                factory?: Factory4
                tree?: Tree2
            }


            export interface NONE{
            }


            export interface Superclass{
            }


            export interface Result35{
            }


            export interface Result36{
            }


            export interface Factory4{
            }


            export interface Tree2{
            }


            export interface Result37{
            }


            export interface Result38{
            }


            export interface ReflectionFactory3{
            }


            export interface Result39{
            }


            export interface EnumConstantDirectory{
            }


            export interface AnnotationData{
                annotations?: Annotations
                declaredAnnotations?: DeclaredAnnotations4
                redefinedCount?: number
            }


            export interface Annotations{
            }


            export interface DeclaredAnnotations4{
            }


            export interface AnnotationType{
                memberTypes?: MemberTypes
                memberDefaults?: MemberDefaults
                members?: Members
                retention?: Retention
                inherited?: boolean
                $assertionsDisabled?: boolean
            }


            export interface MemberTypes{
            }


            export interface MemberDefaults{
            }


            export interface Members{
            }


            export interface Retention{
                sOURCE?: SOURCE
                cLASS?: CLASS
                rUNTIME?: RUNTIME
                $VALUES?: Array<Result40>
                name?: string
                ordinal?: number
            }


            export interface SOURCE{
            }


            export interface CLASS{
            }


            export interface RUNTIME{
            }


            export interface Result40{
            }


            export 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
            }


            export interface Result41{
                value?: Value2
                dEAD_ENTRY?: DEAD_ENTRY
                $assertionsDisabled?: boolean
                referent?: Referent2
                queue?: Queue4
                next?: Next4
                discovered?: Discovered2
                processPendingLock?: ProcessPendingLock2
                processPendingActive?: boolean
            }


            export interface Value2{
            }


            export interface DEAD_ENTRY{
            }


            export interface Referent2{
            }


            export interface Queue4{
            }


            export interface Next4{
            }


            export interface Discovered2{
            }


            export interface ProcessPendingLock2{
            }


            export interface Queue5{
            }


            export interface NULL_KEY{
            }


            export interface EntrySet5{
            }


            export interface KeySet5{
            }


            export interface Values5{
            }


            export 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
            }


            export interface Clazz2{
            }


            export interface Type1{
            }


            export interface GenericInfo3{
                genericType?: GenericType
                factory?: Factory5
                tree?: Tree3
            }


            export interface GenericType{
            }


            export interface Factory5{
            }


            export interface Tree3{
            }


            export interface Result42{
            }


            export interface FieldAccessor{
            }


            export interface OverrideFieldAccessor{
            }


            export interface Root2{
            }


            export interface DeclaredAnnotations5{
            }


            export interface ReflectionFactory4{
            }


            export interface SecurityCheckCache3{
            }


            export interface Result43{
            }


            export interface BytesLocal{
            }


            export interface CharsLocal{
            }


        }
        export namespace $results {
            export interface Result{
                resCode?: string
                msg?: string
                data?: string
            }


        }



    export type Parameters = $parameters.JsonObject

    export type Result = $results.Result
}

export type Parameters = PostPayFeeInfoDeclare.Parameters
export type Result = PostPayFeeInfoDeclare.Result
