declare namespace _default {
    let $schema: string;
    let $comment: string;
    namespace definitions {
        namespace QuoteSummaryResult {
            let type: string;
            namespace properties {
                namespace assetProfile {
                    let $ref: string;
                }
                namespace balanceSheetHistory {
                    let $ref_1: string;
                    export { $ref_1 as $ref };
                }
                namespace balanceSheetHistoryQuarterly {
                    let $ref_2: string;
                    export { $ref_2 as $ref };
                }
                namespace calendarEvents {
                    let $ref_3: string;
                    export { $ref_3 as $ref };
                }
                namespace cashflowStatementHistory {
                    let $ref_4: string;
                    export { $ref_4 as $ref };
                }
                namespace cashflowStatementHistoryQuarterly {
                    let $ref_5: string;
                    export { $ref_5 as $ref };
                }
                namespace defaultKeyStatistics {
                    let $ref_6: string;
                    export { $ref_6 as $ref };
                }
                namespace earnings {
                    let $ref_7: string;
                    export { $ref_7 as $ref };
                }
                namespace earningsHistory {
                    let $ref_8: string;
                    export { $ref_8 as $ref };
                }
                namespace earningsTrend {
                    let $ref_9: string;
                    export { $ref_9 as $ref };
                }
                namespace financialData {
                    let $ref_10: string;
                    export { $ref_10 as $ref };
                }
                namespace fundOwnership {
                    let $ref_11: string;
                    export { $ref_11 as $ref };
                }
                namespace fundPerformance {
                    let $ref_12: string;
                    export { $ref_12 as $ref };
                }
                namespace fundProfile {
                    let $ref_13: string;
                    export { $ref_13 as $ref };
                }
                namespace incomeStatementHistory {
                    let $ref_14: string;
                    export { $ref_14 as $ref };
                }
                namespace incomeStatementHistoryQuarterly {
                    let $ref_15: string;
                    export { $ref_15 as $ref };
                }
                namespace indexTrend {
                    let $ref_16: string;
                    export { $ref_16 as $ref };
                }
                namespace industryTrend {
                    let $ref_17: string;
                    export { $ref_17 as $ref };
                }
                namespace insiderHolders {
                    let $ref_18: string;
                    export { $ref_18 as $ref };
                }
                namespace insiderTransactions {
                    let $ref_19: string;
                    export { $ref_19 as $ref };
                }
                namespace institutionOwnership {
                    let $ref_20: string;
                    export { $ref_20 as $ref };
                }
                namespace majorDirectHolders {
                    let $ref_21: string;
                    export { $ref_21 as $ref };
                }
                namespace majorHoldersBreakdown {
                    let $ref_22: string;
                    export { $ref_22 as $ref };
                }
                namespace netSharePurchaseActivity {
                    let $ref_23: string;
                    export { $ref_23 as $ref };
                }
                namespace price {
                    let $ref_24: string;
                    export { $ref_24 as $ref };
                }
                namespace quoteType {
                    let $ref_25: string;
                    export { $ref_25 as $ref };
                }
                namespace recommendationTrend {
                    let $ref_26: string;
                    export { $ref_26 as $ref };
                }
                namespace secFilings {
                    let $ref_27: string;
                    export { $ref_27 as $ref };
                }
                namespace sectorTrend {
                    let $ref_28: string;
                    export { $ref_28 as $ref };
                }
                namespace summaryDetail {
                    let $ref_29: string;
                    export { $ref_29 as $ref };
                }
                namespace summaryProfile {
                    let $ref_30: string;
                    export { $ref_30 as $ref };
                }
                namespace topHoldings {
                    let $ref_31: string;
                    export { $ref_31 as $ref };
                }
                namespace upgradeDowngradeHistory {
                    let $ref_32: string;
                    export { $ref_32 as $ref };
                }
            }
            let additionalProperties: {};
        }
        namespace AssetProfile {
            let type_1: string;
            export { type_1 as type };
            export namespace properties_1 {
                namespace maxAge {
                    let type_2: string;
                    export { type_2 as type };
                }
                namespace address1 {
                    let type_3: string;
                    export { type_3 as type };
                }
                namespace address2 {
                    let type_4: string;
                    export { type_4 as type };
                }
                namespace address3 {
                    let type_5: string;
                    export { type_5 as type };
                }
                namespace city {
                    let type_6: string;
                    export { type_6 as type };
                }
                namespace state {
                    let type_7: string;
                    export { type_7 as type };
                }
                namespace zip {
                    let type_8: string;
                    export { type_8 as type };
                }
                namespace country {
                    let type_9: string;
                    export { type_9 as type };
                }
                namespace phone {
                    let type_10: string;
                    export { type_10 as type };
                }
                namespace fax {
                    let type_11: string;
                    export { type_11 as type };
                }
                namespace website {
                    let type_12: string;
                    export { type_12 as type };
                }
                namespace industry {
                    let type_13: string;
                    export { type_13 as type };
                }
                namespace industryDisp {
                    let type_14: string;
                    export { type_14 as type };
                }
                namespace industryKey {
                    let type_15: string;
                    export { type_15 as type };
                }
                namespace industrySymbol {
                    let type_16: string;
                    export { type_16 as type };
                }
                namespace sector {
                    let type_17: string;
                    export { type_17 as type };
                }
                namespace sectorDisp {
                    let type_18: string;
                    export { type_18 as type };
                }
                namespace sectorKey {
                    let type_19: string;
                    export { type_19 as type };
                }
                namespace longBusinessSummary {
                    let type_20: string;
                    export { type_20 as type };
                }
                namespace fullTimeEmployees {
                    let type_21: string;
                    export { type_21 as type };
                }
                namespace companyOfficers {
                    let type_22: string;
                    export { type_22 as type };
                    export namespace items {
                        let $ref_33: string;
                        export { $ref_33 as $ref };
                    }
                }
                namespace auditRisk {
                    let type_23: string;
                    export { type_23 as type };
                }
                namespace boardRisk {
                    let type_24: string;
                    export { type_24 as type };
                }
                namespace compensationRisk {
                    let type_25: string;
                    export { type_25 as type };
                }
                namespace shareHolderRightsRisk {
                    let type_26: string;
                    export { type_26 as type };
                }
                namespace overallRisk {
                    let type_27: string;
                    export { type_27 as type };
                }
                namespace governanceEpochDate {
                    let type_28: string;
                    export { type_28 as type };
                    export let format: string;
                }
                namespace compensationAsOfEpochDate {
                    let type_29: string;
                    export { type_29 as type };
                    let format_1: string;
                    export { format_1 as format };
                }
                namespace name {
                    let type_30: string;
                    export { type_30 as type };
                }
                namespace startDate {
                    let type_31: string;
                    export { type_31 as type };
                    let format_2: string;
                    export { format_2 as format };
                }
                namespace description {
                    let type_32: string;
                    export { type_32 as type };
                }
                namespace twitter {
                    let type_33: string;
                    export { type_33 as type };
                }
                namespace irWebsite {
                    let type_34: string;
                    export { type_34 as type };
                }
                namespace executiveTeam {
                    let type_35: string;
                    export { type_35 as type };
                    let items_1: {};
                    export { items_1 as items };
                }
            }
            export { properties_1 as properties };
            export let required: string[];
            let additionalProperties_1: {};
            export { additionalProperties_1 as additionalProperties };
        }
        namespace CompanyOfficer {
            let type_36: string;
            export { type_36 as type };
            export namespace properties_2 {
                export namespace maxAge_1 {
                    let type_37: string;
                    export { type_37 as type };
                }
                export { maxAge_1 as maxAge };
                export namespace name_1 {
                    let type_38: string;
                    export { type_38 as type };
                }
                export { name_1 as name };
                export namespace age {
                    let type_39: string;
                    export { type_39 as type };
                }
                export namespace title {
                    let type_40: string;
                    export { type_40 as type };
                }
                export namespace yearBorn {
                    let type_41: string;
                    export { type_41 as type };
                }
                export namespace fiscalYear {
                    let type_42: string;
                    export { type_42 as type };
                }
                export namespace totalPay {
                    let type_43: string;
                    export { type_43 as type };
                }
                export namespace exercisedValue {
                    let type_44: string;
                    export { type_44 as type };
                }
                export namespace unexercisedValue {
                    let type_45: string;
                    export { type_45 as type };
                }
            }
            export { properties_2 as properties };
            let required_1: string[];
            export { required_1 as required };
            let additionalProperties_2: {};
            export { additionalProperties_2 as additionalProperties };
        }
        namespace BalanceSheetHistory {
            let type_46: string;
            export { type_46 as type };
            export namespace properties_3 {
                export namespace balanceSheetStatements {
                    let type_47: string;
                    export { type_47 as type };
                    export namespace items_2 {
                        let $ref_34: string;
                        export { $ref_34 as $ref };
                    }
                    export { items_2 as items };
                }
                export namespace maxAge_2 {
                    let type_48: string;
                    export { type_48 as type };
                }
                export { maxAge_2 as maxAge };
            }
            export { properties_3 as properties };
            let required_2: string[];
            export { required_2 as required };
            let additionalProperties_3: {};
            export { additionalProperties_3 as additionalProperties };
        }
        namespace BalanceSheetStatement {
            let type_49: string;
            export { type_49 as type };
            export namespace properties_4 {
                export namespace maxAge_3 {
                    let type_50: string;
                    export { type_50 as type };
                }
                export { maxAge_3 as maxAge };
                export namespace endDate {
                    let type_51: string;
                    export { type_51 as type };
                    let format_3: string;
                    export { format_3 as format };
                }
            }
            export { properties_4 as properties };
            let required_3: string[];
            export { required_3 as required };
            let additionalProperties_4: boolean;
            export { additionalProperties_4 as additionalProperties };
        }
        namespace CalendarEvents {
            let type_52: string;
            export { type_52 as type };
            export namespace properties_5 {
                export namespace maxAge_4 {
                    let type_53: string;
                    export { type_53 as type };
                }
                export { maxAge_4 as maxAge };
                export namespace earnings_1 {
                    let $ref_35: string;
                    export { $ref_35 as $ref };
                }
                export { earnings_1 as earnings };
                export namespace exDividendDate {
                    let type_54: string;
                    export { type_54 as type };
                    let format_4: string;
                    export { format_4 as format };
                }
                export namespace dividendDate {
                    let type_55: string;
                    export { type_55 as type };
                    let format_5: string;
                    export { format_5 as format };
                }
            }
            export { properties_5 as properties };
            let required_4: string[];
            export { required_4 as required };
            let additionalProperties_5: {};
            export { additionalProperties_5 as additionalProperties };
        }
        namespace CalendarEventsEarnings {
            let type_56: string;
            export { type_56 as type };
            export namespace properties_6 {
                namespace earningsCallDate {
                    let type_57: string;
                    export { type_57 as type };
                    export namespace items_3 {
                        let type_58: string;
                        export { type_58 as type };
                        let format_6: string;
                        export { format_6 as format };
                    }
                    export { items_3 as items };
                }
                namespace isEarningsDateEstimate {
                    let type_59: string;
                    export { type_59 as type };
                }
                namespace earningsDate {
                    let type_60: string;
                    export { type_60 as type };
                    export namespace items_4 {
                        let type_61: string;
                        export { type_61 as type };
                        let format_7: string;
                        export { format_7 as format };
                    }
                    export { items_4 as items };
                }
                namespace earningsAverage {
                    let type_62: string;
                    export { type_62 as type };
                }
                namespace earningsLow {
                    let type_63: string;
                    export { type_63 as type };
                }
                namespace earningsHigh {
                    let type_64: string;
                    export { type_64 as type };
                }
                namespace revenueAverage {
                    let type_65: string;
                    export { type_65 as type };
                }
                namespace revenueLow {
                    let type_66: string;
                    export { type_66 as type };
                }
                namespace revenueHigh {
                    let type_67: string;
                    export { type_67 as type };
                }
            }
            export { properties_6 as properties };
            let required_5: string[];
            export { required_5 as required };
            let additionalProperties_6: {};
            export { additionalProperties_6 as additionalProperties };
        }
        namespace CashflowStatementHistory {
            let type_68: string;
            export { type_68 as type };
            export namespace properties_7 {
                export namespace cashflowStatements {
                    let type_69: string;
                    export { type_69 as type };
                    export namespace items_5 {
                        let $ref_36: string;
                        export { $ref_36 as $ref };
                    }
                    export { items_5 as items };
                }
                export namespace maxAge_5 {
                    let type_70: string;
                    export { type_70 as type };
                }
                export { maxAge_5 as maxAge };
            }
            export { properties_7 as properties };
            let required_6: string[];
            export { required_6 as required };
            let additionalProperties_7: boolean;
            export { additionalProperties_7 as additionalProperties };
        }
        namespace CashflowStatement {
            let type_71: string;
            export { type_71 as type };
            export namespace properties_8 {
                export namespace maxAge_6 {
                    let type_72: string;
                    export { type_72 as type };
                }
                export { maxAge_6 as maxAge };
                export namespace endDate_1 {
                    let type_73: string;
                    export { type_73 as type };
                    let format_8: string;
                    export { format_8 as format };
                }
                export { endDate_1 as endDate };
                export namespace netIncome {
                    let type_74: string;
                    export { type_74 as type };
                }
            }
            export { properties_8 as properties };
            let required_7: string[];
            export { required_7 as required };
            let additionalProperties_8: boolean;
            export { additionalProperties_8 as additionalProperties };
        }
        namespace DefaultKeyStatistics {
            let type_75: string;
            export { type_75 as type };
            let properties_9: {
                maxAge: {
                    type: string;
                };
                priceHint: {
                    type: string;
                };
                enterpriseValue: {
                    type: string;
                };
                forwardPE: {
                    type: string;
                };
                profitMargins: {
                    type: string;
                };
                floatShares: {
                    type: string;
                };
                sharesOutstanding: {
                    type: string;
                };
                sharesShort: {
                    type: string;
                };
                sharesShortPriorMonth: {
                    type: string;
                    format: string;
                };
                sharesShortPreviousMonthDate: {
                    type: string;
                    format: string;
                };
                dateShortInterest: {
                    type: string;
                    format: string;
                };
                sharesPercentSharesOut: {
                    type: string;
                };
                heldPercentInsiders: {
                    type: string;
                };
                heldPercentInstitutions: {
                    type: string;
                };
                shortRatio: {
                    type: string;
                };
                shortPercentOfFloat: {
                    type: string;
                };
                beta: {
                    type: string;
                };
                impliedSharesOutstanding: {
                    type: string;
                };
                category: {
                    type: string[];
                };
                bookValue: {
                    type: string;
                };
                priceToBook: {
                    type: string;
                };
                fundFamily: {
                    type: string[];
                };
                legalType: {
                    type: string[];
                };
                lastFiscalYearEnd: {
                    type: string;
                    format: string;
                };
                nextFiscalYearEnd: {
                    type: string;
                    format: string;
                };
                mostRecentQuarter: {
                    type: string;
                    format: string;
                };
                earningsQuarterlyGrowth: {
                    type: string;
                };
                netIncomeToCommon: {
                    type: string;
                };
                trailingEps: {
                    type: string;
                };
                forwardEps: {
                    type: string;
                };
                pegRatio: {
                    type: string;
                };
                lastSplitFactor: {
                    type: string[];
                };
                lastSplitDate: {
                    type: string;
                };
                enterpriseToRevenue: {
                    type: string;
                };
                enterpriseToEbitda: {
                    type: string;
                };
                "52WeekChange": {
                    type: string;
                };
                SandP52WeekChange: {
                    type: string;
                };
                lastDividendValue: {
                    type: string;
                };
                lastDividendDate: {
                    type: string;
                    format: string;
                };
                ytdReturn: {
                    type: string;
                };
                beta3Year: {
                    type: string;
                };
                totalAssets: {
                    type: string;
                };
                yield: {
                    type: string;
                };
                fundInceptionDate: {
                    type: string;
                    format: string;
                };
                threeYearAverageReturn: {
                    type: string;
                };
                fiveYearAverageReturn: {
                    type: string;
                };
                morningStarOverallRating: {
                    type: string;
                };
                morningStarRiskRating: {
                    type: string;
                };
                annualReportExpenseRatio: {
                    type: string;
                };
                lastCapGain: {
                    type: string;
                };
                annualHoldingsTurnover: {
                    type: string;
                };
                latestShareClass: {};
                leadInvestor: {};
            };
            export { properties_9 as properties };
            let required_8: string[];
            export { required_8 as required };
            let additionalProperties_9: {};
            export { additionalProperties_9 as additionalProperties };
        }
        namespace QuoteSummaryEarnings {
            let type_76: string;
            export { type_76 as type };
            export namespace properties_10 {
                export namespace maxAge_7 {
                    let type_77: string;
                    export { type_77 as type };
                }
                export { maxAge_7 as maxAge };
                export namespace earningsChart {
                    let $ref_37: string;
                    export { $ref_37 as $ref };
                }
                export namespace financialsChart {
                    let $ref_38: string;
                    export { $ref_38 as $ref };
                }
                export namespace financialCurrency {
                    let type_78: string;
                    export { type_78 as type };
                }
            }
            export { properties_10 as properties };
            let required_9: string[];
            export { required_9 as required };
            let additionalProperties_10: {};
            export { additionalProperties_10 as additionalProperties };
        }
        namespace EarningsChart {
            let type_79: string;
            export { type_79 as type };
            export namespace properties_11 {
                export namespace quarterly {
                    let type_80: string;
                    export { type_80 as type };
                    export namespace items_6 {
                        let $ref_39: string;
                        export { $ref_39 as $ref };
                    }
                    export { items_6 as items };
                }
                export namespace currentQuarterEstimate {
                    let type_81: string;
                    export { type_81 as type };
                }
                export namespace currentQuarterEstimateDate {
                    let type_82: string;
                    export { type_82 as type };
                }
                export namespace currentQuarterEstimateYear {
                    let type_83: string;
                    export { type_83 as type };
                }
                export namespace earningsDate_1 {
                    let type_84: string;
                    export { type_84 as type };
                    export namespace items_7 {
                        let type_85: string;
                        export { type_85 as type };
                        let format_9: string;
                        export { format_9 as format };
                    }
                    export { items_7 as items };
                }
                export { earningsDate_1 as earningsDate };
                export namespace isEarningsDateEstimate_1 {
                    let type_86: string;
                    export { type_86 as type };
                }
                export { isEarningsDateEstimate_1 as isEarningsDateEstimate };
            }
            export { properties_11 as properties };
            let required_10: string[];
            export { required_10 as required };
            let additionalProperties_11: {};
            export { additionalProperties_11 as additionalProperties };
        }
        namespace EarningsChartQuarterly {
            let type_87: string;
            export { type_87 as type };
            export namespace properties_12 {
                namespace date {
                    let type_88: string;
                    export { type_88 as type };
                }
                namespace actual {
                    let type_89: string;
                    export { type_89 as type };
                }
                namespace estimate {
                    let type_90: string;
                    export { type_90 as type };
                }
            }
            export { properties_12 as properties };
            let required_11: string[];
            export { required_11 as required };
            let additionalProperties_12: {};
            export { additionalProperties_12 as additionalProperties };
        }
        namespace FinancialsChart {
            let type_91: string;
            export { type_91 as type };
            export namespace properties_13 {
                export namespace yearly {
                    let type_92: string;
                    export { type_92 as type };
                    export namespace items_8 {
                        let $ref_40: string;
                        export { $ref_40 as $ref };
                    }
                    export { items_8 as items };
                }
                export namespace quarterly_1 {
                    let type_93: string;
                    export { type_93 as type };
                    export namespace items_9 {
                        let $ref_41: string;
                        export { $ref_41 as $ref };
                    }
                    export { items_9 as items };
                }
                export { quarterly_1 as quarterly };
            }
            export { properties_13 as properties };
            let required_12: string[];
            export { required_12 as required };
            let additionalProperties_13: {};
            export { additionalProperties_13 as additionalProperties };
        }
        namespace Yearly {
            let type_94: string;
            export { type_94 as type };
            export namespace properties_14 {
                export namespace date_1 {
                    let type_95: string;
                    export { type_95 as type };
                }
                export { date_1 as date };
                export namespace revenue {
                    let type_96: string;
                    export { type_96 as type };
                }
                export namespace earnings_2 {
                    let type_97: string;
                    export { type_97 as type };
                }
                export { earnings_2 as earnings };
            }
            export { properties_14 as properties };
            let required_13: string[];
            export { required_13 as required };
            let additionalProperties_14: {};
            export { additionalProperties_14 as additionalProperties };
        }
        namespace FinancialsChartQuarterly {
            let type_98: string;
            export { type_98 as type };
            export namespace properties_15 {
                export namespace date_2 {
                    let type_99: string;
                    export { type_99 as type };
                }
                export { date_2 as date };
                export namespace revenue_1 {
                    let type_100: string;
                    export { type_100 as type };
                }
                export { revenue_1 as revenue };
                export namespace earnings_3 {
                    let type_101: string;
                    export { type_101 as type };
                }
                export { earnings_3 as earnings };
            }
            export { properties_15 as properties };
            let required_14: string[];
            export { required_14 as required };
            let additionalProperties_15: {};
            export { additionalProperties_15 as additionalProperties };
        }
        namespace EarningsHistory {
            let type_102: string;
            export { type_102 as type };
            export namespace properties_16 {
                export namespace history {
                    let type_103: string;
                    export { type_103 as type };
                    export namespace items_10 {
                        let $ref_42: string;
                        export { $ref_42 as $ref };
                    }
                    export { items_10 as items };
                }
                export namespace maxAge_8 {
                    let type_104: string;
                    export { type_104 as type };
                }
                export { maxAge_8 as maxAge };
            }
            export { properties_16 as properties };
            let required_15: string[];
            export { required_15 as required };
            let additionalProperties_16: {};
            export { additionalProperties_16 as additionalProperties };
        }
        namespace EarningsHistoryHistory {
            let type_105: string;
            export { type_105 as type };
            export namespace properties_17 {
                export namespace maxAge_9 {
                    let type_106: string;
                    export { type_106 as type };
                }
                export { maxAge_9 as maxAge };
                export namespace epsActual {
                    let type_107: string[];
                    export { type_107 as type };
                }
                export namespace epsEstimate {
                    let type_108: string[];
                    export { type_108 as type };
                }
                export namespace epsDifference {
                    let type_109: string[];
                    export { type_109 as type };
                }
                export namespace surprisePercent {
                    let type_110: string[];
                    export { type_110 as type };
                }
                export namespace quarter {
                    let anyOf: ({
                        type: string;
                        format: string;
                    } | {
                        type: string;
                        format?: undefined;
                    })[];
                }
                export namespace period {
                    let type_111: string;
                    export { type_111 as type };
                }
                export namespace currency {
                    let type_112: string;
                    export { type_112 as type };
                }
            }
            export { properties_17 as properties };
            let required_16: string[];
            export { required_16 as required };
            let additionalProperties_17: {};
            export { additionalProperties_17 as additionalProperties };
        }
        namespace EarningsTrend {
            let type_113: string;
            export { type_113 as type };
            export namespace properties_18 {
                export namespace trend {
                    let type_114: string;
                    export { type_114 as type };
                    export namespace items_11 {
                        let $ref_43: string;
                        export { $ref_43 as $ref };
                    }
                    export { items_11 as items };
                }
                export namespace maxAge_10 {
                    let type_115: string;
                    export { type_115 as type };
                }
                export { maxAge_10 as maxAge };
            }
            export { properties_18 as properties };
            let required_17: string[];
            export { required_17 as required };
            let additionalProperties_18: {};
            export { additionalProperties_18 as additionalProperties };
        }
        namespace EarningsTrendTrend {
            let type_116: string;
            export { type_116 as type };
            export namespace properties_19 {
                export namespace maxAge_11 {
                    let type_117: string;
                    export { type_117 as type };
                }
                export { maxAge_11 as maxAge };
                export namespace period_1 {
                    let type_118: string;
                    export { type_118 as type };
                }
                export { period_1 as period };
                export namespace endDate_2 {
                    let anyOf_1: ({
                        type: string;
                        format: string;
                    } | {
                        type: string;
                        format?: undefined;
                    })[];
                    export { anyOf_1 as anyOf };
                }
                export { endDate_2 as endDate };
                export namespace growth {
                    let type_119: string[];
                    export { type_119 as type };
                }
                export namespace earningsEstimate {
                    let $ref_44: string;
                    export { $ref_44 as $ref };
                }
                export namespace revenueEstimate {
                    let $ref_45: string;
                    export { $ref_45 as $ref };
                }
                export namespace epsTrend {
                    let $ref_46: string;
                    export { $ref_46 as $ref };
                }
                export namespace epsRevisions {
                    let $ref_47: string;
                    export { $ref_47 as $ref };
                }
            }
            export { properties_19 as properties };
            let required_18: string[];
            export { required_18 as required };
            let additionalProperties_19: {};
            export { additionalProperties_19 as additionalProperties };
        }
        namespace EarningsEstimate {
            let type_120: string;
            export { type_120 as type };
            export namespace properties_20 {
                export namespace avg {
                    let type_121: string[];
                    export { type_121 as type };
                }
                export namespace low {
                    let type_122: string[];
                    export { type_122 as type };
                }
                export namespace high {
                    let type_123: string[];
                    export { type_123 as type };
                }
                export namespace yearAgoEps {
                    let type_124: string[];
                    export { type_124 as type };
                }
                export namespace numberOfAnalysts {
                    let type_125: string[];
                    export { type_125 as type };
                }
                export namespace growth_1 {
                    let type_126: string[];
                    export { type_126 as type };
                }
                export { growth_1 as growth };
                export namespace earningsCurrency {
                    let type_127: string[];
                    export { type_127 as type };
                }
            }
            export { properties_20 as properties };
            let required_19: string[];
            export { required_19 as required };
            let additionalProperties_20: {};
            export { additionalProperties_20 as additionalProperties };
        }
        namespace RevenueEstimate {
            let type_128: string;
            export { type_128 as type };
            export namespace properties_21 {
                export namespace avg_1 {
                    let type_129: string[];
                    export { type_129 as type };
                }
                export { avg_1 as avg };
                export namespace low_1 {
                    let type_130: string[];
                    export { type_130 as type };
                }
                export { low_1 as low };
                export namespace high_1 {
                    let type_131: string[];
                    export { type_131 as type };
                }
                export { high_1 as high };
                export namespace numberOfAnalysts_1 {
                    let type_132: string[];
                    export { type_132 as type };
                }
                export { numberOfAnalysts_1 as numberOfAnalysts };
                export namespace yearAgoRevenue {
                    let type_133: string[];
                    export { type_133 as type };
                }
                export namespace growth_2 {
                    let type_134: string[];
                    export { type_134 as type };
                }
                export { growth_2 as growth };
                export namespace revenueCurrency {
                    let type_135: string[];
                    export { type_135 as type };
                }
            }
            export { properties_21 as properties };
            let required_20: string[];
            export { required_20 as required };
            let additionalProperties_21: {};
            export { additionalProperties_21 as additionalProperties };
        }
        namespace EpsTrend {
            let type_136: string;
            export { type_136 as type };
            let properties_22: {
                current: {
                    type: string[];
                };
                "7daysAgo": {
                    type: string[];
                };
                "30daysAgo": {
                    type: string[];
                };
                "60daysAgo": {
                    type: string[];
                };
                "90daysAgo": {
                    type: string[];
                };
                epsTrendCurrency: {
                    type: string[];
                };
            };
            export { properties_22 as properties };
            let required_21: string[];
            export { required_21 as required };
            let additionalProperties_22: {};
            export { additionalProperties_22 as additionalProperties };
        }
        namespace EpsRevisions {
            let type_137: string;
            export { type_137 as type };
            export namespace properties_23 {
                namespace upLast7days {
                    let type_138: string[];
                    export { type_138 as type };
                }
                namespace upLast30days {
                    let type_139: string[];
                    export { type_139 as type };
                }
                namespace upLast90days {
                    let type_140: string[];
                    export { type_140 as type };
                }
                namespace downLast7Days {
                    let type_141: string[];
                    export { type_141 as type };
                }
                namespace downLast30days {
                    let type_142: string[];
                    export { type_142 as type };
                }
                namespace downLast90days {
                    let type_143: string[];
                    export { type_143 as type };
                }
                namespace epsRevisionsCurrency {
                    let type_144: string[];
                    export { type_144 as type };
                }
            }
            export { properties_23 as properties };
            let additionalProperties_23: {};
            export { additionalProperties_23 as additionalProperties };
        }
        namespace FinancialData {
            let type_145: string;
            export { type_145 as type };
            export namespace properties_24 {
                export namespace maxAge_12 {
                    let type_146: string;
                    export { type_146 as type };
                }
                export { maxAge_12 as maxAge };
                export namespace currentPrice {
                    let type_147: string;
                    export { type_147 as type };
                }
                export namespace targetHighPrice {
                    let type_148: string;
                    export { type_148 as type };
                }
                export namespace targetLowPrice {
                    let type_149: string;
                    export { type_149 as type };
                }
                export namespace targetMeanPrice {
                    let type_150: string;
                    export { type_150 as type };
                }
                export namespace targetMedianPrice {
                    let type_151: string;
                    export { type_151 as type };
                }
                export namespace recommendationMean {
                    let type_152: string;
                    export { type_152 as type };
                }
                export namespace recommendationKey {
                    let type_153: string;
                    export { type_153 as type };
                }
                export namespace numberOfAnalystOpinions {
                    let type_154: string;
                    export { type_154 as type };
                }
                export namespace totalCash {
                    let type_155: string;
                    export { type_155 as type };
                }
                export namespace totalCashPerShare {
                    let type_156: string;
                    export { type_156 as type };
                }
                export namespace ebitda {
                    let type_157: string;
                    export { type_157 as type };
                }
                export namespace totalDebt {
                    let type_158: string;
                    export { type_158 as type };
                }
                export namespace quickRatio {
                    let type_159: string;
                    export { type_159 as type };
                }
                export namespace currentRatio {
                    let type_160: string;
                    export { type_160 as type };
                }
                export namespace totalRevenue {
                    let type_161: string;
                    export { type_161 as type };
                }
                export namespace debtToEquity {
                    let type_162: string;
                    export { type_162 as type };
                }
                export namespace revenuePerShare {
                    let type_163: string;
                    export { type_163 as type };
                }
                export namespace returnOnAssets {
                    let type_164: string;
                    export { type_164 as type };
                }
                export namespace returnOnEquity {
                    let type_165: string;
                    export { type_165 as type };
                }
                export namespace grossProfits {
                    let type_166: string;
                    export { type_166 as type };
                }
                export namespace freeCashflow {
                    let type_167: string;
                    export { type_167 as type };
                }
                export namespace operatingCashflow {
                    let type_168: string;
                    export { type_168 as type };
                }
                export namespace earningsGrowth {
                    let type_169: string;
                    export { type_169 as type };
                }
                export namespace revenueGrowth {
                    let type_170: string;
                    export { type_170 as type };
                }
                export namespace grossMargins {
                    let type_171: string;
                    export { type_171 as type };
                }
                export namespace ebitdaMargins {
                    let type_172: string;
                    export { type_172 as type };
                }
                export namespace operatingMargins {
                    let type_173: string;
                    export { type_173 as type };
                }
                export namespace profitMargins {
                    let type_174: string;
                    export { type_174 as type };
                }
                export namespace financialCurrency_1 {
                    let type_175: string[];
                    export { type_175 as type };
                }
                export { financialCurrency_1 as financialCurrency };
            }
            export { properties_24 as properties };
            let required_22: string[];
            export { required_22 as required };
            let additionalProperties_24: {};
            export { additionalProperties_24 as additionalProperties };
        }
        namespace Ownership {
            let type_176: string;
            export { type_176 as type };
            export namespace properties_25 {
                export namespace maxAge_13 {
                    let type_177: string;
                    export { type_177 as type };
                }
                export { maxAge_13 as maxAge };
                export namespace ownershipList {
                    let type_178: string;
                    export { type_178 as type };
                    export namespace items_12 {
                        let $ref_48: string;
                        export { $ref_48 as $ref };
                    }
                    export { items_12 as items };
                }
            }
            export { properties_25 as properties };
            let required_23: string[];
            export { required_23 as required };
            let additionalProperties_25: {};
            export { additionalProperties_25 as additionalProperties };
        }
        namespace OwnershipList {
            let type_179: string;
            export { type_179 as type };
            export namespace properties_26 {
                export namespace maxAge_14 {
                    let type_180: string;
                    export { type_180 as type };
                }
                export { maxAge_14 as maxAge };
                export namespace reportDate {
                    let type_181: string;
                    export { type_181 as type };
                    let format_10: string;
                    export { format_10 as format };
                }
                export namespace organization {
                    let type_182: string;
                    export { type_182 as type };
                }
                export namespace pctHeld {
                    let type_183: string;
                    export { type_183 as type };
                }
                export namespace position {
                    let type_184: string;
                    export { type_184 as type };
                }
                export namespace value {
                    let type_185: string;
                    export { type_185 as type };
                }
                export namespace pctChange {
                    let type_186: string;
                    export { type_186 as type };
                }
            }
            export { properties_26 as properties };
            let required_24: string[];
            export { required_24 as required };
            let additionalProperties_26: {};
            export { additionalProperties_26 as additionalProperties };
        }
        namespace FundPerformance {
            let type_187: string;
            export { type_187 as type };
            export namespace properties_27 {
                export namespace maxAge_15 {
                    let type_188: string;
                    export { type_188 as type };
                }
                export { maxAge_15 as maxAge };
                export namespace loadAdjustedReturns {
                    let $ref_49: string;
                    export { $ref_49 as $ref };
                }
                export namespace rankInCategory {
                    let $ref_50: string;
                    export { $ref_50 as $ref };
                }
                export namespace performanceOverview {
                    let $ref_51: string;
                    export { $ref_51 as $ref };
                }
                export namespace performanceOverviewCat {
                    let $ref_52: string;
                    export { $ref_52 as $ref };
                }
                export namespace trailingReturns {
                    let $ref_53: string;
                    export { $ref_53 as $ref };
                }
                export namespace trailingReturnsNav {
                    let $ref_54: string;
                    export { $ref_54 as $ref };
                }
                export namespace trailingReturnsCat {
                    let $ref_55: string;
                    export { $ref_55 as $ref };
                }
                export namespace annualTotalReturns {
                    let $ref_56: string;
                    export { $ref_56 as $ref };
                }
                export namespace pastQuarterlyReturns {
                    let $ref_57: string;
                    export { $ref_57 as $ref };
                }
                export namespace riskOverviewStatistics {
                    let $ref_58: string;
                    export { $ref_58 as $ref };
                }
                export namespace riskOverviewStatisticsCat {
                    let $ref_59: string;
                    export { $ref_59 as $ref };
                }
                export namespace fundCategoryName {
                    let type_189: string;
                    export { type_189 as type };
                }
            }
            export { properties_27 as properties };
            let required_25: string[];
            export { required_25 as required };
            let additionalProperties_27: {};
            export { additionalProperties_27 as additionalProperties };
        }
        namespace PeriodRange {
            let type_190: string;
            export { type_190 as type };
            export namespace properties_28 {
                namespace asOfDate {
                    let type_191: string;
                    export { type_191 as type };
                    let format_11: string;
                    export { format_11 as format };
                }
                namespace ytd {
                    let type_192: string;
                    export { type_192 as type };
                }
                namespace oneMonth {
                    let type_193: string;
                    export { type_193 as type };
                }
                namespace threeMonth {
                    let type_194: string;
                    export { type_194 as type };
                }
                namespace oneYear {
                    let type_195: string;
                    export { type_195 as type };
                }
                namespace threeYear {
                    let type_196: string;
                    export { type_196 as type };
                }
                namespace fiveYear {
                    let type_197: string;
                    export { type_197 as type };
                }
                namespace tenYear {
                    let type_198: string;
                    export { type_198 as type };
                }
            }
            export { properties_28 as properties };
            let additionalProperties_28: {};
            export { additionalProperties_28 as additionalProperties };
        }
        namespace FundPerformancePerformanceOverview {
            let type_199: string;
            export { type_199 as type };
            export namespace properties_29 {
                export namespace asOfDate_1 {
                    let type_200: string;
                    export { type_200 as type };
                    let format_12: string;
                    export { format_12 as format };
                }
                export { asOfDate_1 as asOfDate };
                export namespace ytdReturnPct {
                    let type_201: string;
                    export { type_201 as type };
                }
                export namespace oneYearTotalReturn {
                    let type_202: string;
                    export { type_202 as type };
                }
                export namespace threeYearTotalReturn {
                    let type_203: string;
                    export { type_203 as type };
                }
                export namespace fiveYrAvgReturnPct {
                    let type_204: string;
                    export { type_204 as type };
                }
                export namespace morningStarReturnRating {
                    let type_205: string;
                    export { type_205 as type };
                }
                export namespace numYearsUp {
                    let type_206: string;
                    export { type_206 as type };
                }
                export namespace numYearsDown {
                    let type_207: string;
                    export { type_207 as type };
                }
                export namespace bestOneYrTotalReturn {
                    let type_208: string;
                    export { type_208 as type };
                }
                export namespace worstOneYrTotalReturn {
                    let type_209: string;
                    export { type_209 as type };
                }
                export namespace bestThreeYrTotalReturn {
                    let type_210: string;
                    export { type_210 as type };
                }
                export namespace worstThreeYrTotalReturn {
                    let type_211: string;
                    export { type_211 as type };
                }
            }
            export { properties_29 as properties };
            let additionalProperties_29: {};
            export { additionalProperties_29 as additionalProperties };
        }
        namespace FundPerformancePerformanceOverviewCat {
            let type_212: string;
            export { type_212 as type };
            export namespace properties_30 {
                export namespace ytdReturnPct_1 {
                    let type_213: string;
                    export { type_213 as type };
                }
                export { ytdReturnPct_1 as ytdReturnPct };
                export namespace fiveYrAvgReturnPct_1 {
                    let type_214: string;
                    export { type_214 as type };
                }
                export { fiveYrAvgReturnPct_1 as fiveYrAvgReturnPct };
                export namespace oneYearTotalReturn_1 {
                    let type_215: string;
                    export { type_215 as type };
                }
                export { oneYearTotalReturn_1 as oneYearTotalReturn };
                export namespace threeYearTotalReturn_1 {
                    let type_216: string;
                    export { type_216 as type };
                }
                export { threeYearTotalReturn_1 as threeYearTotalReturn };
            }
            export { properties_30 as properties };
            let additionalProperties_30: {};
            export { additionalProperties_30 as additionalProperties };
        }
        namespace FundPerformanceTrailingReturns {
            let type_217: string;
            export { type_217 as type };
            export namespace properties_31 {
                export namespace asOfDate_2 {
                    let type_218: string;
                    export { type_218 as type };
                    let format_13: string;
                    export { format_13 as format };
                }
                export { asOfDate_2 as asOfDate };
                export namespace ytd_1 {
                    let type_219: string;
                    export { type_219 as type };
                }
                export { ytd_1 as ytd };
                export namespace oneMonth_1 {
                    let type_220: string;
                    export { type_220 as type };
                }
                export { oneMonth_1 as oneMonth };
                export namespace threeMonth_1 {
                    let type_221: string;
                    export { type_221 as type };
                }
                export { threeMonth_1 as threeMonth };
                export namespace oneYear_1 {
                    let type_222: string;
                    export { type_222 as type };
                }
                export { oneYear_1 as oneYear };
                export namespace threeYear_1 {
                    let type_223: string;
                    export { type_223 as type };
                }
                export { threeYear_1 as threeYear };
                export namespace fiveYear_1 {
                    let type_224: string;
                    export { type_224 as type };
                }
                export { fiveYear_1 as fiveYear };
                export namespace tenYear_1 {
                    let type_225: string;
                    export { type_225 as type };
                }
                export { tenYear_1 as tenYear };
                export namespace lastBullMkt {
                    let type_226: string;
                    export { type_226 as type };
                }
                export namespace lastBearMkt {
                    let type_227: string;
                    export { type_227 as type };
                }
            }
            export { properties_31 as properties };
            export namespace additionalProperties_31 {
                let anyOf_2: {}[];
                export { anyOf_2 as anyOf };
            }
            export { additionalProperties_31 as additionalProperties };
        }
        namespace FundPerformanceReturns {
            let type_228: string;
            export { type_228 as type };
            export namespace properties_32 {
                namespace returns {
                    let type_229: string;
                    export { type_229 as type };
                    export namespace items_13 {
                        let $ref_60: string;
                        export { $ref_60 as $ref };
                    }
                    export { items_13 as items };
                }
                namespace returnsCat {
                    let type_230: string;
                    export { type_230 as type };
                    export namespace items_14 {
                        let $ref_61: string;
                        export { $ref_61 as $ref };
                    }
                    export { items_14 as items };
                }
            }
            export { properties_32 as properties };
            let required_26: string[];
            export { required_26 as required };
            let additionalProperties_32: {};
            export { additionalProperties_32 as additionalProperties };
        }
        namespace FundPerformanceReturnsRow {
            let type_231: string;
            export { type_231 as type };
            export namespace properties_33 {
                namespace year {
                    let type_232: string;
                    export { type_232 as type };
                }
                namespace annualValue {
                    let type_233: string;
                    export { type_233 as type };
                }
                namespace q1 {
                    let type_234: string;
                    export { type_234 as type };
                }
                namespace q2 {
                    let type_235: string;
                    export { type_235 as type };
                }
                namespace q3 {
                    let type_236: string;
                    export { type_236 as type };
                }
                namespace q4 {
                    let type_237: string;
                    export { type_237 as type };
                }
            }
            export { properties_33 as properties };
            let required_27: string[];
            export { required_27 as required };
            let additionalProperties_33: {};
            export { additionalProperties_33 as additionalProperties };
        }
        namespace FundPerformanceRiskOverviewStats {
            let type_238: string;
            export { type_238 as type };
            export namespace properties_34 {
                namespace riskStatistics {
                    let type_239: string;
                    export { type_239 as type };
                    export namespace items_15 {
                        let $ref_62: string;
                        export { $ref_62 as $ref };
                    }
                    export { items_15 as items };
                }
                namespace riskRating {
                    let type_240: string;
                    export { type_240 as type };
                }
            }
            export { properties_34 as properties };
            let required_28: string[];
            export { required_28 as required };
            let additionalProperties_34: {};
            export { additionalProperties_34 as additionalProperties };
        }
        namespace FundPerformanceRiskOverviewStatsRow {
            let type_241: string;
            export { type_241 as type };
            export namespace properties_35 {
                export namespace year_1 {
                    let type_242: string;
                    export { type_242 as type };
                }
                export { year_1 as year };
                export namespace alpha {
                    let type_243: string;
                    export { type_243 as type };
                }
                export namespace beta {
                    let type_244: string;
                    export { type_244 as type };
                }
                export namespace meanAnnualReturn {
                    let type_245: string;
                    export { type_245 as type };
                }
                export namespace rSquared {
                    let type_246: string;
                    export { type_246 as type };
                }
                export namespace stdDev {
                    let type_247: string;
                    export { type_247 as type };
                }
                export namespace sharpeRatio {
                    let type_248: string;
                    export { type_248 as type };
                }
                export namespace treynorRatio {
                    let type_249: string;
                    export { type_249 as type };
                }
            }
            export { properties_35 as properties };
            let required_29: string[];
            export { required_29 as required };
            let additionalProperties_35: {};
            export { additionalProperties_35 as additionalProperties };
        }
        namespace FundPerformanceRiskOverviewStatsCat {
            let type_250: string;
            export { type_250 as type };
            export namespace properties_36 {
                namespace riskStatisticsCat {
                    let type_251: string;
                    export { type_251 as type };
                    export namespace items_16 {
                        let $ref_63: string;
                        export { $ref_63 as $ref };
                    }
                    export { items_16 as items };
                }
            }
            export { properties_36 as properties };
            let required_30: string[];
            export { required_30 as required };
            let additionalProperties_36: {};
            export { additionalProperties_36 as additionalProperties };
        }
        namespace FundProfile {
            let type_252: string;
            export { type_252 as type };
            export namespace properties_37 {
                export namespace maxAge_16 {
                    let type_253: string;
                    export { type_253 as type };
                }
                export { maxAge_16 as maxAge };
                export namespace styleBoxUrl {
                    let type_254: string[];
                    export { type_254 as type };
                }
                export namespace family {
                    let type_255: string[];
                    export { type_255 as type };
                }
                export namespace categoryName {
                    let type_256: string[];
                    export { type_256 as type };
                }
                export namespace legalType {
                    let type_257: string[];
                    export { type_257 as type };
                }
                export namespace managementInfo {
                    let $ref_64: string;
                    export { $ref_64 as $ref };
                }
                export namespace feesExpensesInvestment {
                    let $ref_65: string;
                    export { $ref_65 as $ref };
                }
                export namespace feesExpensesInvestmentCat {
                    let $ref_66: string;
                    export { $ref_66 as $ref };
                }
                export namespace brokerages {
                    let type_258: string;
                    export { type_258 as type };
                    export namespace items_17 {
                        let $ref_67: string;
                        export { $ref_67 as $ref };
                    }
                    export { items_17 as items };
                }
                export namespace initInvestment {
                    let type_259: string;
                    export { type_259 as type };
                }
                export namespace initIraInvestment {
                    let type_260: string;
                    export { type_260 as type };
                }
                export namespace initAipInvestment {
                    let type_261: string;
                    export { type_261 as type };
                }
                export namespace subseqInvestment {
                    let type_262: string;
                    export { type_262 as type };
                }
                export namespace subseqIraInvestment {
                    let type_263: string;
                    export { type_263 as type };
                }
                export namespace subseqAipInvestment {
                    let type_264: string;
                    export { type_264 as type };
                }
            }
            export { properties_37 as properties };
            let required_31: string[];
            export { required_31 as required };
            let additionalProperties_37: {};
            export { additionalProperties_37 as additionalProperties };
        }
        namespace FundProfileManagementInfo {
            let type_265: string;
            export { type_265 as type };
            export namespace properties_38 {
                namespace managerName {
                    let type_266: string[];
                    export { type_266 as type };
                }
                namespace managerBio {
                    let type_267: string[];
                    export { type_267 as type };
                }
                namespace startdate {
                    let type_268: string;
                    export { type_268 as type };
                    let format_14: string;
                    export { format_14 as format };
                }
            }
            export { properties_38 as properties };
            let required_32: string[];
            export { required_32 as required };
            let additionalProperties_38: {};
            export { additionalProperties_38 as additionalProperties };
        }
        namespace FundProfileFeesExpensesInvestment {
            let type_269: string;
            export { type_269 as type };
            export namespace properties_39 {
                namespace annualHoldingsTurnover {
                    let type_270: string;
                    export { type_270 as type };
                }
                namespace annualReportExpenseRatio {
                    let type_271: string;
                    export { type_271 as type };
                }
                namespace grossExpRatio {
                    let type_272: string;
                    export { type_272 as type };
                }
                namespace netExpRatio {
                    let type_273: string;
                    export { type_273 as type };
                }
                namespace projectionValues {
                    let type_274: string;
                    export { type_274 as type };
                }
                namespace totalNetAssets {
                    let type_275: string;
                    export { type_275 as type };
                }
            }
            export { properties_39 as properties };
            let required_33: string[];
            export { required_33 as required };
            let additionalProperties_39: {};
            export { additionalProperties_39 as additionalProperties };
        }
        namespace FundProfileFeesExpensesInvestmentCat {
            let type_276: string;
            export { type_276 as type };
            export namespace properties_40 {
                export namespace annualHoldingsTurnover_1 {
                    let type_277: string;
                    export { type_277 as type };
                }
                export { annualHoldingsTurnover_1 as annualHoldingsTurnover };
                export namespace annualReportExpenseRatio_1 {
                    let type_278: string;
                    export { type_278 as type };
                }
                export { annualReportExpenseRatio_1 as annualReportExpenseRatio };
                export namespace grossExpRatio_1 {
                    let type_279: string;
                    export { type_279 as type };
                }
                export { grossExpRatio_1 as grossExpRatio };
                export namespace netExpRatio_1 {
                    let type_280: string;
                    export { type_280 as type };
                }
                export { netExpRatio_1 as netExpRatio };
                export namespace totalNetAssets_1 {
                    let type_281: string;
                    export { type_281 as type };
                }
                export { totalNetAssets_1 as totalNetAssets };
                export namespace projectionValuesCat {
                    let type_282: string;
                    export { type_282 as type };
                }
            }
            export { properties_40 as properties };
            let required_34: string[];
            export { required_34 as required };
            export namespace additionalProperties_40 {
                let anyOf_3: {}[];
                export { anyOf_3 as anyOf };
            }
            export { additionalProperties_40 as additionalProperties };
        }
        namespace FundProfileBrokerage {
            let type_283: string;
            export { type_283 as type };
            let additionalProperties_41: {};
            export { additionalProperties_41 as additionalProperties };
        }
        namespace IncomeStatementHistory {
            let type_284: string;
            export { type_284 as type };
            export namespace properties_41 {
                export namespace incomeStatementHistory_1 {
                    let type_285: string;
                    export { type_285 as type };
                    export namespace items_18 {
                        let $ref_68: string;
                        export { $ref_68 as $ref };
                    }
                    export { items_18 as items };
                }
                export { incomeStatementHistory_1 as incomeStatementHistory };
                export namespace maxAge_17 {
                    let type_286: string;
                    export { type_286 as type };
                }
                export { maxAge_17 as maxAge };
            }
            export { properties_41 as properties };
            let required_35: string[];
            export { required_35 as required };
            let additionalProperties_42: {};
            export { additionalProperties_42 as additionalProperties };
        }
        namespace IncomeStatementHistoryElement {
            let type_287: string;
            export { type_287 as type };
            export namespace properties_42 {
                export namespace maxAge_18 {
                    let type_288: string;
                    export { type_288 as type };
                }
                export { maxAge_18 as maxAge };
                export namespace endDate_3 {
                    let type_289: string;
                    export { type_289 as type };
                    let format_15: string;
                    export { format_15 as format };
                }
                export { endDate_3 as endDate };
                export namespace totalRevenue_1 {
                    let type_290: string;
                    export { type_290 as type };
                }
                export { totalRevenue_1 as totalRevenue };
                export namespace costOfRevenue {
                    let type_291: string;
                    export { type_291 as type };
                }
                export namespace grossProfit {
                    let type_292: string;
                    export { type_292 as type };
                }
                export namespace researchDevelopment {
                    let type_293: string;
                    export { type_293 as type };
                }
                export namespace sellingGeneralAdministrative {
                    let type_294: string;
                    export { type_294 as type };
                }
                export namespace nonRecurring {
                    let type_295: string;
                    export { type_295 as type };
                }
                export namespace otherOperatingExpenses {
                    let type_296: string;
                    export { type_296 as type };
                }
                export namespace totalOperatingExpenses {
                    let type_297: string;
                    export { type_297 as type };
                }
                export namespace operatingIncome {
                    let type_298: string;
                    export { type_298 as type };
                }
                export namespace totalOtherIncomeExpenseNet {
                    let type_299: string;
                    export { type_299 as type };
                }
                export namespace ebit {
                    let type_300: string;
                    export { type_300 as type };
                }
                export namespace interestExpense {
                    let type_301: string;
                    export { type_301 as type };
                }
                export namespace incomeBeforeTax {
                    let type_302: string;
                    export { type_302 as type };
                }
                export namespace incomeTaxExpense {
                    let type_303: string;
                    export { type_303 as type };
                }
                export namespace minorityInterest {
                    let type_304: string;
                    export { type_304 as type };
                }
                export namespace netIncomeFromContinuingOps {
                    let type_305: string;
                    export { type_305 as type };
                }
                export namespace discontinuedOperations {
                    let type_306: string;
                    export { type_306 as type };
                }
                export namespace extraordinaryItems {
                    let type_307: string;
                    export { type_307 as type };
                }
                export namespace effectOfAccountingCharges {
                    let type_308: string;
                    export { type_308 as type };
                }
                export namespace otherItems {
                    let type_309: string;
                    export { type_309 as type };
                }
                export namespace netIncome_1 {
                    let type_310: string;
                    export { type_310 as type };
                }
                export { netIncome_1 as netIncome };
                export namespace netIncomeApplicableToCommonShares {
                    let type_311: string;
                    export { type_311 as type };
                }
            }
            export { properties_42 as properties };
            let required_36: string[];
            export { required_36 as required };
            let additionalProperties_43: boolean;
            export { additionalProperties_43 as additionalProperties };
        }
        namespace IndexTrend {
            let type_312: string;
            export { type_312 as type };
            export namespace properties_43 {
                export namespace maxAge_19 {
                    let type_313: string;
                    export { type_313 as type };
                }
                export { maxAge_19 as maxAge };
                export namespace symbol {
                    let type_314: string;
                    export { type_314 as type };
                }
                export namespace peRatio {
                    let type_315: string;
                    export { type_315 as type };
                }
                export namespace pegRatio {
                    let type_316: string;
                    export { type_316 as type };
                }
                export namespace estimates {
                    let type_317: string;
                    export { type_317 as type };
                    export namespace items_19 {
                        let $ref_69: string;
                        export { $ref_69 as $ref };
                    }
                    export { items_19 as items };
                }
            }
            export { properties_43 as properties };
            let required_37: string[];
            export { required_37 as required };
            let additionalProperties_44: {};
            export { additionalProperties_44 as additionalProperties };
        }
        namespace Estimate {
            let type_318: string;
            export { type_318 as type };
            export namespace properties_44 {
                export namespace period_2 {
                    let type_319: string;
                    export { type_319 as type };
                }
                export { period_2 as period };
                export namespace growth_3 {
                    let type_320: string;
                    export { type_320 as type };
                }
                export { growth_3 as growth };
            }
            export { properties_44 as properties };
            let required_38: string[];
            export { required_38 as required };
            let additionalProperties_45: {};
            export { additionalProperties_45 as additionalProperties };
        }
        namespace Trend {
            let type_321: string;
            export { type_321 as type };
            export namespace properties_45 {
                export namespace maxAge_20 {
                    let type_322: string;
                    export { type_322 as type };
                }
                export { maxAge_20 as maxAge };
                export namespace symbol_1 {
                    let type_323: string;
                    export { type_323 as type };
                }
                export { symbol_1 as symbol };
                export namespace estimates_1 {
                    let type_324: string;
                    export { type_324 as type };
                    let items_20: {};
                    export { items_20 as items };
                }
                export { estimates_1 as estimates };
            }
            export { properties_45 as properties };
            let required_39: string[];
            export { required_39 as required };
            let additionalProperties_46: {};
            export { additionalProperties_46 as additionalProperties };
        }
        namespace Holders {
            let type_325: string;
            export { type_325 as type };
            export namespace properties_46 {
                export namespace holders {
                    let type_326: string;
                    export { type_326 as type };
                    export namespace items_21 {
                        let $ref_70: string;
                        export { $ref_70 as $ref };
                    }
                    export { items_21 as items };
                }
                export namespace maxAge_21 {
                    let type_327: string;
                    export { type_327 as type };
                }
                export { maxAge_21 as maxAge };
            }
            export { properties_46 as properties };
            let required_40: string[];
            export { required_40 as required };
            let additionalProperties_47: {};
            export { additionalProperties_47 as additionalProperties };
        }
        namespace Holder {
            let type_328: string;
            export { type_328 as type };
            export namespace properties_47 {
                export namespace maxAge_22 {
                    let type_329: string;
                    export { type_329 as type };
                }
                export { maxAge_22 as maxAge };
                export namespace name_2 {
                    let type_330: string;
                    export { type_330 as type };
                }
                export { name_2 as name };
                export namespace relation {
                    let anyOf_4: ({
                        $ref: string;
                        type?: undefined;
                    } | {
                        type: string;
                        $ref?: undefined;
                    })[];
                    export { anyOf_4 as anyOf };
                }
                export namespace url {
                    let type_331: string;
                    export { type_331 as type };
                }
                export namespace transactionDescription {
                    let type_332: string;
                    export { type_332 as type };
                }
                export namespace latestTransDate {
                    let type_333: string;
                    export { type_333 as type };
                    let format_16: string;
                    export { format_16 as format };
                }
                export namespace positionDirect {
                    let type_334: string;
                    export { type_334 as type };
                }
                export namespace positionDirectDate {
                    let type_335: string;
                    export { type_335 as type };
                    let format_17: string;
                    export { format_17 as format };
                }
                export namespace positionIndirect {
                    let type_336: string;
                    export { type_336 as type };
                }
                export namespace positionIndirectDate {
                    let type_337: string;
                    export { type_337 as type };
                    let format_18: string;
                    export { format_18 as format };
                }
                export namespace positionSummaryDate {
                    let type_338: string;
                    export { type_338 as type };
                    let format_19: string;
                    export { format_19 as format };
                }
            }
            export { properties_47 as properties };
            let required_41: string[];
            export { required_41 as required };
            let additionalProperties_48: {};
            export { additionalProperties_48 as additionalProperties };
        }
        namespace Relation {
            let type_339: string;
            export { type_339 as type };
            let _enum: string[];
            export { _enum as enum };
        }
        namespace InsiderTransactions {
            let type_340: string;
            export { type_340 as type };
            export namespace properties_48 {
                export namespace transactions {
                    let type_341: string;
                    export { type_341 as type };
                    export namespace items_22 {
                        let $ref_71: string;
                        export { $ref_71 as $ref };
                    }
                    export { items_22 as items };
                }
                export namespace maxAge_23 {
                    let type_342: string;
                    export { type_342 as type };
                }
                export { maxAge_23 as maxAge };
            }
            export { properties_48 as properties };
            let required_42: string[];
            export { required_42 as required };
            let additionalProperties_49: {};
            export { additionalProperties_49 as additionalProperties };
        }
        namespace Transaction {
            let type_343: string;
            export { type_343 as type };
            export namespace properties_49 {
                export namespace maxAge_24 {
                    let type_344: string;
                    export { type_344 as type };
                }
                export { maxAge_24 as maxAge };
                export namespace shares {
                    let type_345: string;
                    export { type_345 as type };
                }
                export namespace filerUrl {
                    let type_346: string;
                    export { type_346 as type };
                }
                export namespace transactionText {
                    let type_347: string;
                    export { type_347 as type };
                }
                export namespace filerName {
                    let type_348: string;
                    export { type_348 as type };
                }
                export namespace filerRelation {
                    let anyOf_5: ({
                        $ref: string;
                        type?: undefined;
                    } | {
                        type: string;
                        $ref?: undefined;
                    })[];
                    export { anyOf_5 as anyOf };
                }
                export namespace moneyText {
                    let type_349: string;
                    export { type_349 as type };
                }
                export namespace startDate_1 {
                    let type_350: string;
                    export { type_350 as type };
                    let format_20: string;
                    export { format_20 as format };
                }
                export { startDate_1 as startDate };
                export namespace ownership {
                    let anyOf_6: ({
                        $ref: string;
                        type?: undefined;
                    } | {
                        type: string;
                        $ref?: undefined;
                    })[];
                    export { anyOf_6 as anyOf };
                }
                export namespace value_1 {
                    let type_351: string;
                    export { type_351 as type };
                }
                export { value_1 as value };
            }
            export { properties_49 as properties };
            let required_43: string[];
            export { required_43 as required };
            let additionalProperties_50: {};
            export { additionalProperties_50 as additionalProperties };
        }
        namespace OwnershipEnum {
            let type_352: string;
            export { type_352 as type };
            let _enum_1: string[];
            export { _enum_1 as enum };
        }
        namespace MajorHoldersBreakdown {
            let type_353: string;
            export { type_353 as type };
            export namespace properties_50 {
                export namespace maxAge_25 {
                    let type_354: string;
                    export { type_354 as type };
                }
                export { maxAge_25 as maxAge };
                export namespace insidersPercentHeld {
                    let type_355: string;
                    export { type_355 as type };
                }
                export namespace institutionsPercentHeld {
                    let type_356: string;
                    export { type_356 as type };
                }
                export namespace institutionsFloatPercentHeld {
                    let type_357: string;
                    export { type_357 as type };
                }
                export namespace institutionsCount {
                    let type_358: string;
                    export { type_358 as type };
                }
            }
            export { properties_50 as properties };
            let required_44: string[];
            export { required_44 as required };
            let additionalProperties_51: {};
            export { additionalProperties_51 as additionalProperties };
        }
        namespace NetSharePurchaseActivity {
            let type_359: string;
            export { type_359 as type };
            export namespace properties_51 {
                export namespace maxAge_26 {
                    let type_360: string;
                    export { type_360 as type };
                }
                export { maxAge_26 as maxAge };
                export namespace period_3 {
                    let type_361: string;
                    export { type_361 as type };
                }
                export { period_3 as period };
                export namespace buyInfoCount {
                    let type_362: string;
                    export { type_362 as type };
                }
                export namespace buyInfoShares {
                    let type_363: string;
                    export { type_363 as type };
                }
                export namespace buyPercentInsiderShares {
                    let type_364: string;
                    export { type_364 as type };
                }
                export namespace sellInfoCount {
                    let type_365: string;
                    export { type_365 as type };
                }
                export namespace sellInfoShares {
                    let type_366: string;
                    export { type_366 as type };
                }
                export namespace sellPercentInsiderShares {
                    let type_367: string;
                    export { type_367 as type };
                }
                export namespace netInfoCount {
                    let type_368: string;
                    export { type_368 as type };
                }
                export namespace netInfoShares {
                    let type_369: string;
                    export { type_369 as type };
                }
                export namespace netPercentInsiderShares {
                    let type_370: string;
                    export { type_370 as type };
                }
                export namespace totalInsiderShares {
                    let type_371: string;
                    export { type_371 as type };
                }
            }
            export { properties_51 as properties };
            let required_45: string[];
            export { required_45 as required };
            let additionalProperties_52: {};
            export { additionalProperties_52 as additionalProperties };
        }
        namespace Price {
            let type_372: string;
            export { type_372 as type };
            export namespace properties_52 {
                export namespace averageDailyVolume10Day {
                    let type_373: string;
                    export { type_373 as type };
                }
                export namespace averageDailyVolume3Month {
                    let type_374: string;
                    export { type_374 as type };
                }
                export namespace exchange {
                    let type_375: string;
                    export { type_375 as type };
                }
                export namespace exchangeName {
                    let type_376: string;
                    export { type_376 as type };
                }
                export namespace exchangeDataDelayedBy {
                    let type_377: string;
                    export { type_377 as type };
                }
                export namespace maxAge_27 {
                    let type_378: string;
                    export { type_378 as type };
                }
                export { maxAge_27 as maxAge };
                export namespace postMarketChangePercent {
                    let type_379: string;
                    export { type_379 as type };
                }
                export namespace postMarketChange {
                    let type_380: string;
                    export { type_380 as type };
                }
                export namespace postMarketTime {
                    let type_381: string;
                    export { type_381 as type };
                    let format_21: string;
                    export { format_21 as format };
                }
                export namespace postMarketPrice {
                    let type_382: string;
                    export { type_382 as type };
                }
                export namespace postMarketSource {
                    let type_383: string;
                    export { type_383 as type };
                }
                export namespace preMarketChangePercent {
                    let type_384: string;
                    export { type_384 as type };
                }
                export namespace preMarketChange {
                    let type_385: string;
                    export { type_385 as type };
                }
                export namespace preMarketTime {
                    let type_386: string;
                    export { type_386 as type };
                    let format_22: string;
                    export { format_22 as format };
                }
                export namespace preMarketPrice {
                    let type_387: string;
                    export { type_387 as type };
                }
                export namespace preMarketSource {
                    let type_388: string;
                    export { type_388 as type };
                }
                export namespace priceHint {
                    let type_389: string;
                    export { type_389 as type };
                }
                export namespace regularMarketChangePercent {
                    let type_390: string;
                    export { type_390 as type };
                }
                export namespace regularMarketChange {
                    let type_391: string;
                    export { type_391 as type };
                }
                export namespace regularMarketTime {
                    let type_392: string;
                    export { type_392 as type };
                    let format_23: string;
                    export { format_23 as format };
                }
                export namespace regularMarketPrice {
                    let type_393: string;
                    export { type_393 as type };
                }
                export namespace regularMarketDayHigh {
                    let type_394: string;
                    export { type_394 as type };
                }
                export namespace regularMarketDayLow {
                    let type_395: string;
                    export { type_395 as type };
                }
                export namespace regularMarketVolume {
                    let type_396: string;
                    export { type_396 as type };
                }
                export namespace regularMarketPreviousClose {
                    let type_397: string;
                    export { type_397 as type };
                }
                export namespace regularMarketSource {
                    let type_398: string;
                    export { type_398 as type };
                }
                export namespace regularMarketOpen {
                    let type_399: string;
                    export { type_399 as type };
                }
                export namespace quoteSourceName {
                    let type_400: string;
                    export { type_400 as type };
                }
                export namespace quoteType_1 {
                    let type_401: string;
                    export { type_401 as type };
                }
                export { quoteType_1 as quoteType };
                export namespace symbol_2 {
                    let type_402: string;
                    export { type_402 as type };
                }
                export { symbol_2 as symbol };
                export namespace underlyingSymbol {
                    let type_403: string[];
                    export { type_403 as type };
                }
                export namespace shortName {
                    let type_404: string[];
                    export { type_404 as type };
                }
                export namespace longName {
                    let type_405: string[];
                    export { type_405 as type };
                }
                export namespace lastMarket {
                    let type_406: string[];
                    export { type_406 as type };
                }
                export namespace marketState {
                    let type_407: string;
                    export { type_407 as type };
                }
                export namespace marketCap {
                    let type_408: string;
                    export { type_408 as type };
                }
                export namespace currency_1 {
                    let type_409: string;
                    export { type_409 as type };
                }
                export { currency_1 as currency };
                export namespace currencySymbol {
                    let type_410: string;
                    export { type_410 as type };
                }
                export namespace fromCurrency {
                    let type_411: string[];
                    export { type_411 as type };
                }
                export namespace toCurrency {
                    let type_412: string[];
                    export { type_412 as type };
                }
                export namespace volume24Hr {
                    let type_413: string;
                    export { type_413 as type };
                }
                export namespace volumeAllCurrencies {
                    let type_414: string;
                    export { type_414 as type };
                }
                export namespace circulatingSupply {
                    let type_415: string;
                    export { type_415 as type };
                }
                export namespace expireDate {
                    let type_416: string;
                    export { type_416 as type };
                    let format_24: string;
                    export { format_24 as format };
                }
                export namespace openInterest {
                    let type_417: string;
                    export { type_417 as type };
                }
            }
            export { properties_52 as properties };
            let required_46: string[];
            export { required_46 as required };
            let additionalProperties_53: {};
            export { additionalProperties_53 as additionalProperties };
        }
        namespace QuoteType {
            let type_418: string;
            export { type_418 as type };
            export namespace properties_53 {
                export namespace exchange_1 {
                    let type_419: string;
                    export { type_419 as type };
                }
                export { exchange_1 as exchange };
                export namespace quoteType_2 {
                    let type_420: string;
                    export { type_420 as type };
                }
                export { quoteType_2 as quoteType };
                export namespace symbol_3 {
                    let type_421: string;
                    export { type_421 as type };
                }
                export { symbol_3 as symbol };
                export namespace underlyingSymbol_1 {
                    let type_422: string;
                    export { type_422 as type };
                }
                export { underlyingSymbol_1 as underlyingSymbol };
                export namespace shortName_1 {
                    let type_423: string[];
                    export { type_423 as type };
                }
                export { shortName_1 as shortName };
                export namespace longName_1 {
                    let type_424: string[];
                    export { type_424 as type };
                }
                export { longName_1 as longName };
                export namespace firstTradeDateEpochUtc {
                    let anyOf_7: ({
                        type: string;
                        format?: undefined;
                    } | {
                        type: string;
                        format: string;
                    })[];
                    export { anyOf_7 as anyOf };
                }
                export namespace timeZoneFullName {
                    let type_425: string;
                    export { type_425 as type };
                }
                export namespace timeZoneShortName {
                    let type_426: string;
                    export { type_426 as type };
                }
                export namespace uuid {
                    let type_427: string;
                    export { type_427 as type };
                }
                export namespace messageBoardId {
                    let type_428: string[];
                    export { type_428 as type };
                }
                export namespace gmtOffSetMilliseconds {
                    let type_429: string;
                    export { type_429 as type };
                }
                export namespace maxAge_28 {
                    let type_430: string;
                    export { type_430 as type };
                }
                export { maxAge_28 as maxAge };
            }
            export { properties_53 as properties };
            let required_47: string[];
            export { required_47 as required };
            let additionalProperties_54: {};
            export { additionalProperties_54 as additionalProperties };
        }
        namespace RecommendationTrend {
            let type_431: string;
            export { type_431 as type };
            export namespace properties_54 {
                export namespace trend_1 {
                    let type_432: string;
                    export { type_432 as type };
                    export namespace items_23 {
                        let $ref_72: string;
                        export { $ref_72 as $ref };
                    }
                    export { items_23 as items };
                }
                export { trend_1 as trend };
                export namespace maxAge_29 {
                    let type_433: string;
                    export { type_433 as type };
                }
                export { maxAge_29 as maxAge };
            }
            export { properties_54 as properties };
            let required_48: string[];
            export { required_48 as required };
            let additionalProperties_55: {};
            export { additionalProperties_55 as additionalProperties };
        }
        namespace RecommendationTrendTrend {
            let type_434: string;
            export { type_434 as type };
            export namespace properties_55 {
                export namespace period_4 {
                    let type_435: string;
                    export { type_435 as type };
                }
                export { period_4 as period };
                export namespace strongBuy {
                    let type_436: string;
                    export { type_436 as type };
                }
                export namespace buy {
                    let type_437: string;
                    export { type_437 as type };
                }
                export namespace hold {
                    let type_438: string;
                    export { type_438 as type };
                }
                export namespace sell {
                    let type_439: string;
                    export { type_439 as type };
                }
                export namespace strongSell {
                    let type_440: string;
                    export { type_440 as type };
                }
            }
            export { properties_55 as properties };
            let required_49: string[];
            export { required_49 as required };
            let additionalProperties_56: {};
            export { additionalProperties_56 as additionalProperties };
        }
        namespace SECFilings {
            let type_441: string;
            export { type_441 as type };
            export namespace properties_56 {
                export namespace filings {
                    let type_442: string;
                    export { type_442 as type };
                    export namespace items_24 {
                        let $ref_73: string;
                        export { $ref_73 as $ref };
                    }
                    export { items_24 as items };
                }
                export namespace maxAge_30 {
                    let type_443: string;
                    export { type_443 as type };
                }
                export { maxAge_30 as maxAge };
            }
            export { properties_56 as properties };
            let required_50: string[];
            export { required_50 as required };
            let additionalProperties_57: {};
            export { additionalProperties_57 as additionalProperties };
        }
        namespace Filing {
            let type_444: string;
            export { type_444 as type };
            export namespace properties_57 {
                export namespace date_3 {
                    let type_445: string;
                    export { type_445 as type };
                }
                export { date_3 as date };
                export namespace epochDate {
                    let type_446: string;
                    export { type_446 as type };
                    let format_25: string;
                    export { format_25 as format };
                }
                export namespace type_447 {
                    let type_448: string;
                    export { type_448 as type };
                    let _enum_2: string[];
                    export { _enum_2 as enum };
                }
                export { type_447 as type };
                export namespace title_1 {
                    let type_449: string;
                    export { type_449 as type };
                }
                export { title_1 as title };
                export namespace edgarUrl {
                    let type_450: string;
                    export { type_450 as type };
                }
                export namespace maxAge_31 {
                    let type_451: string;
                    export { type_451 as type };
                }
                export { maxAge_31 as maxAge };
                export namespace url_1 {
                    let type_452: string;
                    export { type_452 as type };
                }
                export { url_1 as url };
                export namespace exhibits {
                    let type_453: string;
                    export { type_453 as type };
                    export namespace items_25 {
                        let type_454: string;
                        export { type_454 as type };
                        export namespace properties_58 {
                            export namespace type_455 {
                                let type_456: string;
                                export { type_456 as type };
                            }
                            export { type_455 as type };
                            export namespace url_2 {
                                let type_457: string;
                                export { type_457 as type };
                            }
                            export { url_2 as url };
                            export namespace downloadUrl {
                                let type_458: string;
                                export { type_458 as type };
                            }
                        }
                        export { properties_58 as properties };
                        let required_51: string[];
                        export { required_51 as required };
                        let additionalProperties_58: boolean;
                        export { additionalProperties_58 as additionalProperties };
                    }
                    export { items_25 as items };
                }
            }
            export { properties_57 as properties };
            let required_52: string[];
            export { required_52 as required };
            let additionalProperties_59: {};
            export { additionalProperties_59 as additionalProperties };
        }
        namespace SummaryDetail {
            let type_459: string;
            export { type_459 as type };
            export namespace properties_59 {
                export namespace maxAge_32 {
                    let type_460: string;
                    export { type_460 as type };
                }
                export { maxAge_32 as maxAge };
                export namespace priceHint_1 {
                    let type_461: string;
                    export { type_461 as type };
                }
                export { priceHint_1 as priceHint };
                export namespace previousClose {
                    let type_462: string;
                    export { type_462 as type };
                }
                export namespace open {
                    let type_463: string;
                    export { type_463 as type };
                }
                export namespace dayLow {
                    let type_464: string;
                    export { type_464 as type };
                }
                export namespace dayHigh {
                    let type_465: string;
                    export { type_465 as type };
                }
                export namespace regularMarketPreviousClose_1 {
                    let type_466: string;
                    export { type_466 as type };
                }
                export { regularMarketPreviousClose_1 as regularMarketPreviousClose };
                export namespace regularMarketOpen_1 {
                    let type_467: string;
                    export { type_467 as type };
                }
                export { regularMarketOpen_1 as regularMarketOpen };
                export namespace regularMarketDayLow_1 {
                    let type_468: string;
                    export { type_468 as type };
                }
                export { regularMarketDayLow_1 as regularMarketDayLow };
                export namespace regularMarketDayHigh_1 {
                    let type_469: string;
                    export { type_469 as type };
                }
                export { regularMarketDayHigh_1 as regularMarketDayHigh };
                export namespace regularMarketVolume_1 {
                    let type_470: string;
                    export { type_470 as type };
                }
                export { regularMarketVolume_1 as regularMarketVolume };
                export namespace dividendRate {
                    let type_471: string;
                    export { type_471 as type };
                }
                export namespace dividendYield {
                    let type_472: string;
                    export { type_472 as type };
                }
                export namespace exDividendDate_1 {
                    let type_473: string;
                    export { type_473 as type };
                    let format_26: string;
                    export { format_26 as format };
                }
                export { exDividendDate_1 as exDividendDate };
                export namespace payoutRatio {
                    let type_474: string;
                    export { type_474 as type };
                }
                export namespace fiveYearAvgDividendYield {
                    let type_475: string;
                    export { type_475 as type };
                }
                export namespace beta_1 {
                    let type_476: string;
                    export { type_476 as type };
                }
                export { beta_1 as beta };
                export namespace trailingPE {
                    let type_477: string;
                    export { type_477 as type };
                }
                export namespace forwardPE {
                    let type_478: string;
                    export { type_478 as type };
                }
                export namespace volume {
                    let type_479: string;
                    export { type_479 as type };
                }
                export namespace averageVolume {
                    let type_480: string;
                    export { type_480 as type };
                }
                export namespace averageVolume10days {
                    let type_481: string;
                    export { type_481 as type };
                }
                export namespace averageDailyVolume10Day_1 {
                    let type_482: string;
                    export { type_482 as type };
                }
                export { averageDailyVolume10Day_1 as averageDailyVolume10Day };
                export namespace bid {
                    let type_483: string;
                    export { type_483 as type };
                }
                export namespace ask {
                    let type_484: string;
                    export { type_484 as type };
                }
                export namespace bidSize {
                    let type_485: string;
                    export { type_485 as type };
                }
                export namespace askSize {
                    let type_486: string;
                    export { type_486 as type };
                }
                export namespace marketCap_1 {
                    let type_487: string;
                    export { type_487 as type };
                }
                export { marketCap_1 as marketCap };
                export namespace fiftyDayAverage {
                    let type_488: string;
                    export { type_488 as type };
                }
                export namespace fiftyTwoWeekLow {
                    let type_489: string;
                    export { type_489 as type };
                }
                export namespace fiftyTwoWeekHigh {
                    let type_490: string;
                    export { type_490 as type };
                }
                export namespace twoHundredDayAverage {
                    let type_491: string;
                    export { type_491 as type };
                }
                export namespace priceToSalesTrailing12Months {
                    let type_492: string;
                    export { type_492 as type };
                }
                export namespace trailingAnnualDividendRate {
                    let type_493: string;
                    export { type_493 as type };
                }
                export namespace trailingAnnualDividendYield {
                    let type_494: string;
                    export { type_494 as type };
                }
                export namespace currency_2 {
                    let type_495: string;
                    export { type_495 as type };
                }
                export { currency_2 as currency };
                export namespace algorithm {
                    let type_496: string;
                    export { type_496 as type };
                }
                export namespace tradeable {
                    let type_497: string;
                    export { type_497 as type };
                }
                export namespace _yield {
                    let type_498: string;
                    export { type_498 as type };
                }
                export { _yield as yield };
                export namespace totalAssets {
                    let type_499: string;
                    export { type_499 as type };
                }
                export namespace navPrice {
                    let type_500: string;
                    export { type_500 as type };
                }
                export namespace ytdReturn {
                    let type_501: string;
                    export { type_501 as type };
                }
                export namespace fromCurrency_1 {
                    let type_502: string[];
                    export { type_502 as type };
                }
                export { fromCurrency_1 as fromCurrency };
                export namespace toCurrency_1 {
                    let type_503: string[];
                    export { type_503 as type };
                }
                export { toCurrency_1 as toCurrency };
                export namespace lastMarket_1 {
                    let type_504: string[];
                    export { type_504 as type };
                }
                export { lastMarket_1 as lastMarket };
                export namespace volume24Hr_1 {
                    let type_505: string;
                    export { type_505 as type };
                }
                export { volume24Hr_1 as volume24Hr };
                export namespace volumeAllCurrencies_1 {
                    let type_506: string;
                    export { type_506 as type };
                }
                export { volumeAllCurrencies_1 as volumeAllCurrencies };
                export namespace circulatingSupply_1 {
                    let type_507: string;
                    export { type_507 as type };
                }
                export { circulatingSupply_1 as circulatingSupply };
                export namespace startDate_2 {
                    let type_508: string;
                    export { type_508 as type };
                    let format_27: string;
                    export { format_27 as format };
                }
                export { startDate_2 as startDate };
                export namespace coinMarketCapLink {
                    let type_509: string[];
                    export { type_509 as type };
                }
                export namespace expireDate_1 {
                    let type_510: string;
                    export { type_510 as type };
                    let format_28: string;
                    export { format_28 as format };
                }
                export { expireDate_1 as expireDate };
                export namespace openInterest_1 {
                    let type_511: string;
                    export { type_511 as type };
                }
                export { openInterest_1 as openInterest };
                export namespace averageMaturity {
                    let type_512: string;
                    export { type_512 as type };
                }
            }
            export { properties_59 as properties };
            let required_53: string[];
            export { required_53 as required };
            let additionalProperties_60: {};
            export { additionalProperties_60 as additionalProperties };
        }
        namespace SummaryProfile {
            let type_513: string;
            export { type_513 as type };
            export namespace properties_60 {
                export namespace address1_1 {
                    let type_514: string;
                    export { type_514 as type };
                }
                export { address1_1 as address1 };
                export namespace address2_1 {
                    let type_515: string;
                    export { type_515 as type };
                }
                export { address2_1 as address2 };
                export namespace address3_1 {
                    let type_516: string;
                    export { type_516 as type };
                }
                export { address3_1 as address3 };
                export namespace city_1 {
                    let type_517: string;
                    export { type_517 as type };
                }
                export { city_1 as city };
                export namespace state_1 {
                    let type_518: string;
                    export { type_518 as type };
                }
                export { state_1 as state };
                export namespace zip_1 {
                    let type_519: string;
                    export { type_519 as type };
                }
                export { zip_1 as zip };
                export namespace country_1 {
                    let type_520: string;
                    export { type_520 as type };
                }
                export { country_1 as country };
                export namespace phone_1 {
                    let type_521: string;
                    export { type_521 as type };
                }
                export { phone_1 as phone };
                export namespace fax_1 {
                    let type_522: string;
                    export { type_522 as type };
                }
                export { fax_1 as fax };
                export namespace website_1 {
                    let type_523: string;
                    export { type_523 as type };
                }
                export { website_1 as website };
                export namespace industry_1 {
                    let type_524: string;
                    export { type_524 as type };
                }
                export { industry_1 as industry };
                export namespace industryDisp_1 {
                    let type_525: string;
                    export { type_525 as type };
                }
                export { industryDisp_1 as industryDisp };
                export namespace sector_1 {
                    let type_526: string;
                    export { type_526 as type };
                }
                export { sector_1 as sector };
                export namespace sectorDisp_1 {
                    let type_527: string;
                    export { type_527 as type };
                }
                export { sectorDisp_1 as sectorDisp };
                export namespace longBusinessSummary_1 {
                    let type_528: string;
                    export { type_528 as type };
                }
                export { longBusinessSummary_1 as longBusinessSummary };
                export namespace fullTimeEmployees_1 {
                    let type_529: string;
                    export { type_529 as type };
                }
                export { fullTimeEmployees_1 as fullTimeEmployees };
                export namespace companyOfficers_1 {
                    let type_530: string;
                    export { type_530 as type };
                    let items_26: {};
                    export { items_26 as items };
                }
                export { companyOfficers_1 as companyOfficers };
                export namespace maxAge_33 {
                    let type_531: string;
                    export { type_531 as type };
                }
                export { maxAge_33 as maxAge };
                export namespace twitter_1 {
                    let type_532: string;
                    export { type_532 as type };
                }
                export { twitter_1 as twitter };
                export namespace industryKey_1 {
                    let type_533: string;
                    export { type_533 as type };
                }
                export { industryKey_1 as industryKey };
                export namespace sectorKey_1 {
                    let type_534: string;
                    export { type_534 as type };
                }
                export { sectorKey_1 as sectorKey };
                export namespace irWebsite_1 {
                    let type_535: string;
                    export { type_535 as type };
                }
                export { irWebsite_1 as irWebsite };
                export namespace executiveTeam_1 {
                    let type_536: string;
                    export { type_536 as type };
                    let items_27: {};
                    export { items_27 as items };
                }
                export { executiveTeam_1 as executiveTeam };
                export namespace name_3 {
                    let type_537: string;
                    export { type_537 as type };
                }
                export { name_3 as name };
                export namespace startDate_3 {
                    let type_538: string;
                    export { type_538 as type };
                    let format_29: string;
                    export { format_29 as format };
                }
                export { startDate_3 as startDate };
                export namespace description_1 {
                    let type_539: string;
                    export { type_539 as type };
                }
                export { description_1 as description };
            }
            export { properties_60 as properties };
            let required_54: string[];
            export { required_54 as required };
            let additionalProperties_61: {};
            export { additionalProperties_61 as additionalProperties };
        }
        namespace TopHoldings {
            let type_540: string;
            export { type_540 as type };
            export namespace properties_61 {
                export namespace maxAge_34 {
                    let type_541: string;
                    export { type_541 as type };
                }
                export { maxAge_34 as maxAge };
                export namespace stockPosition {
                    let type_542: string;
                    export { type_542 as type };
                }
                export namespace bondPosition {
                    let type_543: string;
                    export { type_543 as type };
                }
                export namespace holdings {
                    let type_544: string;
                    export { type_544 as type };
                    export namespace items_28 {
                        let $ref_74: string;
                        export { $ref_74 as $ref };
                    }
                    export { items_28 as items };
                }
                export namespace equityHoldings {
                    let $ref_75: string;
                    export { $ref_75 as $ref };
                }
                export namespace bondHoldings {
                    let type_545: string;
                    export { type_545 as type };
                }
                export namespace bondRatings {
                    let type_546: string;
                    export { type_546 as type };
                    export namespace items_29 {
                        let $ref_76: string;
                        export { $ref_76 as $ref };
                    }
                    export { items_29 as items };
                }
                export namespace sectorWeightings {
                    let type_547: string;
                    export { type_547 as type };
                    export namespace items_30 {
                        let $ref_77: string;
                        export { $ref_77 as $ref };
                    }
                    export { items_30 as items };
                }
                export namespace cashPosition {
                    let type_548: string;
                    export { type_548 as type };
                }
                export namespace otherPosition {
                    let type_549: string;
                    export { type_549 as type };
                }
                export namespace preferredPosition {
                    let type_550: string;
                    export { type_550 as type };
                }
                export namespace convertiblePosition {
                    let type_551: string;
                    export { type_551 as type };
                }
            }
            export { properties_61 as properties };
            let required_55: string[];
            export { required_55 as required };
            let additionalProperties_62: {};
            export { additionalProperties_62 as additionalProperties };
        }
        namespace TopHoldingsHolding {
            let type_552: string;
            export { type_552 as type };
            export namespace properties_62 {
                export namespace symbol_4 {
                    let type_553: string;
                    export { type_553 as type };
                }
                export { symbol_4 as symbol };
                export namespace holdingName {
                    let type_554: string;
                    export { type_554 as type };
                }
                export namespace holdingPercent {
                    let type_555: string;
                    export { type_555 as type };
                }
            }
            export { properties_62 as properties };
            let required_56: string[];
            export { required_56 as required };
            let additionalProperties_63: {};
            export { additionalProperties_63 as additionalProperties };
        }
        namespace TopHoldingsEquityHoldings {
            let type_556: string;
            export { type_556 as type };
            export namespace properties_63 {
                namespace medianMarketCap {
                    let type_557: string;
                    export { type_557 as type };
                }
                namespace medianMarketCapCat {
                    let type_558: string;
                    export { type_558 as type };
                }
                namespace priceToBook {
                    let type_559: string;
                    export { type_559 as type };
                }
                namespace priceToBookCat {
                    let type_560: string;
                    export { type_560 as type };
                }
                namespace priceToCashflow {
                    let type_561: string;
                    export { type_561 as type };
                }
                namespace priceToCashflowCat {
                    let type_562: string;
                    export { type_562 as type };
                }
                namespace priceToEarnings {
                    let type_563: string;
                    export { type_563 as type };
                }
                namespace priceToEarningsCat {
                    let type_564: string;
                    export { type_564 as type };
                }
                namespace priceToSales {
                    let type_565: string;
                    export { type_565 as type };
                }
                namespace priceToSalesCat {
                    let type_566: string;
                    export { type_566 as type };
                }
                namespace threeYearEarningsGrowth {
                    let type_567: string;
                    export { type_567 as type };
                }
                namespace threeYearEarningsGrowthCat {
                    let type_568: string;
                    export { type_568 as type };
                }
            }
            export { properties_63 as properties };
            let required_57: string[];
            export { required_57 as required };
            let additionalProperties_64: {};
            export { additionalProperties_64 as additionalProperties };
        }
        namespace TopHoldingsBondRating {
            let type_569: string;
            export { type_569 as type };
            export namespace properties_64 {
                namespace a {
                    let type_570: string;
                    export { type_570 as type };
                }
                namespace aa {
                    let type_571: string;
                    export { type_571 as type };
                }
                namespace aaa {
                    let type_572: string;
                    export { type_572 as type };
                }
                namespace other {
                    let type_573: string;
                    export { type_573 as type };
                }
                namespace b {
                    let type_574: string;
                    export { type_574 as type };
                }
                namespace bb {
                    let type_575: string;
                    export { type_575 as type };
                }
                namespace bbb {
                    let type_576: string;
                    export { type_576 as type };
                }
                namespace below_b {
                    let type_577: string;
                    export { type_577 as type };
                }
                namespace us_government {
                    let type_578: string;
                    export { type_578 as type };
                }
            }
            export { properties_64 as properties };
            let additionalProperties_65: {};
            export { additionalProperties_65 as additionalProperties };
        }
        namespace TopHoldingsSectorWeighting {
            let type_579: string;
            export { type_579 as type };
            export namespace properties_65 {
                namespace realestate {
                    let type_580: string;
                    export { type_580 as type };
                }
                namespace consumer_cyclical {
                    let type_581: string;
                    export { type_581 as type };
                }
                namespace basic_materials {
                    let type_582: string;
                    export { type_582 as type };
                }
                namespace consumer_defensive {
                    let type_583: string;
                    export { type_583 as type };
                }
                namespace technology {
                    let type_584: string;
                    export { type_584 as type };
                }
                namespace communication_services {
                    let type_585: string;
                    export { type_585 as type };
                }
                namespace financial_services {
                    let type_586: string;
                    export { type_586 as type };
                }
                namespace utilities {
                    let type_587: string;
                    export { type_587 as type };
                }
                namespace industrials {
                    let type_588: string;
                    export { type_588 as type };
                }
                namespace energy {
                    let type_589: string;
                    export { type_589 as type };
                }
                namespace healthcare {
                    let type_590: string;
                    export { type_590 as type };
                }
            }
            export { properties_65 as properties };
            let additionalProperties_66: {};
            export { additionalProperties_66 as additionalProperties };
        }
        namespace UpgradeDowngradeHistory {
            let type_591: string;
            export { type_591 as type };
            export namespace properties_66 {
                export namespace history_1 {
                    let type_592: string;
                    export { type_592 as type };
                    export namespace items_31 {
                        let $ref_78: string;
                        export { $ref_78 as $ref };
                    }
                    export { items_31 as items };
                }
                export { history_1 as history };
                export namespace maxAge_35 {
                    let type_593: string;
                    export { type_593 as type };
                }
                export { maxAge_35 as maxAge };
            }
            export { properties_66 as properties };
            let required_58: string[];
            export { required_58 as required };
            let additionalProperties_67: {};
            export { additionalProperties_67 as additionalProperties };
        }
        namespace UpgradeDowngradeHistoryHistory {
            let type_594: string;
            export { type_594 as type };
            export namespace properties_67 {
                namespace epochGradeDate {
                    let type_595: string;
                    export { type_595 as type };
                    let format_30: string;
                    export { format_30 as format };
                }
                namespace firm {
                    let type_596: string;
                    export { type_596 as type };
                }
                namespace toGrade {
                    let $ref_79: string;
                    export { $ref_79 as $ref };
                }
                namespace fromGrade {
                    let $ref_80: string;
                    export { $ref_80 as $ref };
                }
                namespace action {
                    let $ref_81: string;
                    export { $ref_81 as $ref };
                }
            }
            export { properties_67 as properties };
            let required_59: string[];
            export { required_59 as required };
            let additionalProperties_68: {};
            export { additionalProperties_68 as additionalProperties };
        }
        namespace Grade {
            let type_597: string;
            export { type_597 as type };
            let _enum_3: string[];
            export { _enum_3 as enum };
        }
        namespace Action {
            let type_598: string;
            export { type_598 as type };
            let _enum_4: string[];
            export { _enum_4 as enum };
        }
    }
}
export default _default;
//# sourceMappingURL=quoteSummary-iface.schema.d.ts.map