declare namespace _default {
    let $schema: string;
    let $comment: string;
    namespace definitions {
        namespace ScreenerResultBase {
            let type: string;
            namespace properties {
                namespace id {
                    let type_1: string;
                    export { type_1 as type };
                }
                namespace title {
                    let type_2: string;
                    export { type_2 as type };
                }
                namespace description {
                    let type_3: string;
                    export { type_3 as type };
                }
                namespace canonicalName {
                    let type_4: string;
                    export { type_4 as type };
                }
                namespace criteriaMeta {
                    let $ref: string;
                }
                namespace rawCriteria {
                    let type_5: string;
                    export { type_5 as type };
                }
                namespace start {
                    let type_6: string;
                    export { type_6 as type };
                }
                namespace count {
                    let type_7: string;
                    export { type_7 as type };
                }
                namespace total {
                    let type_8: string;
                    export { type_8 as type };
                }
                namespace quotes {
                    let type_9: string;
                    export { type_9 as type };
                    export namespace items {
                        let $ref_1: string;
                        export { $ref_1 as $ref };
                    }
                }
                namespace useRecords {
                    let type_10: string;
                    export { type_10 as type };
                }
                namespace predefinedScr {
                    let type_11: string;
                    export { type_11 as type };
                }
                namespace versionId {
                    let type_12: string;
                    export { type_12 as type };
                }
                namespace creationDate {
                    let type_13: string;
                    export { type_13 as type };
                }
                namespace lastUpdated {
                    let type_14: string;
                    export { type_14 as type };
                }
                namespace isPremium {
                    let type_15: string;
                    export { type_15 as type };
                }
                namespace iconUrl {
                    let type_16: string;
                    export { type_16 as type };
                }
            }
            let required: string[];
            let additionalProperties: boolean;
        }
        namespace ScreenerCriteriaMeta {
            let type_17: string;
            export { type_17 as type };
            export namespace properties_1 {
                namespace size {
                    let type_18: string;
                    export { type_18 as type };
                }
                namespace offset {
                    let type_19: string;
                    export { type_19 as type };
                }
                namespace sortField {
                    let type_20: string;
                    export { type_20 as type };
                }
                namespace sortType {
                    let type_21: string;
                    export { type_21 as type };
                }
                namespace quoteType {
                    let type_22: string;
                    export { type_22 as type };
                }
                namespace criteria {
                    let type_23: string;
                    export { type_23 as type };
                    export namespace items_1 {
                        let $ref_2: string;
                        export { $ref_2 as $ref };
                    }
                    export { items_1 as items };
                }
                namespace topOperator {
                    let type_24: string;
                    export { type_24 as type };
                }
            }
            export { properties_1 as properties };
            let required_1: string[];
            export { required_1 as required };
            let additionalProperties_1: boolean;
            export { additionalProperties_1 as additionalProperties };
        }
        namespace ScreenerCriterum {
            let type_25: string;
            export { type_25 as type };
            export namespace properties_2 {
                namespace field {
                    let type_26: string;
                    export { type_26 as type };
                }
                namespace operators {
                    let type_27: string;
                    export { type_27 as type };
                    export namespace items_2 {
                        let type_28: string;
                        export { type_28 as type };
                    }
                    export { items_2 as items };
                }
                namespace values {
                    let type_29: string;
                    export { type_29 as type };
                    export namespace items_3 {
                        let type_30: string[];
                        export { type_30 as type };
                    }
                    export { items_3 as items };
                }
                namespace labelsSelected {
                    let type_31: string;
                    export { type_31 as type };
                    export namespace items_4 {
                        let type_32: string;
                        export { type_32 as type };
                    }
                    export { items_4 as items };
                }
                namespace dependentValues {
                    let type_33: string;
                    export { type_33 as type };
                    let items_5: {};
                    export { items_5 as items };
                }
                namespace subField {
                    let type_34: string;
                    export { type_34 as type };
                }
            }
            export { properties_2 as properties };
            let required_2: string[];
            export { required_2 as required };
            let additionalProperties_2: boolean;
            export { additionalProperties_2 as additionalProperties };
        }
        namespace ScreenerQuote {
            let type_35: string;
            export { type_35 as type };
            export namespace properties_3 {
                export namespace language {
                    let type_36: string;
                    export { type_36 as type };
                }
                export namespace region {
                    let type_37: string;
                    export { type_37 as type };
                }
                export namespace quoteType_1 {
                    let type_38: string;
                    export { type_38 as type };
                }
                export { quoteType_1 as quoteType };
                export namespace typeDisp {
                    let type_39: string;
                    export { type_39 as type };
                }
                export namespace quoteSourceName {
                    let type_40: string;
                    export { type_40 as type };
                }
                export namespace triggerable {
                    let type_41: string;
                    export { type_41 as type };
                }
                export namespace customPriceAlertConfidence {
                    let type_42: string;
                    export { type_42 as type };
                }
                export namespace lastCloseTevEbitLtm {
                    let type_43: string;
                    export { type_43 as type };
                }
                export namespace lastClosePriceToNNWCPerShare {
                    let type_44: string;
                    export { type_44 as type };
                }
                export namespace firstTradeDateMilliseconds {
                    let type_45: string;
                    export { type_45 as type };
                }
                export namespace priceHint {
                    let type_46: string;
                    export { type_46 as type };
                }
                export namespace postMarketChangePercent {
                    let type_47: string;
                    export { type_47 as type };
                }
                export namespace postMarketTime {
                    let type_48: string;
                    export { type_48 as type };
                }
                export namespace postMarketPrice {
                    let type_49: string;
                    export { type_49 as type };
                }
                export namespace postMarketChange {
                    let type_50: string;
                    export { type_50 as type };
                }
                export namespace regularMarketChange {
                    let type_51: string;
                    export { type_51 as type };
                }
                export namespace regularMarketTime {
                    let type_52: string;
                    export { type_52 as type };
                }
                export namespace regularMarketPrice {
                    let type_53: string;
                    export { type_53 as type };
                }
                export namespace regularMarketDayHigh {
                    let type_54: string;
                    export { type_54 as type };
                }
                export namespace regularMarketDayRange {
                    let type_55: string;
                    export { type_55 as type };
                }
                export namespace currency {
                    let type_56: string;
                    export { type_56 as type };
                }
                export namespace regularMarketDayLow {
                    let type_57: string;
                    export { type_57 as type };
                }
                export namespace regularMarketVolume {
                    let type_58: string;
                    export { type_58 as type };
                }
                export namespace regularMarketPreviousClose {
                    let type_59: string;
                    export { type_59 as type };
                }
                export namespace bid {
                    let type_60: string;
                    export { type_60 as type };
                }
                export namespace ask {
                    let type_61: string;
                    export { type_61 as type };
                }
                export namespace bidSize {
                    let type_62: string;
                    export { type_62 as type };
                }
                export namespace askSize {
                    let type_63: string;
                    export { type_63 as type };
                }
                export namespace market {
                    let type_64: string;
                    export { type_64 as type };
                }
                export namespace messageBoardId {
                    let type_65: string;
                    export { type_65 as type };
                }
                export namespace fullExchangeName {
                    let type_66: string;
                    export { type_66 as type };
                }
                export namespace longName {
                    let type_67: string;
                    export { type_67 as type };
                }
                export namespace financialCurrency {
                    let type_68: string;
                    export { type_68 as type };
                }
                export namespace regularMarketOpen {
                    let type_69: string;
                    export { type_69 as type };
                }
                export namespace averageDailyVolume3Month {
                    let type_70: string;
                    export { type_70 as type };
                }
                export namespace averageDailyVolume10Day {
                    let type_71: string;
                    export { type_71 as type };
                }
                export namespace fiftyTwoWeekLowChange {
                    let type_72: string;
                    export { type_72 as type };
                }
                export namespace fiftyTwoWeekLowChangePercent {
                    let type_73: string;
                    export { type_73 as type };
                }
                export namespace fiftyTwoWeekRange {
                    let type_74: string;
                    export { type_74 as type };
                }
                export namespace fiftyTwoWeekHighChange {
                    let type_75: string;
                    export { type_75 as type };
                }
                export namespace fiftyTwoWeekHighChangePercent {
                    let type_76: string;
                    export { type_76 as type };
                }
                export namespace fiftyTwoWeekChangePercent {
                    let type_77: string;
                    export { type_77 as type };
                }
                export namespace earningsTimestamp {
                    let type_78: string;
                    export { type_78 as type };
                }
                export namespace earningsTimestampStart {
                    let type_79: string;
                    export { type_79 as type };
                }
                export namespace earningsTimestampEnd {
                    let type_80: string;
                    export { type_80 as type };
                }
                export namespace trailingAnnualDividendRate {
                    let type_81: string;
                    export { type_81 as type };
                }
                export namespace trailingAnnualDividendYield {
                    let type_82: string;
                    export { type_82 as type };
                }
                export namespace marketState {
                    let type_83: string;
                    export { type_83 as type };
                }
                export namespace epsTrailingTwelveMonths {
                    let type_84: string;
                    export { type_84 as type };
                }
                export namespace epsForward {
                    let type_85: string;
                    export { type_85 as type };
                }
                export namespace epsCurrentYear {
                    let type_86: string;
                    export { type_86 as type };
                }
                export namespace priceEpsCurrentYear {
                    let type_87: string;
                    export { type_87 as type };
                }
                export namespace sharesOutstanding {
                    let type_88: string;
                    export { type_88 as type };
                }
                export namespace bookValue {
                    let type_89: string;
                    export { type_89 as type };
                }
                export namespace fiftyDayAverage {
                    let type_90: string;
                    export { type_90 as type };
                }
                export namespace fiftyDayAverageChange {
                    let type_91: string;
                    export { type_91 as type };
                }
                export namespace fiftyDayAverageChangePercent {
                    let type_92: string;
                    export { type_92 as type };
                }
                export namespace twoHundredDayAverage {
                    let type_93: string;
                    export { type_93 as type };
                }
                export namespace twoHundredDayAverageChange {
                    let type_94: string;
                    export { type_94 as type };
                }
                export namespace twoHundredDayAverageChangePercent {
                    let type_95: string;
                    export { type_95 as type };
                }
                export namespace marketCap {
                    let type_96: string;
                    export { type_96 as type };
                }
                export namespace forwardPE {
                    let type_97: string;
                    export { type_97 as type };
                }
                export namespace priceToBook {
                    let type_98: string;
                    export { type_98 as type };
                }
                export namespace sourceInterval {
                    let type_99: string;
                    export { type_99 as type };
                }
                export namespace exchangeDataDelayedBy {
                    let type_100: string;
                    export { type_100 as type };
                }
                export namespace exchangeTimezoneName {
                    let type_101: string;
                    export { type_101 as type };
                }
                export namespace exchangeTimezoneShortName {
                    let type_102: string;
                    export { type_102 as type };
                }
                export namespace gmtOffSetMilliseconds {
                    let type_103: string;
                    export { type_103 as type };
                }
                export namespace esgPopulated {
                    let type_104: string;
                    export { type_104 as type };
                }
                export namespace tradeable {
                    let type_105: string;
                    export { type_105 as type };
                }
                export namespace cryptoTradeable {
                    let type_106: string;
                    export { type_106 as type };
                }
                export namespace exchange {
                    let type_107: string;
                    export { type_107 as type };
                }
                export namespace fiftyTwoWeekLow {
                    let type_108: string;
                    export { type_108 as type };
                }
                export namespace fiftyTwoWeekHigh {
                    let type_109: string;
                    export { type_109 as type };
                }
                export namespace shortName {
                    let type_110: string;
                    export { type_110 as type };
                }
                export namespace averageAnalystRating {
                    let type_111: string;
                    export { type_111 as type };
                }
                export namespace regularMarketChangePercent {
                    let type_112: string;
                    export { type_112 as type };
                }
                export namespace symbol {
                    let type_113: string;
                    export { type_113 as type };
                }
                export namespace dividendDate {
                    let type_114: string;
                    export { type_114 as type };
                }
                export namespace displayName {
                    let type_115: string;
                    export { type_115 as type };
                }
                export namespace trailingPE {
                    let type_116: string;
                    export { type_116 as type };
                }
                export namespace prevName {
                    let type_117: string;
                    export { type_117 as type };
                }
                export namespace nameChangeDate {
                    let type_118: string;
                    export { type_118 as type };
                }
                export namespace ipoExpectedDate {
                    let type_119: string;
                    export { type_119 as type };
                }
                export namespace dividendYield {
                    let type_120: string;
                    export { type_120 as type };
                }
                export namespace dividendRate {
                    let type_121: string;
                    export { type_121 as type };
                }
                export namespace yieldTTM {
                    let type_122: string;
                    export { type_122 as type };
                }
                export namespace peTTM {
                    let type_123: string;
                    export { type_123 as type };
                }
                export namespace annualReturnNavY3 {
                    let type_124: string;
                    export { type_124 as type };
                }
                export namespace annualReturnNavY5 {
                    let type_125: string;
                    export { type_125 as type };
                }
                export namespace ytdReturn {
                    let type_126: string;
                    export { type_126 as type };
                }
                export namespace trailingThreeMonthReturns {
                    let type_127: string;
                    export { type_127 as type };
                }
                export namespace netAssets {
                    let type_128: string;
                    export { type_128 as type };
                }
                export namespace netExpenseRatio {
                    let type_129: string;
                    export { type_129 as type };
                }
                export namespace hasPrePostMarketData {
                    let type_130: string;
                    export { type_130 as type };
                }
                export namespace corporateActions {
                    let type_131: string;
                    export { type_131 as type };
                    let items_6: {};
                    export { items_6 as items };
                }
                export namespace earningsCallTimestampStart {
                    let type_132: string;
                    export { type_132 as type };
                    export let format: string;
                }
                export namespace earningsCallTimestampEnd {
                    let type_133: string;
                    export { type_133 as type };
                    let format_1: string;
                    export { format_1 as format };
                }
                export namespace isEarningsDateEstimate {
                    let type_134: string;
                    export { type_134 as type };
                }
                export namespace preMarketChange {
                    let type_135: string;
                    export { type_135 as type };
                }
                export namespace preMarketChangePercent {
                    let type_136: string;
                    export { type_136 as type };
                }
                export namespace preMarketTime {
                    let type_137: string;
                    export { type_137 as type };
                    let format_2: string;
                    export { format_2 as format };
                }
                export namespace preMarketPrice {
                    let type_138: string;
                    export { type_138 as type };
                }
            }
            export { properties_3 as properties };
            let required_3: string[];
            export { required_3 as required };
            let additionalProperties_3: boolean;
            export { additionalProperties_3 as additionalProperties };
        }
        namespace ScreenerResultAggressiveSmallCaps {
            let type_139: string;
            export { type_139 as type };
            export namespace properties_4 {
                export namespace id_1 {
                    let type_140: string;
                    export { type_140 as type };
                }
                export { id_1 as id };
                export namespace title_1 {
                    let type_141: string;
                    export { type_141 as type };
                }
                export { title_1 as title };
                export namespace description_1 {
                    let type_142: string;
                    export { type_142 as type };
                }
                export { description_1 as description };
                export namespace canonicalName_1 {
                    let type_143: string;
                    export { type_143 as type };
                    let _const: string;
                    export { _const as const };
                }
                export { canonicalName_1 as canonicalName };
                export namespace criteriaMeta_1 {
                    let type_144: string;
                    export { type_144 as type };
                    let additionalProperties_4: boolean;
                    export { additionalProperties_4 as additionalProperties };
                    export namespace properties_5 {
                        export namespace includeFields {
                            let type_145: string;
                            export { type_145 as type };
                            export namespace items_7 {
                                let type_146: string;
                                export { type_146 as type };
                                let _enum: string[];
                                export { _enum as enum };
                            }
                            export { items_7 as items };
                        }
                        export namespace size_1 {
                            let type_147: string;
                            export { type_147 as type };
                        }
                        export { size_1 as size };
                        export namespace offset_1 {
                            let type_148: string;
                            export { type_148 as type };
                        }
                        export { offset_1 as offset };
                        export namespace sortField_1 {
                            let type_149: string;
                            export { type_149 as type };
                        }
                        export { sortField_1 as sortField };
                        export namespace sortType_1 {
                            let type_150: string;
                            export { type_150 as type };
                        }
                        export { sortType_1 as sortType };
                        export namespace quoteType_2 {
                            let type_151: string;
                            export { type_151 as type };
                        }
                        export { quoteType_2 as quoteType };
                        export namespace criteria_1 {
                            let type_152: string;
                            export { type_152 as type };
                            export namespace items_8 {
                                let $ref_3: string;
                                export { $ref_3 as $ref };
                            }
                            export { items_8 as items };
                        }
                        export { criteria_1 as criteria };
                        export namespace topOperator_1 {
                            let type_153: string;
                            export { type_153 as type };
                        }
                        export { topOperator_1 as topOperator };
                    }
                    export { properties_5 as properties };
                    let required_4: string[];
                    export { required_4 as required };
                }
                export { criteriaMeta_1 as criteriaMeta };
                export namespace rawCriteria_1 {
                    let type_154: string;
                    export { type_154 as type };
                }
                export { rawCriteria_1 as rawCriteria };
                export namespace start_1 {
                    let type_155: string;
                    export { type_155 as type };
                }
                export { start_1 as start };
                export namespace count_1 {
                    let type_156: string;
                    export { type_156 as type };
                }
                export { count_1 as count };
                export namespace total_1 {
                    let type_157: string;
                    export { type_157 as type };
                }
                export { total_1 as total };
                export namespace quotes_1 {
                    let type_158: string;
                    export { type_158 as type };
                    export namespace items_9 {
                        let $ref_4: string;
                        export { $ref_4 as $ref };
                    }
                    export { items_9 as items };
                }
                export { quotes_1 as quotes };
                export namespace useRecords_1 {
                    let type_159: string;
                    export { type_159 as type };
                }
                export { useRecords_1 as useRecords };
                export namespace predefinedScr_1 {
                    let type_160: string;
                    export { type_160 as type };
                }
                export { predefinedScr_1 as predefinedScr };
                export namespace versionId_1 {
                    let type_161: string;
                    export { type_161 as type };
                }
                export { versionId_1 as versionId };
                export namespace creationDate_1 {
                    let type_162: string;
                    export { type_162 as type };
                }
                export { creationDate_1 as creationDate };
                export namespace lastUpdated_1 {
                    let type_163: string;
                    export { type_163 as type };
                }
                export { lastUpdated_1 as lastUpdated };
                export namespace isPremium_1 {
                    let type_164: string;
                    export { type_164 as type };
                }
                export { isPremium_1 as isPremium };
                export namespace iconUrl_1 {
                    let type_165: string;
                    export { type_165 as type };
                }
                export { iconUrl_1 as iconUrl };
            }
            export { properties_4 as properties };
            let required_5: string[];
            export { required_5 as required };
            let additionalProperties_5: boolean;
            export { additionalProperties_5 as additionalProperties };
        }
        namespace ScreenerCriteriaFieldsFund {
            let type_166: string;
            export { type_166 as type };
            let _enum_1: string[];
            export { _enum_1 as enum };
        }
        namespace ScreenerResultConservativeForeignFunds {
            let type_167: string;
            export { type_167 as type };
            export namespace properties_6 {
                export namespace id_2 {
                    let type_168: string;
                    export { type_168 as type };
                }
                export { id_2 as id };
                export namespace title_2 {
                    let type_169: string;
                    export { type_169 as type };
                }
                export { title_2 as title };
                export namespace description_2 {
                    let type_170: string;
                    export { type_170 as type };
                }
                export { description_2 as description };
                export namespace canonicalName_2 {
                    let type_171: string;
                    export { type_171 as type };
                    let _const_1: string;
                    export { _const_1 as const };
                }
                export { canonicalName_2 as canonicalName };
                export namespace criteriaMeta_2 {
                    let type_172: string;
                    export { type_172 as type };
                    let additionalProperties_6: boolean;
                    export { additionalProperties_6 as additionalProperties };
                    export namespace properties_7 {
                        export namespace includeFields_1 {
                            let type_173: string;
                            export { type_173 as type };
                            export namespace items_10 {
                                let $ref_5: string;
                                export { $ref_5 as $ref };
                            }
                            export { items_10 as items };
                        }
                        export { includeFields_1 as includeFields };
                        export namespace size_2 {
                            let type_174: string;
                            export { type_174 as type };
                        }
                        export { size_2 as size };
                        export namespace offset_2 {
                            let type_175: string;
                            export { type_175 as type };
                        }
                        export { offset_2 as offset };
                        export namespace sortField_2 {
                            let type_176: string;
                            export { type_176 as type };
                        }
                        export { sortField_2 as sortField };
                        export namespace sortType_2 {
                            let type_177: string;
                            export { type_177 as type };
                        }
                        export { sortType_2 as sortType };
                        export namespace quoteType_3 {
                            let type_178: string;
                            export { type_178 as type };
                        }
                        export { quoteType_3 as quoteType };
                        export namespace criteria_2 {
                            let type_179: string;
                            export { type_179 as type };
                            export namespace items_11 {
                                let $ref_6: string;
                                export { $ref_6 as $ref };
                            }
                            export { items_11 as items };
                        }
                        export { criteria_2 as criteria };
                        export namespace topOperator_2 {
                            let type_180: string;
                            export { type_180 as type };
                        }
                        export { topOperator_2 as topOperator };
                    }
                    export { properties_7 as properties };
                    let required_6: string[];
                    export { required_6 as required };
                }
                export { criteriaMeta_2 as criteriaMeta };
                export namespace rawCriteria_2 {
                    let type_181: string;
                    export { type_181 as type };
                }
                export { rawCriteria_2 as rawCriteria };
                export namespace start_2 {
                    let type_182: string;
                    export { type_182 as type };
                }
                export { start_2 as start };
                export namespace count_2 {
                    let type_183: string;
                    export { type_183 as type };
                }
                export { count_2 as count };
                export namespace total_2 {
                    let type_184: string;
                    export { type_184 as type };
                }
                export { total_2 as total };
                export namespace quotes_2 {
                    let type_185: string;
                    export { type_185 as type };
                    export namespace items_12 {
                        let $ref_7: string;
                        export { $ref_7 as $ref };
                    }
                    export { items_12 as items };
                }
                export { quotes_2 as quotes };
                export namespace useRecords_2 {
                    let type_186: string;
                    export { type_186 as type };
                }
                export { useRecords_2 as useRecords };
                export namespace predefinedScr_2 {
                    let type_187: string;
                    export { type_187 as type };
                }
                export { predefinedScr_2 as predefinedScr };
                export namespace versionId_2 {
                    let type_188: string;
                    export { type_188 as type };
                }
                export { versionId_2 as versionId };
                export namespace creationDate_2 {
                    let type_189: string;
                    export { type_189 as type };
                }
                export { creationDate_2 as creationDate };
                export namespace lastUpdated_2 {
                    let type_190: string;
                    export { type_190 as type };
                }
                export { lastUpdated_2 as lastUpdated };
                export namespace isPremium_2 {
                    let type_191: string;
                    export { type_191 as type };
                }
                export { isPremium_2 as isPremium };
                export namespace iconUrl_2 {
                    let type_192: string;
                    export { type_192 as type };
                }
                export { iconUrl_2 as iconUrl };
            }
            export { properties_6 as properties };
            let required_7: string[];
            export { required_7 as required };
            let additionalProperties_7: boolean;
            export { additionalProperties_7 as additionalProperties };
        }
        namespace ScreenerResultDayGainers {
            let type_193: string;
            export { type_193 as type };
            export namespace properties_8 {
                export namespace id_3 {
                    let type_194: string;
                    export { type_194 as type };
                }
                export { id_3 as id };
                export namespace title_3 {
                    let type_195: string;
                    export { type_195 as type };
                }
                export { title_3 as title };
                export namespace description_3 {
                    let type_196: string;
                    export { type_196 as type };
                }
                export { description_3 as description };
                export namespace canonicalName_3 {
                    let type_197: string;
                    export { type_197 as type };
                    let _const_2: string;
                    export { _const_2 as const };
                }
                export { canonicalName_3 as canonicalName };
                export namespace criteriaMeta_3 {
                    let type_198: string;
                    export { type_198 as type };
                    let additionalProperties_8: boolean;
                    export { additionalProperties_8 as additionalProperties };
                    export namespace properties_9 {
                        export namespace includeFields_2 {
                            let type_199: string;
                            export { type_199 as type };
                            export namespace items_13 {
                                let type_200: string;
                                export { type_200 as type };
                                let _enum_2: string[];
                                export { _enum_2 as enum };
                            }
                            export { items_13 as items };
                        }
                        export { includeFields_2 as includeFields };
                        export namespace size_3 {
                            let type_201: string;
                            export { type_201 as type };
                        }
                        export { size_3 as size };
                        export namespace offset_3 {
                            let type_202: string;
                            export { type_202 as type };
                        }
                        export { offset_3 as offset };
                        export namespace sortField_3 {
                            let type_203: string;
                            export { type_203 as type };
                        }
                        export { sortField_3 as sortField };
                        export namespace sortType_3 {
                            let type_204: string;
                            export { type_204 as type };
                        }
                        export { sortType_3 as sortType };
                        export namespace quoteType_4 {
                            let type_205: string;
                            export { type_205 as type };
                        }
                        export { quoteType_4 as quoteType };
                        export namespace criteria_3 {
                            let type_206: string;
                            export { type_206 as type };
                            export namespace items_14 {
                                let $ref_8: string;
                                export { $ref_8 as $ref };
                            }
                            export { items_14 as items };
                        }
                        export { criteria_3 as criteria };
                        export namespace topOperator_3 {
                            let type_207: string;
                            export { type_207 as type };
                        }
                        export { topOperator_3 as topOperator };
                    }
                    export { properties_9 as properties };
                    let required_8: string[];
                    export { required_8 as required };
                }
                export { criteriaMeta_3 as criteriaMeta };
                export namespace rawCriteria_3 {
                    let type_208: string;
                    export { type_208 as type };
                }
                export { rawCriteria_3 as rawCriteria };
                export namespace start_3 {
                    let type_209: string;
                    export { type_209 as type };
                }
                export { start_3 as start };
                export namespace count_3 {
                    let type_210: string;
                    export { type_210 as type };
                }
                export { count_3 as count };
                export namespace total_3 {
                    let type_211: string;
                    export { type_211 as type };
                }
                export { total_3 as total };
                export namespace quotes_3 {
                    let type_212: string;
                    export { type_212 as type };
                    export namespace items_15 {
                        let $ref_9: string;
                        export { $ref_9 as $ref };
                    }
                    export { items_15 as items };
                }
                export { quotes_3 as quotes };
                export namespace useRecords_3 {
                    let type_213: string;
                    export { type_213 as type };
                }
                export { useRecords_3 as useRecords };
                export namespace predefinedScr_3 {
                    let type_214: string;
                    export { type_214 as type };
                }
                export { predefinedScr_3 as predefinedScr };
                export namespace versionId_3 {
                    let type_215: string;
                    export { type_215 as type };
                }
                export { versionId_3 as versionId };
                export namespace creationDate_3 {
                    let type_216: string;
                    export { type_216 as type };
                }
                export { creationDate_3 as creationDate };
                export namespace lastUpdated_3 {
                    let type_217: string;
                    export { type_217 as type };
                }
                export { lastUpdated_3 as lastUpdated };
                export namespace isPremium_3 {
                    let type_218: string;
                    export { type_218 as type };
                }
                export { isPremium_3 as isPremium };
                export namespace iconUrl_3 {
                    let type_219: string;
                    export { type_219 as type };
                }
                export { iconUrl_3 as iconUrl };
            }
            export { properties_8 as properties };
            let required_9: string[];
            export { required_9 as required };
            let additionalProperties_9: boolean;
            export { additionalProperties_9 as additionalProperties };
        }
        namespace ScreenerResultDayLosers {
            let type_220: string;
            export { type_220 as type };
            export namespace properties_10 {
                export namespace id_4 {
                    let type_221: string;
                    export { type_221 as type };
                }
                export { id_4 as id };
                export namespace title_4 {
                    let type_222: string;
                    export { type_222 as type };
                }
                export { title_4 as title };
                export namespace description_4 {
                    let type_223: string;
                    export { type_223 as type };
                }
                export { description_4 as description };
                export namespace canonicalName_4 {
                    let type_224: string;
                    export { type_224 as type };
                    let _const_3: string;
                    export { _const_3 as const };
                }
                export { canonicalName_4 as canonicalName };
                export namespace criteriaMeta_4 {
                    let type_225: string;
                    export { type_225 as type };
                    let additionalProperties_10: boolean;
                    export { additionalProperties_10 as additionalProperties };
                    export namespace properties_11 {
                        export namespace includeFields_3 {
                            let type_226: string;
                            export { type_226 as type };
                            export namespace items_16 {
                                let type_227: string;
                                export { type_227 as type };
                                let _enum_3: string[];
                                export { _enum_3 as enum };
                            }
                            export { items_16 as items };
                        }
                        export { includeFields_3 as includeFields };
                        export namespace size_4 {
                            let type_228: string;
                            export { type_228 as type };
                        }
                        export { size_4 as size };
                        export namespace offset_4 {
                            let type_229: string;
                            export { type_229 as type };
                        }
                        export { offset_4 as offset };
                        export namespace sortField_4 {
                            let type_230: string;
                            export { type_230 as type };
                        }
                        export { sortField_4 as sortField };
                        export namespace sortType_4 {
                            let type_231: string;
                            export { type_231 as type };
                        }
                        export { sortType_4 as sortType };
                        export namespace quoteType_5 {
                            let type_232: string;
                            export { type_232 as type };
                        }
                        export { quoteType_5 as quoteType };
                        export namespace criteria_4 {
                            let type_233: string;
                            export { type_233 as type };
                            export namespace items_17 {
                                let $ref_10: string;
                                export { $ref_10 as $ref };
                            }
                            export { items_17 as items };
                        }
                        export { criteria_4 as criteria };
                        export namespace topOperator_4 {
                            let type_234: string;
                            export { type_234 as type };
                        }
                        export { topOperator_4 as topOperator };
                    }
                    export { properties_11 as properties };
                    let required_10: string[];
                    export { required_10 as required };
                }
                export { criteriaMeta_4 as criteriaMeta };
                export namespace rawCriteria_4 {
                    let type_235: string;
                    export { type_235 as type };
                }
                export { rawCriteria_4 as rawCriteria };
                export namespace start_4 {
                    let type_236: string;
                    export { type_236 as type };
                }
                export { start_4 as start };
                export namespace count_4 {
                    let type_237: string;
                    export { type_237 as type };
                }
                export { count_4 as count };
                export namespace total_4 {
                    let type_238: string;
                    export { type_238 as type };
                }
                export { total_4 as total };
                export namespace quotes_4 {
                    let type_239: string;
                    export { type_239 as type };
                    export namespace items_18 {
                        let $ref_11: string;
                        export { $ref_11 as $ref };
                    }
                    export { items_18 as items };
                }
                export { quotes_4 as quotes };
                export namespace useRecords_4 {
                    let type_240: string;
                    export { type_240 as type };
                }
                export { useRecords_4 as useRecords };
                export namespace predefinedScr_4 {
                    let type_241: string;
                    export { type_241 as type };
                }
                export { predefinedScr_4 as predefinedScr };
                export namespace versionId_4 {
                    let type_242: string;
                    export { type_242 as type };
                }
                export { versionId_4 as versionId };
                export namespace creationDate_4 {
                    let type_243: string;
                    export { type_243 as type };
                }
                export { creationDate_4 as creationDate };
                export namespace lastUpdated_4 {
                    let type_244: string;
                    export { type_244 as type };
                }
                export { lastUpdated_4 as lastUpdated };
                export namespace isPremium_4 {
                    let type_245: string;
                    export { type_245 as type };
                }
                export { isPremium_4 as isPremium };
                export namespace iconUrl_4 {
                    let type_246: string;
                    export { type_246 as type };
                }
                export { iconUrl_4 as iconUrl };
            }
            export { properties_10 as properties };
            let required_11: string[];
            export { required_11 as required };
            let additionalProperties_11: boolean;
            export { additionalProperties_11 as additionalProperties };
        }
        namespace ScreenerResultGrowthTechnologyStocks {
            let type_247: string;
            export { type_247 as type };
            export namespace properties_12 {
                export namespace id_5 {
                    let type_248: string;
                    export { type_248 as type };
                }
                export { id_5 as id };
                export namespace title_5 {
                    let type_249: string;
                    export { type_249 as type };
                }
                export { title_5 as title };
                export namespace description_5 {
                    let type_250: string;
                    export { type_250 as type };
                }
                export { description_5 as description };
                export namespace canonicalName_5 {
                    let type_251: string;
                    export { type_251 as type };
                    let _const_4: string;
                    export { _const_4 as const };
                }
                export { canonicalName_5 as canonicalName };
                export namespace criteriaMeta_5 {
                    let type_252: string;
                    export { type_252 as type };
                    let additionalProperties_12: boolean;
                    export { additionalProperties_12 as additionalProperties };
                    export namespace properties_13 {
                        export namespace includeFields_4 {
                            let type_253: string;
                            export { type_253 as type };
                            export namespace items_19 {
                                let type_254: string;
                                export { type_254 as type };
                                let _enum_4: string[];
                                export { _enum_4 as enum };
                            }
                            export { items_19 as items };
                        }
                        export { includeFields_4 as includeFields };
                        export namespace size_5 {
                            let type_255: string;
                            export { type_255 as type };
                        }
                        export { size_5 as size };
                        export namespace offset_5 {
                            let type_256: string;
                            export { type_256 as type };
                        }
                        export { offset_5 as offset };
                        export namespace sortField_5 {
                            let type_257: string;
                            export { type_257 as type };
                        }
                        export { sortField_5 as sortField };
                        export namespace sortType_5 {
                            let type_258: string;
                            export { type_258 as type };
                        }
                        export { sortType_5 as sortType };
                        export namespace quoteType_6 {
                            let type_259: string;
                            export { type_259 as type };
                        }
                        export { quoteType_6 as quoteType };
                        export namespace criteria_5 {
                            let type_260: string;
                            export { type_260 as type };
                            export namespace items_20 {
                                let $ref_12: string;
                                export { $ref_12 as $ref };
                            }
                            export { items_20 as items };
                        }
                        export { criteria_5 as criteria };
                        export namespace topOperator_5 {
                            let type_261: string;
                            export { type_261 as type };
                        }
                        export { topOperator_5 as topOperator };
                    }
                    export { properties_13 as properties };
                    let required_12: string[];
                    export { required_12 as required };
                }
                export { criteriaMeta_5 as criteriaMeta };
                export namespace rawCriteria_5 {
                    let type_262: string;
                    export { type_262 as type };
                }
                export { rawCriteria_5 as rawCriteria };
                export namespace start_5 {
                    let type_263: string;
                    export { type_263 as type };
                }
                export { start_5 as start };
                export namespace count_5 {
                    let type_264: string;
                    export { type_264 as type };
                }
                export { count_5 as count };
                export namespace total_5 {
                    let type_265: string;
                    export { type_265 as type };
                }
                export { total_5 as total };
                export namespace quotes_5 {
                    let type_266: string;
                    export { type_266 as type };
                    export namespace items_21 {
                        let $ref_13: string;
                        export { $ref_13 as $ref };
                    }
                    export { items_21 as items };
                }
                export { quotes_5 as quotes };
                export namespace useRecords_5 {
                    let type_267: string;
                    export { type_267 as type };
                }
                export { useRecords_5 as useRecords };
                export namespace predefinedScr_5 {
                    let type_268: string;
                    export { type_268 as type };
                }
                export { predefinedScr_5 as predefinedScr };
                export namespace versionId_5 {
                    let type_269: string;
                    export { type_269 as type };
                }
                export { versionId_5 as versionId };
                export namespace creationDate_5 {
                    let type_270: string;
                    export { type_270 as type };
                }
                export { creationDate_5 as creationDate };
                export namespace lastUpdated_5 {
                    let type_271: string;
                    export { type_271 as type };
                }
                export { lastUpdated_5 as lastUpdated };
                export namespace isPremium_5 {
                    let type_272: string;
                    export { type_272 as type };
                }
                export { isPremium_5 as isPremium };
                export namespace iconUrl_5 {
                    let type_273: string;
                    export { type_273 as type };
                }
                export { iconUrl_5 as iconUrl };
            }
            export { properties_12 as properties };
            let required_13: string[];
            export { required_13 as required };
            let additionalProperties_13: boolean;
            export { additionalProperties_13 as additionalProperties };
        }
        namespace ScreenerResultMostActives {
            let type_274: string;
            export { type_274 as type };
            export namespace properties_14 {
                export namespace id_6 {
                    let type_275: string;
                    export { type_275 as type };
                }
                export { id_6 as id };
                export namespace title_6 {
                    let type_276: string;
                    export { type_276 as type };
                }
                export { title_6 as title };
                export namespace description_6 {
                    let type_277: string;
                    export { type_277 as type };
                }
                export { description_6 as description };
                export namespace canonicalName_6 {
                    let type_278: string;
                    export { type_278 as type };
                    let _const_5: string;
                    export { _const_5 as const };
                }
                export { canonicalName_6 as canonicalName };
                export namespace criteriaMeta_6 {
                    let type_279: string;
                    export { type_279 as type };
                    let additionalProperties_14: boolean;
                    export { additionalProperties_14 as additionalProperties };
                    export namespace properties_15 {
                        export namespace includeFields_5 {
                            let type_280: string;
                            export { type_280 as type };
                            export namespace items_22 {
                                let type_281: string;
                                export { type_281 as type };
                                let _enum_5: string[];
                                export { _enum_5 as enum };
                            }
                            export { items_22 as items };
                        }
                        export { includeFields_5 as includeFields };
                        export namespace size_6 {
                            let type_282: string;
                            export { type_282 as type };
                        }
                        export { size_6 as size };
                        export namespace offset_6 {
                            let type_283: string;
                            export { type_283 as type };
                        }
                        export { offset_6 as offset };
                        export namespace sortField_6 {
                            let type_284: string;
                            export { type_284 as type };
                        }
                        export { sortField_6 as sortField };
                        export namespace sortType_6 {
                            let type_285: string;
                            export { type_285 as type };
                        }
                        export { sortType_6 as sortType };
                        export namespace quoteType_7 {
                            let type_286: string;
                            export { type_286 as type };
                        }
                        export { quoteType_7 as quoteType };
                        export namespace criteria_6 {
                            let type_287: string;
                            export { type_287 as type };
                            export namespace items_23 {
                                let $ref_14: string;
                                export { $ref_14 as $ref };
                            }
                            export { items_23 as items };
                        }
                        export { criteria_6 as criteria };
                        export namespace topOperator_6 {
                            let type_288: string;
                            export { type_288 as type };
                        }
                        export { topOperator_6 as topOperator };
                    }
                    export { properties_15 as properties };
                    let required_14: string[];
                    export { required_14 as required };
                }
                export { criteriaMeta_6 as criteriaMeta };
                export namespace rawCriteria_6 {
                    let type_289: string;
                    export { type_289 as type };
                }
                export { rawCriteria_6 as rawCriteria };
                export namespace start_6 {
                    let type_290: string;
                    export { type_290 as type };
                }
                export { start_6 as start };
                export namespace count_6 {
                    let type_291: string;
                    export { type_291 as type };
                }
                export { count_6 as count };
                export namespace total_6 {
                    let type_292: string;
                    export { type_292 as type };
                }
                export { total_6 as total };
                export namespace quotes_6 {
                    let type_293: string;
                    export { type_293 as type };
                    export namespace items_24 {
                        let $ref_15: string;
                        export { $ref_15 as $ref };
                    }
                    export { items_24 as items };
                }
                export { quotes_6 as quotes };
                export namespace useRecords_6 {
                    let type_294: string;
                    export { type_294 as type };
                }
                export { useRecords_6 as useRecords };
                export namespace predefinedScr_6 {
                    let type_295: string;
                    export { type_295 as type };
                }
                export { predefinedScr_6 as predefinedScr };
                export namespace versionId_6 {
                    let type_296: string;
                    export { type_296 as type };
                }
                export { versionId_6 as versionId };
                export namespace creationDate_6 {
                    let type_297: string;
                    export { type_297 as type };
                }
                export { creationDate_6 as creationDate };
                export namespace lastUpdated_6 {
                    let type_298: string;
                    export { type_298 as type };
                }
                export { lastUpdated_6 as lastUpdated };
                export namespace isPremium_6 {
                    let type_299: string;
                    export { type_299 as type };
                }
                export { isPremium_6 as isPremium };
                export namespace iconUrl_6 {
                    let type_300: string;
                    export { type_300 as type };
                }
                export { iconUrl_6 as iconUrl };
            }
            export { properties_14 as properties };
            let required_15: string[];
            export { required_15 as required };
            let additionalProperties_15: boolean;
            export { additionalProperties_15 as additionalProperties };
        }
        namespace ScreenerResultHighYieldBond {
            let type_301: string;
            export { type_301 as type };
            export namespace properties_16 {
                export namespace id_7 {
                    let type_302: string;
                    export { type_302 as type };
                }
                export { id_7 as id };
                export namespace title_7 {
                    let type_303: string;
                    export { type_303 as type };
                }
                export { title_7 as title };
                export namespace description_7 {
                    let type_304: string;
                    export { type_304 as type };
                }
                export { description_7 as description };
                export namespace canonicalName_7 {
                    let type_305: string;
                    export { type_305 as type };
                    let _const_6: string;
                    export { _const_6 as const };
                }
                export { canonicalName_7 as canonicalName };
                export namespace criteriaMeta_7 {
                    let type_306: string;
                    export { type_306 as type };
                    let additionalProperties_16: boolean;
                    export { additionalProperties_16 as additionalProperties };
                    export namespace properties_17 {
                        export namespace includeFields_6 {
                            let type_307: string;
                            export { type_307 as type };
                            export namespace items_25 {
                                let $ref_16: string;
                                export { $ref_16 as $ref };
                            }
                            export { items_25 as items };
                        }
                        export { includeFields_6 as includeFields };
                        export namespace size_7 {
                            let type_308: string;
                            export { type_308 as type };
                        }
                        export { size_7 as size };
                        export namespace offset_7 {
                            let type_309: string;
                            export { type_309 as type };
                        }
                        export { offset_7 as offset };
                        export namespace sortField_7 {
                            let type_310: string;
                            export { type_310 as type };
                        }
                        export { sortField_7 as sortField };
                        export namespace sortType_7 {
                            let type_311: string;
                            export { type_311 as type };
                        }
                        export { sortType_7 as sortType };
                        export namespace quoteType_8 {
                            let type_312: string;
                            export { type_312 as type };
                        }
                        export { quoteType_8 as quoteType };
                        export namespace criteria_7 {
                            let type_313: string;
                            export { type_313 as type };
                            export namespace items_26 {
                                let $ref_17: string;
                                export { $ref_17 as $ref };
                            }
                            export { items_26 as items };
                        }
                        export { criteria_7 as criteria };
                        export namespace topOperator_7 {
                            let type_314: string;
                            export { type_314 as type };
                        }
                        export { topOperator_7 as topOperator };
                    }
                    export { properties_17 as properties };
                    let required_16: string[];
                    export { required_16 as required };
                }
                export { criteriaMeta_7 as criteriaMeta };
                export namespace rawCriteria_7 {
                    let type_315: string;
                    export { type_315 as type };
                }
                export { rawCriteria_7 as rawCriteria };
                export namespace start_7 {
                    let type_316: string;
                    export { type_316 as type };
                }
                export { start_7 as start };
                export namespace count_7 {
                    let type_317: string;
                    export { type_317 as type };
                }
                export { count_7 as count };
                export namespace total_7 {
                    let type_318: string;
                    export { type_318 as type };
                }
                export { total_7 as total };
                export namespace quotes_7 {
                    let type_319: string;
                    export { type_319 as type };
                    export namespace items_27 {
                        let $ref_18: string;
                        export { $ref_18 as $ref };
                    }
                    export { items_27 as items };
                }
                export { quotes_7 as quotes };
                export namespace useRecords_7 {
                    let type_320: string;
                    export { type_320 as type };
                }
                export { useRecords_7 as useRecords };
                export namespace predefinedScr_7 {
                    let type_321: string;
                    export { type_321 as type };
                }
                export { predefinedScr_7 as predefinedScr };
                export namespace versionId_7 {
                    let type_322: string;
                    export { type_322 as type };
                }
                export { versionId_7 as versionId };
                export namespace creationDate_7 {
                    let type_323: string;
                    export { type_323 as type };
                }
                export { creationDate_7 as creationDate };
                export namespace lastUpdated_7 {
                    let type_324: string;
                    export { type_324 as type };
                }
                export { lastUpdated_7 as lastUpdated };
                export namespace isPremium_7 {
                    let type_325: string;
                    export { type_325 as type };
                }
                export { isPremium_7 as isPremium };
                export namespace iconUrl_7 {
                    let type_326: string;
                    export { type_326 as type };
                }
                export { iconUrl_7 as iconUrl };
            }
            export { properties_16 as properties };
            let required_17: string[];
            export { required_17 as required };
            let additionalProperties_17: boolean;
            export { additionalProperties_17 as additionalProperties };
        }
        namespace ScreenerResultMostShortedStocks {
            let type_327: string;
            export { type_327 as type };
            export namespace properties_18 {
                export namespace id_8 {
                    let type_328: string;
                    export { type_328 as type };
                }
                export { id_8 as id };
                export namespace title_8 {
                    let type_329: string;
                    export { type_329 as type };
                }
                export { title_8 as title };
                export namespace description_8 {
                    let type_330: string;
                    export { type_330 as type };
                }
                export { description_8 as description };
                export namespace canonicalName_8 {
                    let type_331: string;
                    export { type_331 as type };
                    let _const_7: string;
                    export { _const_7 as const };
                }
                export { canonicalName_8 as canonicalName };
                export namespace criteriaMeta_8 {
                    let type_332: string;
                    export { type_332 as type };
                    let additionalProperties_18: boolean;
                    export { additionalProperties_18 as additionalProperties };
                    export namespace properties_19 {
                        export namespace includeFields_7 {
                            let type_333: string;
                            export { type_333 as type };
                            export namespace items_28 {
                                let type_334: string;
                                export { type_334 as type };
                                let _enum_6: string[];
                                export { _enum_6 as enum };
                            }
                            export { items_28 as items };
                        }
                        export { includeFields_7 as includeFields };
                        export namespace size_8 {
                            let type_335: string;
                            export { type_335 as type };
                        }
                        export { size_8 as size };
                        export namespace offset_8 {
                            let type_336: string;
                            export { type_336 as type };
                        }
                        export { offset_8 as offset };
                        export namespace sortField_8 {
                            let type_337: string;
                            export { type_337 as type };
                        }
                        export { sortField_8 as sortField };
                        export namespace sortType_8 {
                            let type_338: string;
                            export { type_338 as type };
                        }
                        export { sortType_8 as sortType };
                        export namespace quoteType_9 {
                            let type_339: string;
                            export { type_339 as type };
                        }
                        export { quoteType_9 as quoteType };
                        export namespace criteria_8 {
                            let type_340: string;
                            export { type_340 as type };
                            export namespace items_29 {
                                let $ref_19: string;
                                export { $ref_19 as $ref };
                            }
                            export { items_29 as items };
                        }
                        export { criteria_8 as criteria };
                        export namespace topOperator_8 {
                            let type_341: string;
                            export { type_341 as type };
                        }
                        export { topOperator_8 as topOperator };
                    }
                    export { properties_19 as properties };
                    let required_18: string[];
                    export { required_18 as required };
                }
                export { criteriaMeta_8 as criteriaMeta };
                export namespace rawCriteria_8 {
                    let type_342: string;
                    export { type_342 as type };
                }
                export { rawCriteria_8 as rawCriteria };
                export namespace start_8 {
                    let type_343: string;
                    export { type_343 as type };
                }
                export { start_8 as start };
                export namespace count_8 {
                    let type_344: string;
                    export { type_344 as type };
                }
                export { count_8 as count };
                export namespace total_8 {
                    let type_345: string;
                    export { type_345 as type };
                }
                export { total_8 as total };
                export namespace quotes_8 {
                    let type_346: string;
                    export { type_346 as type };
                    export namespace items_30 {
                        let $ref_20: string;
                        export { $ref_20 as $ref };
                    }
                    export { items_30 as items };
                }
                export { quotes_8 as quotes };
                export namespace useRecords_8 {
                    let type_347: string;
                    export { type_347 as type };
                }
                export { useRecords_8 as useRecords };
                export namespace predefinedScr_8 {
                    let type_348: string;
                    export { type_348 as type };
                }
                export { predefinedScr_8 as predefinedScr };
                export namespace versionId_8 {
                    let type_349: string;
                    export { type_349 as type };
                }
                export { versionId_8 as versionId };
                export namespace creationDate_8 {
                    let type_350: string;
                    export { type_350 as type };
                }
                export { creationDate_8 as creationDate };
                export namespace lastUpdated_8 {
                    let type_351: string;
                    export { type_351 as type };
                }
                export { lastUpdated_8 as lastUpdated };
                export namespace isPremium_8 {
                    let type_352: string;
                    export { type_352 as type };
                }
                export { isPremium_8 as isPremium };
                export namespace iconUrl_8 {
                    let type_353: string;
                    export { type_353 as type };
                }
                export { iconUrl_8 as iconUrl };
            }
            export { properties_18 as properties };
            let required_19: string[];
            export { required_19 as required };
            let additionalProperties_19: boolean;
            export { additionalProperties_19 as additionalProperties };
        }
        namespace ScreenerResultPortfolioAnchors {
            let type_354: string;
            export { type_354 as type };
            export namespace properties_20 {
                export namespace id_9 {
                    let type_355: string;
                    export { type_355 as type };
                }
                export { id_9 as id };
                export namespace title_9 {
                    let type_356: string;
                    export { type_356 as type };
                }
                export { title_9 as title };
                export namespace description_9 {
                    let type_357: string;
                    export { type_357 as type };
                }
                export { description_9 as description };
                export namespace canonicalName_9 {
                    let type_358: string;
                    export { type_358 as type };
                    let _const_8: string;
                    export { _const_8 as const };
                }
                export { canonicalName_9 as canonicalName };
                export namespace criteriaMeta_9 {
                    let type_359: string;
                    export { type_359 as type };
                    let additionalProperties_20: boolean;
                    export { additionalProperties_20 as additionalProperties };
                    export namespace properties_21 {
                        export namespace includeFields_8 {
                            let type_360: string;
                            export { type_360 as type };
                            export namespace items_31 {
                                let $ref_21: string;
                                export { $ref_21 as $ref };
                            }
                            export { items_31 as items };
                        }
                        export { includeFields_8 as includeFields };
                        export namespace size_9 {
                            let type_361: string;
                            export { type_361 as type };
                        }
                        export { size_9 as size };
                        export namespace offset_9 {
                            let type_362: string;
                            export { type_362 as type };
                        }
                        export { offset_9 as offset };
                        export namespace sortField_9 {
                            let type_363: string;
                            export { type_363 as type };
                        }
                        export { sortField_9 as sortField };
                        export namespace sortType_9 {
                            let type_364: string;
                            export { type_364 as type };
                        }
                        export { sortType_9 as sortType };
                        export namespace quoteType_10 {
                            let type_365: string;
                            export { type_365 as type };
                        }
                        export { quoteType_10 as quoteType };
                        export namespace criteria_9 {
                            let type_366: string;
                            export { type_366 as type };
                            export namespace items_32 {
                                let $ref_22: string;
                                export { $ref_22 as $ref };
                            }
                            export { items_32 as items };
                        }
                        export { criteria_9 as criteria };
                        export namespace topOperator_9 {
                            let type_367: string;
                            export { type_367 as type };
                        }
                        export { topOperator_9 as topOperator };
                    }
                    export { properties_21 as properties };
                    let required_20: string[];
                    export { required_20 as required };
                }
                export { criteriaMeta_9 as criteriaMeta };
                export namespace rawCriteria_9 {
                    let type_368: string;
                    export { type_368 as type };
                }
                export { rawCriteria_9 as rawCriteria };
                export namespace start_9 {
                    let type_369: string;
                    export { type_369 as type };
                }
                export { start_9 as start };
                export namespace count_9 {
                    let type_370: string;
                    export { type_370 as type };
                }
                export { count_9 as count };
                export namespace total_9 {
                    let type_371: string;
                    export { type_371 as type };
                }
                export { total_9 as total };
                export namespace quotes_9 {
                    let type_372: string;
                    export { type_372 as type };
                    export namespace items_33 {
                        let $ref_23: string;
                        export { $ref_23 as $ref };
                    }
                    export { items_33 as items };
                }
                export { quotes_9 as quotes };
                export namespace useRecords_9 {
                    let type_373: string;
                    export { type_373 as type };
                }
                export { useRecords_9 as useRecords };
                export namespace predefinedScr_9 {
                    let type_374: string;
                    export { type_374 as type };
                }
                export { predefinedScr_9 as predefinedScr };
                export namespace versionId_9 {
                    let type_375: string;
                    export { type_375 as type };
                }
                export { versionId_9 as versionId };
                export namespace creationDate_9 {
                    let type_376: string;
                    export { type_376 as type };
                }
                export { creationDate_9 as creationDate };
                export namespace lastUpdated_9 {
                    let type_377: string;
                    export { type_377 as type };
                }
                export { lastUpdated_9 as lastUpdated };
                export namespace isPremium_9 {
                    let type_378: string;
                    export { type_378 as type };
                }
                export { isPremium_9 as isPremium };
                export namespace iconUrl_9 {
                    let type_379: string;
                    export { type_379 as type };
                }
                export { iconUrl_9 as iconUrl };
            }
            export { properties_20 as properties };
            let required_21: string[];
            export { required_21 as required };
            let additionalProperties_21: boolean;
            export { additionalProperties_21 as additionalProperties };
        }
        namespace ScreenerResultSmallCapGainers {
            let type_380: string;
            export { type_380 as type };
            export namespace properties_22 {
                export namespace id_10 {
                    let type_381: string;
                    export { type_381 as type };
                }
                export { id_10 as id };
                export namespace title_10 {
                    let type_382: string;
                    export { type_382 as type };
                }
                export { title_10 as title };
                export namespace description_10 {
                    let type_383: string;
                    export { type_383 as type };
                }
                export { description_10 as description };
                export namespace canonicalName_10 {
                    let type_384: string;
                    export { type_384 as type };
                    let _const_9: string;
                    export { _const_9 as const };
                }
                export { canonicalName_10 as canonicalName };
                export namespace criteriaMeta_10 {
                    let type_385: string;
                    export { type_385 as type };
                    let additionalProperties_22: boolean;
                    export { additionalProperties_22 as additionalProperties };
                    export namespace properties_23 {
                        export namespace includeFields_9 {
                            let type_386: string;
                            export { type_386 as type };
                            export namespace items_34 {
                                let type_387: string;
                                export { type_387 as type };
                                let _enum_7: string[];
                                export { _enum_7 as enum };
                            }
                            export { items_34 as items };
                        }
                        export { includeFields_9 as includeFields };
                        export namespace size_10 {
                            let type_388: string;
                            export { type_388 as type };
                        }
                        export { size_10 as size };
                        export namespace offset_10 {
                            let type_389: string;
                            export { type_389 as type };
                        }
                        export { offset_10 as offset };
                        export namespace sortField_10 {
                            let type_390: string;
                            export { type_390 as type };
                        }
                        export { sortField_10 as sortField };
                        export namespace sortType_10 {
                            let type_391: string;
                            export { type_391 as type };
                        }
                        export { sortType_10 as sortType };
                        export namespace quoteType_11 {
                            let type_392: string;
                            export { type_392 as type };
                        }
                        export { quoteType_11 as quoteType };
                        export namespace criteria_10 {
                            let type_393: string;
                            export { type_393 as type };
                            export namespace items_35 {
                                let $ref_24: string;
                                export { $ref_24 as $ref };
                            }
                            export { items_35 as items };
                        }
                        export { criteria_10 as criteria };
                        export namespace topOperator_10 {
                            let type_394: string;
                            export { type_394 as type };
                        }
                        export { topOperator_10 as topOperator };
                    }
                    export { properties_23 as properties };
                    let required_22: string[];
                    export { required_22 as required };
                }
                export { criteriaMeta_10 as criteriaMeta };
                export namespace rawCriteria_10 {
                    let type_395: string;
                    export { type_395 as type };
                }
                export { rawCriteria_10 as rawCriteria };
                export namespace start_10 {
                    let type_396: string;
                    export { type_396 as type };
                }
                export { start_10 as start };
                export namespace count_10 {
                    let type_397: string;
                    export { type_397 as type };
                }
                export { count_10 as count };
                export namespace total_10 {
                    let type_398: string;
                    export { type_398 as type };
                }
                export { total_10 as total };
                export namespace quotes_10 {
                    let type_399: string;
                    export { type_399 as type };
                    export namespace items_36 {
                        let $ref_25: string;
                        export { $ref_25 as $ref };
                    }
                    export { items_36 as items };
                }
                export { quotes_10 as quotes };
                export namespace useRecords_10 {
                    let type_400: string;
                    export { type_400 as type };
                }
                export { useRecords_10 as useRecords };
                export namespace predefinedScr_10 {
                    let type_401: string;
                    export { type_401 as type };
                }
                export { predefinedScr_10 as predefinedScr };
                export namespace versionId_10 {
                    let type_402: string;
                    export { type_402 as type };
                }
                export { versionId_10 as versionId };
                export namespace creationDate_10 {
                    let type_403: string;
                    export { type_403 as type };
                }
                export { creationDate_10 as creationDate };
                export namespace lastUpdated_10 {
                    let type_404: string;
                    export { type_404 as type };
                }
                export { lastUpdated_10 as lastUpdated };
                export namespace isPremium_10 {
                    let type_405: string;
                    export { type_405 as type };
                }
                export { isPremium_10 as isPremium };
                export namespace iconUrl_10 {
                    let type_406: string;
                    export { type_406 as type };
                }
                export { iconUrl_10 as iconUrl };
            }
            export { properties_22 as properties };
            let required_23: string[];
            export { required_23 as required };
            let additionalProperties_23: boolean;
            export { additionalProperties_23 as additionalProperties };
        }
        namespace ScreenerResultSolidLargeGrowthFunds {
            let type_407: string;
            export { type_407 as type };
            export namespace properties_24 {
                export namespace id_11 {
                    let type_408: string;
                    export { type_408 as type };
                }
                export { id_11 as id };
                export namespace title_11 {
                    let type_409: string;
                    export { type_409 as type };
                }
                export { title_11 as title };
                export namespace description_11 {
                    let type_410: string;
                    export { type_410 as type };
                }
                export { description_11 as description };
                export namespace canonicalName_11 {
                    let type_411: string;
                    export { type_411 as type };
                    let _const_10: string;
                    export { _const_10 as const };
                }
                export { canonicalName_11 as canonicalName };
                export namespace criteriaMeta_11 {
                    let type_412: string;
                    export { type_412 as type };
                    let additionalProperties_24: boolean;
                    export { additionalProperties_24 as additionalProperties };
                    export namespace properties_25 {
                        export namespace includeFields_10 {
                            let type_413: string;
                            export { type_413 as type };
                            export namespace items_37 {
                                let $ref_26: string;
                                export { $ref_26 as $ref };
                            }
                            export { items_37 as items };
                        }
                        export { includeFields_10 as includeFields };
                        export namespace size_11 {
                            let type_414: string;
                            export { type_414 as type };
                        }
                        export { size_11 as size };
                        export namespace offset_11 {
                            let type_415: string;
                            export { type_415 as type };
                        }
                        export { offset_11 as offset };
                        export namespace sortField_11 {
                            let type_416: string;
                            export { type_416 as type };
                        }
                        export { sortField_11 as sortField };
                        export namespace sortType_11 {
                            let type_417: string;
                            export { type_417 as type };
                        }
                        export { sortType_11 as sortType };
                        export namespace quoteType_12 {
                            let type_418: string;
                            export { type_418 as type };
                        }
                        export { quoteType_12 as quoteType };
                        export namespace criteria_11 {
                            let type_419: string;
                            export { type_419 as type };
                            export namespace items_38 {
                                let $ref_27: string;
                                export { $ref_27 as $ref };
                            }
                            export { items_38 as items };
                        }
                        export { criteria_11 as criteria };
                        export namespace topOperator_11 {
                            let type_420: string;
                            export { type_420 as type };
                        }
                        export { topOperator_11 as topOperator };
                    }
                    export { properties_25 as properties };
                    let required_24: string[];
                    export { required_24 as required };
                }
                export { criteriaMeta_11 as criteriaMeta };
                export namespace rawCriteria_11 {
                    let type_421: string;
                    export { type_421 as type };
                }
                export { rawCriteria_11 as rawCriteria };
                export namespace start_11 {
                    let type_422: string;
                    export { type_422 as type };
                }
                export { start_11 as start };
                export namespace count_11 {
                    let type_423: string;
                    export { type_423 as type };
                }
                export { count_11 as count };
                export namespace total_11 {
                    let type_424: string;
                    export { type_424 as type };
                }
                export { total_11 as total };
                export namespace quotes_11 {
                    let type_425: string;
                    export { type_425 as type };
                    export namespace items_39 {
                        let $ref_28: string;
                        export { $ref_28 as $ref };
                    }
                    export { items_39 as items };
                }
                export { quotes_11 as quotes };
                export namespace useRecords_11 {
                    let type_426: string;
                    export { type_426 as type };
                }
                export { useRecords_11 as useRecords };
                export namespace predefinedScr_11 {
                    let type_427: string;
                    export { type_427 as type };
                }
                export { predefinedScr_11 as predefinedScr };
                export namespace versionId_11 {
                    let type_428: string;
                    export { type_428 as type };
                }
                export { versionId_11 as versionId };
                export namespace creationDate_11 {
                    let type_429: string;
                    export { type_429 as type };
                }
                export { creationDate_11 as creationDate };
                export namespace lastUpdated_11 {
                    let type_430: string;
                    export { type_430 as type };
                }
                export { lastUpdated_11 as lastUpdated };
                export namespace isPremium_11 {
                    let type_431: string;
                    export { type_431 as type };
                }
                export { isPremium_11 as isPremium };
                export namespace iconUrl_11 {
                    let type_432: string;
                    export { type_432 as type };
                }
                export { iconUrl_11 as iconUrl };
            }
            export { properties_24 as properties };
            let required_25: string[];
            export { required_25 as required };
            let additionalProperties_25: boolean;
            export { additionalProperties_25 as additionalProperties };
        }
        namespace ScreenerResultSolidMidcapGrowthFunds {
            let type_433: string;
            export { type_433 as type };
            export namespace properties_26 {
                export namespace id_12 {
                    let type_434: string;
                    export { type_434 as type };
                }
                export { id_12 as id };
                export namespace title_12 {
                    let type_435: string;
                    export { type_435 as type };
                }
                export { title_12 as title };
                export namespace description_12 {
                    let type_436: string;
                    export { type_436 as type };
                }
                export { description_12 as description };
                export namespace canonicalName_12 {
                    let type_437: string;
                    export { type_437 as type };
                    let _const_11: string;
                    export { _const_11 as const };
                }
                export { canonicalName_12 as canonicalName };
                export namespace criteriaMeta_12 {
                    let type_438: string;
                    export { type_438 as type };
                    let additionalProperties_26: boolean;
                    export { additionalProperties_26 as additionalProperties };
                    export namespace properties_27 {
                        export namespace includeFields_11 {
                            let type_439: string;
                            export { type_439 as type };
                            export namespace items_40 {
                                let $ref_29: string;
                                export { $ref_29 as $ref };
                            }
                            export { items_40 as items };
                        }
                        export { includeFields_11 as includeFields };
                        export namespace size_12 {
                            let type_440: string;
                            export { type_440 as type };
                        }
                        export { size_12 as size };
                        export namespace offset_12 {
                            let type_441: string;
                            export { type_441 as type };
                        }
                        export { offset_12 as offset };
                        export namespace sortField_12 {
                            let type_442: string;
                            export { type_442 as type };
                        }
                        export { sortField_12 as sortField };
                        export namespace sortType_12 {
                            let type_443: string;
                            export { type_443 as type };
                        }
                        export { sortType_12 as sortType };
                        export namespace quoteType_13 {
                            let type_444: string;
                            export { type_444 as type };
                        }
                        export { quoteType_13 as quoteType };
                        export namespace criteria_12 {
                            let type_445: string;
                            export { type_445 as type };
                            export namespace items_41 {
                                let $ref_30: string;
                                export { $ref_30 as $ref };
                            }
                            export { items_41 as items };
                        }
                        export { criteria_12 as criteria };
                        export namespace topOperator_12 {
                            let type_446: string;
                            export { type_446 as type };
                        }
                        export { topOperator_12 as topOperator };
                    }
                    export { properties_27 as properties };
                    let required_26: string[];
                    export { required_26 as required };
                }
                export { criteriaMeta_12 as criteriaMeta };
                export namespace rawCriteria_12 {
                    let type_447: string;
                    export { type_447 as type };
                }
                export { rawCriteria_12 as rawCriteria };
                export namespace start_12 {
                    let type_448: string;
                    export { type_448 as type };
                }
                export { start_12 as start };
                export namespace count_12 {
                    let type_449: string;
                    export { type_449 as type };
                }
                export { count_12 as count };
                export namespace total_12 {
                    let type_450: string;
                    export { type_450 as type };
                }
                export { total_12 as total };
                export namespace quotes_12 {
                    let type_451: string;
                    export { type_451 as type };
                    export namespace items_42 {
                        let $ref_31: string;
                        export { $ref_31 as $ref };
                    }
                    export { items_42 as items };
                }
                export { quotes_12 as quotes };
                export namespace useRecords_12 {
                    let type_452: string;
                    export { type_452 as type };
                }
                export { useRecords_12 as useRecords };
                export namespace predefinedScr_12 {
                    let type_453: string;
                    export { type_453 as type };
                }
                export { predefinedScr_12 as predefinedScr };
                export namespace versionId_12 {
                    let type_454: string;
                    export { type_454 as type };
                }
                export { versionId_12 as versionId };
                export namespace creationDate_12 {
                    let type_455: string;
                    export { type_455 as type };
                }
                export { creationDate_12 as creationDate };
                export namespace lastUpdated_12 {
                    let type_456: string;
                    export { type_456 as type };
                }
                export { lastUpdated_12 as lastUpdated };
                export namespace isPremium_12 {
                    let type_457: string;
                    export { type_457 as type };
                }
                export { isPremium_12 as isPremium };
                export namespace iconUrl_12 {
                    let type_458: string;
                    export { type_458 as type };
                }
                export { iconUrl_12 as iconUrl };
            }
            export { properties_26 as properties };
            let required_27: string[];
            export { required_27 as required };
            let additionalProperties_27: boolean;
            export { additionalProperties_27 as additionalProperties };
        }
        namespace ScreenerResultTopMutualFunds {
            let type_459: string;
            export { type_459 as type };
            export namespace properties_28 {
                export namespace id_13 {
                    let type_460: string;
                    export { type_460 as type };
                }
                export { id_13 as id };
                export namespace title_13 {
                    let type_461: string;
                    export { type_461 as type };
                }
                export { title_13 as title };
                export namespace description_13 {
                    let type_462: string;
                    export { type_462 as type };
                }
                export { description_13 as description };
                export namespace canonicalName_13 {
                    let type_463: string;
                    export { type_463 as type };
                    let _const_12: string;
                    export { _const_12 as const };
                }
                export { canonicalName_13 as canonicalName };
                export namespace criteriaMeta_13 {
                    let type_464: string;
                    export { type_464 as type };
                    let additionalProperties_28: boolean;
                    export { additionalProperties_28 as additionalProperties };
                    export namespace properties_29 {
                        export namespace includeFields_12 {
                            let type_465: string;
                            export { type_465 as type };
                            export namespace items_43 {
                                let $ref_32: string;
                                export { $ref_32 as $ref };
                            }
                            export { items_43 as items };
                        }
                        export { includeFields_12 as includeFields };
                        export namespace size_13 {
                            let type_466: string;
                            export { type_466 as type };
                        }
                        export { size_13 as size };
                        export namespace offset_13 {
                            let type_467: string;
                            export { type_467 as type };
                        }
                        export { offset_13 as offset };
                        export namespace sortField_13 {
                            let type_468: string;
                            export { type_468 as type };
                        }
                        export { sortField_13 as sortField };
                        export namespace sortType_13 {
                            let type_469: string;
                            export { type_469 as type };
                        }
                        export { sortType_13 as sortType };
                        export namespace quoteType_14 {
                            let type_470: string;
                            export { type_470 as type };
                        }
                        export { quoteType_14 as quoteType };
                        export namespace criteria_13 {
                            let type_471: string;
                            export { type_471 as type };
                            export namespace items_44 {
                                let $ref_33: string;
                                export { $ref_33 as $ref };
                            }
                            export { items_44 as items };
                        }
                        export { criteria_13 as criteria };
                        export namespace topOperator_13 {
                            let type_472: string;
                            export { type_472 as type };
                        }
                        export { topOperator_13 as topOperator };
                    }
                    export { properties_29 as properties };
                    let required_28: string[];
                    export { required_28 as required };
                }
                export { criteriaMeta_13 as criteriaMeta };
                export namespace rawCriteria_13 {
                    let type_473: string;
                    export { type_473 as type };
                }
                export { rawCriteria_13 as rawCriteria };
                export namespace start_13 {
                    let type_474: string;
                    export { type_474 as type };
                }
                export { start_13 as start };
                export namespace count_13 {
                    let type_475: string;
                    export { type_475 as type };
                }
                export { count_13 as count };
                export namespace total_13 {
                    let type_476: string;
                    export { type_476 as type };
                }
                export { total_13 as total };
                export namespace quotes_13 {
                    let type_477: string;
                    export { type_477 as type };
                    export namespace items_45 {
                        let $ref_34: string;
                        export { $ref_34 as $ref };
                    }
                    export { items_45 as items };
                }
                export { quotes_13 as quotes };
                export namespace useRecords_13 {
                    let type_478: string;
                    export { type_478 as type };
                }
                export { useRecords_13 as useRecords };
                export namespace predefinedScr_13 {
                    let type_479: string;
                    export { type_479 as type };
                }
                export { predefinedScr_13 as predefinedScr };
                export namespace versionId_13 {
                    let type_480: string;
                    export { type_480 as type };
                }
                export { versionId_13 as versionId };
                export namespace creationDate_13 {
                    let type_481: string;
                    export { type_481 as type };
                }
                export { creationDate_13 as creationDate };
                export namespace lastUpdated_13 {
                    let type_482: string;
                    export { type_482 as type };
                }
                export { lastUpdated_13 as lastUpdated };
                export namespace isPremium_13 {
                    let type_483: string;
                    export { type_483 as type };
                }
                export { isPremium_13 as isPremium };
                export namespace iconUrl_13 {
                    let type_484: string;
                    export { type_484 as type };
                }
                export { iconUrl_13 as iconUrl };
            }
            export { properties_28 as properties };
            let required_29: string[];
            export { required_29 as required };
            let additionalProperties_29: boolean;
            export { additionalProperties_29 as additionalProperties };
        }
        namespace ScreenerResultUndervaluedGrowthStocks {
            let type_485: string;
            export { type_485 as type };
            export namespace properties_30 {
                export namespace id_14 {
                    let type_486: string;
                    export { type_486 as type };
                }
                export { id_14 as id };
                export namespace title_14 {
                    let type_487: string;
                    export { type_487 as type };
                }
                export { title_14 as title };
                export namespace description_14 {
                    let type_488: string;
                    export { type_488 as type };
                }
                export { description_14 as description };
                export namespace canonicalName_14 {
                    let type_489: string;
                    export { type_489 as type };
                    let _const_13: string;
                    export { _const_13 as const };
                }
                export { canonicalName_14 as canonicalName };
                export namespace criteriaMeta_14 {
                    let type_490: string;
                    export { type_490 as type };
                    let additionalProperties_30: boolean;
                    export { additionalProperties_30 as additionalProperties };
                    export namespace properties_31 {
                        export namespace includeFields_13 {
                            let type_491: string;
                            export { type_491 as type };
                            export namespace items_46 {
                                let type_492: string;
                                export { type_492 as type };
                                let _enum_8: string[];
                                export { _enum_8 as enum };
                            }
                            export { items_46 as items };
                        }
                        export { includeFields_13 as includeFields };
                        export namespace size_14 {
                            let type_493: string;
                            export { type_493 as type };
                        }
                        export { size_14 as size };
                        export namespace offset_14 {
                            let type_494: string;
                            export { type_494 as type };
                        }
                        export { offset_14 as offset };
                        export namespace sortField_14 {
                            let type_495: string;
                            export { type_495 as type };
                        }
                        export { sortField_14 as sortField };
                        export namespace sortType_14 {
                            let type_496: string;
                            export { type_496 as type };
                        }
                        export { sortType_14 as sortType };
                        export namespace quoteType_15 {
                            let type_497: string;
                            export { type_497 as type };
                        }
                        export { quoteType_15 as quoteType };
                        export namespace criteria_14 {
                            let type_498: string;
                            export { type_498 as type };
                            export namespace items_47 {
                                let $ref_35: string;
                                export { $ref_35 as $ref };
                            }
                            export { items_47 as items };
                        }
                        export { criteria_14 as criteria };
                        export namespace topOperator_14 {
                            let type_499: string;
                            export { type_499 as type };
                        }
                        export { topOperator_14 as topOperator };
                    }
                    export { properties_31 as properties };
                    let required_30: string[];
                    export { required_30 as required };
                }
                export { criteriaMeta_14 as criteriaMeta };
                export namespace rawCriteria_14 {
                    let type_500: string;
                    export { type_500 as type };
                }
                export { rawCriteria_14 as rawCriteria };
                export namespace start_14 {
                    let type_501: string;
                    export { type_501 as type };
                }
                export { start_14 as start };
                export namespace count_14 {
                    let type_502: string;
                    export { type_502 as type };
                }
                export { count_14 as count };
                export namespace total_14 {
                    let type_503: string;
                    export { type_503 as type };
                }
                export { total_14 as total };
                export namespace quotes_14 {
                    let type_504: string;
                    export { type_504 as type };
                    export namespace items_48 {
                        let $ref_36: string;
                        export { $ref_36 as $ref };
                    }
                    export { items_48 as items };
                }
                export { quotes_14 as quotes };
                export namespace useRecords_14 {
                    let type_505: string;
                    export { type_505 as type };
                }
                export { useRecords_14 as useRecords };
                export namespace predefinedScr_14 {
                    let type_506: string;
                    export { type_506 as type };
                }
                export { predefinedScr_14 as predefinedScr };
                export namespace versionId_14 {
                    let type_507: string;
                    export { type_507 as type };
                }
                export { versionId_14 as versionId };
                export namespace creationDate_14 {
                    let type_508: string;
                    export { type_508 as type };
                }
                export { creationDate_14 as creationDate };
                export namespace lastUpdated_14 {
                    let type_509: string;
                    export { type_509 as type };
                }
                export { lastUpdated_14 as lastUpdated };
                export namespace isPremium_14 {
                    let type_510: string;
                    export { type_510 as type };
                }
                export { isPremium_14 as isPremium };
                export namespace iconUrl_14 {
                    let type_511: string;
                    export { type_511 as type };
                }
                export { iconUrl_14 as iconUrl };
            }
            export { properties_30 as properties };
            let required_31: string[];
            export { required_31 as required };
            let additionalProperties_31: boolean;
            export { additionalProperties_31 as additionalProperties };
        }
        namespace ScreenerResultUndervaluedLargeCaps {
            let type_512: string;
            export { type_512 as type };
            export namespace properties_32 {
                export namespace id_15 {
                    let type_513: string;
                    export { type_513 as type };
                }
                export { id_15 as id };
                export namespace title_15 {
                    let type_514: string;
                    export { type_514 as type };
                }
                export { title_15 as title };
                export namespace description_15 {
                    let type_515: string;
                    export { type_515 as type };
                }
                export { description_15 as description };
                export namespace canonicalName_15 {
                    let type_516: string;
                    export { type_516 as type };
                    let _const_14: string;
                    export { _const_14 as const };
                }
                export { canonicalName_15 as canonicalName };
                export namespace criteriaMeta_15 {
                    let type_517: string;
                    export { type_517 as type };
                    let additionalProperties_32: boolean;
                    export { additionalProperties_32 as additionalProperties };
                    export namespace properties_33 {
                        export namespace includeFields_14 {
                            let type_518: string;
                            export { type_518 as type };
                            export namespace items_49 {
                                let type_519: string;
                                export { type_519 as type };
                                let _enum_9: string[];
                                export { _enum_9 as enum };
                            }
                            export { items_49 as items };
                        }
                        export { includeFields_14 as includeFields };
                        export namespace size_15 {
                            let type_520: string;
                            export { type_520 as type };
                        }
                        export { size_15 as size };
                        export namespace offset_15 {
                            let type_521: string;
                            export { type_521 as type };
                        }
                        export { offset_15 as offset };
                        export namespace sortField_15 {
                            let type_522: string;
                            export { type_522 as type };
                        }
                        export { sortField_15 as sortField };
                        export namespace sortType_15 {
                            let type_523: string;
                            export { type_523 as type };
                        }
                        export { sortType_15 as sortType };
                        export namespace quoteType_16 {
                            let type_524: string;
                            export { type_524 as type };
                        }
                        export { quoteType_16 as quoteType };
                        export namespace criteria_15 {
                            let type_525: string;
                            export { type_525 as type };
                            export namespace items_50 {
                                let $ref_37: string;
                                export { $ref_37 as $ref };
                            }
                            export { items_50 as items };
                        }
                        export { criteria_15 as criteria };
                        export namespace topOperator_15 {
                            let type_526: string;
                            export { type_526 as type };
                        }
                        export { topOperator_15 as topOperator };
                    }
                    export { properties_33 as properties };
                    let required_32: string[];
                    export { required_32 as required };
                }
                export { criteriaMeta_15 as criteriaMeta };
                export namespace rawCriteria_15 {
                    let type_527: string;
                    export { type_527 as type };
                }
                export { rawCriteria_15 as rawCriteria };
                export namespace start_15 {
                    let type_528: string;
                    export { type_528 as type };
                }
                export { start_15 as start };
                export namespace count_15 {
                    let type_529: string;
                    export { type_529 as type };
                }
                export { count_15 as count };
                export namespace total_15 {
                    let type_530: string;
                    export { type_530 as type };
                }
                export { total_15 as total };
                export namespace quotes_15 {
                    let type_531: string;
                    export { type_531 as type };
                    export namespace items_51 {
                        let $ref_38: string;
                        export { $ref_38 as $ref };
                    }
                    export { items_51 as items };
                }
                export { quotes_15 as quotes };
                export namespace useRecords_15 {
                    let type_532: string;
                    export { type_532 as type };
                }
                export { useRecords_15 as useRecords };
                export namespace predefinedScr_15 {
                    let type_533: string;
                    export { type_533 as type };
                }
                export { predefinedScr_15 as predefinedScr };
                export namespace versionId_15 {
                    let type_534: string;
                    export { type_534 as type };
                }
                export { versionId_15 as versionId };
                export namespace creationDate_15 {
                    let type_535: string;
                    export { type_535 as type };
                }
                export { creationDate_15 as creationDate };
                export namespace lastUpdated_15 {
                    let type_536: string;
                    export { type_536 as type };
                }
                export { lastUpdated_15 as lastUpdated };
                export namespace isPremium_15 {
                    let type_537: string;
                    export { type_537 as type };
                }
                export { isPremium_15 as isPremium };
                export namespace iconUrl_15 {
                    let type_538: string;
                    export { type_538 as type };
                }
                export { iconUrl_15 as iconUrl };
            }
            export { properties_32 as properties };
            let required_33: string[];
            export { required_33 as required };
            let additionalProperties_33: boolean;
            export { additionalProperties_33 as additionalProperties };
        }
        namespace ScreenerResult {
            let type_539: string;
            export { type_539 as type };
            export namespace discriminator {
                let propertyName: string;
            }
            let required_34: string[];
            export { required_34 as required };
            export let oneOf: {
                $ref: string;
            }[];
        }
        namespace PredefinedScreenerModules {
            let type_540: string;
            export { type_540 as type };
            let _enum_10: string[];
            export { _enum_10 as enum };
        }
        namespace ScreenerOptions {
            let type_541: string;
            export { type_541 as type };
            export namespace properties_34 {
                export namespace lang {
                    let type_542: string;
                    export { type_542 as type };
                }
                export namespace region_1 {
                    let type_543: string;
                    export { type_543 as type };
                }
                export { region_1 as region };
                export namespace scrIds {
                    let $ref_39: string;
                    export { $ref_39 as $ref };
                }
                export namespace count_16 {
                    let type_544: string;
                    export { type_544 as type };
                }
                export { count_16 as count };
            }
            export { properties_34 as properties };
            let required_35: string[];
            export { required_35 as required };
            let additionalProperties_34: boolean;
            export { additionalProperties_34 as additionalProperties };
        }
        let screener: {};
    }
}
export default _default;
//# sourceMappingURL=screener.schema.d.ts.map