declare namespace _default {
    let $schema: string;
    let $comment: string;
    namespace definitions {
        namespace ChartResultObject {
            let type: string;
            namespace properties {
                namespace meta {
                    let $ref: string;
                }
                namespace timestamp {
                    let type_1: string;
                    export { type_1 as type };
                    export namespace items {
                        let type_2: string;
                        export { type_2 as type };
                    }
                }
                namespace events {
                    let $ref_1: string;
                    export { $ref_1 as $ref };
                }
                namespace indicators {
                    let $ref_2: string;
                    export { $ref_2 as $ref };
                }
            }
            let required: string[];
            let additionalProperties: {};
        }
        namespace ChartMeta {
            let type_3: string;
            export { type_3 as type };
            export namespace properties_1 {
                namespace currency {
                    let type_4: string;
                    export { type_4 as type };
                }
                namespace symbol {
                    let type_5: string;
                    export { type_5 as type };
                }
                namespace exchangeName {
                    let type_6: string;
                    export { type_6 as type };
                }
                namespace instrumentType {
                    let type_7: string;
                    export { type_7 as type };
                }
                namespace fiftyTwoWeekHigh {
                    let type_8: string;
                    export { type_8 as type };
                }
                namespace fiftyTwoWeekLow {
                    let type_9: string;
                    export { type_9 as type };
                }
                namespace firstTradeDate {
                    let anyOf: ({
                        type: string;
                        format: string;
                    } | {
                        type: string;
                        format?: undefined;
                    })[];
                }
                namespace fullExchangeName {
                    let type_10: string;
                    export { type_10 as type };
                }
                namespace regularMarketTime {
                    let type_11: string;
                    export { type_11 as type };
                    export let format: string;
                }
                namespace gmtoffset {
                    let type_12: string;
                    export { type_12 as type };
                }
                namespace hasPrePostMarketData {
                    let type_13: string;
                    export { type_13 as type };
                }
                namespace timezone {
                    let type_14: string;
                    export { type_14 as type };
                }
                namespace exchangeTimezoneName {
                    let type_15: string;
                    export { type_15 as type };
                }
                namespace regularMarketPrice {
                    let type_16: string;
                    export { type_16 as type };
                }
                namespace chartPreviousClose {
                    let type_17: string;
                    export { type_17 as type };
                }
                namespace previousClose {
                    let type_18: string;
                    export { type_18 as type };
                }
                namespace regularMarketDayHigh {
                    let type_19: string;
                    export { type_19 as type };
                }
                namespace regularMarketDayLow {
                    let type_20: string;
                    export { type_20 as type };
                }
                namespace regularMarketVolume {
                    let type_21: string;
                    export { type_21 as type };
                }
                namespace longName {
                    let type_22: string;
                    export { type_22 as type };
                }
                namespace shortName {
                    let type_23: string;
                    export { type_23 as type };
                }
                namespace scale {
                    let type_24: string;
                    export { type_24 as type };
                }
                namespace priceHint {
                    let type_25: string;
                    export { type_25 as type };
                }
                namespace currentTradingPeriod {
                    let type_26: string;
                    export { type_26 as type };
                    export namespace properties_2 {
                        namespace pre {
                            let $ref_3: string;
                            export { $ref_3 as $ref };
                        }
                        namespace regular {
                            let $ref_4: string;
                            export { $ref_4 as $ref };
                        }
                        namespace post {
                            let $ref_5: string;
                            export { $ref_5 as $ref };
                        }
                    }
                    export { properties_2 as properties };
                    let required_1: string[];
                    export { required_1 as required };
                    let additionalProperties_1: {};
                    export { additionalProperties_1 as additionalProperties };
                }
                namespace tradingPeriods {
                    let anyOf_1: ({
                        $ref: string;
                        type?: undefined;
                        items?: undefined;
                    } | {
                        type: string;
                        items: {
                            type: string;
                            items: {
                                $ref: string;
                            };
                        };
                        $ref?: undefined;
                    })[];
                    export { anyOf_1 as anyOf };
                }
                namespace dataGranularity {
                    let type_27: string;
                    export { type_27 as type };
                }
                namespace range {
                    let type_28: string;
                    export { type_28 as type };
                }
                namespace validRanges {
                    let type_29: string;
                    export { type_29 as type };
                    export namespace items_1 {
                        let type_30: string;
                        export { type_30 as type };
                    }
                    export { items_1 as items };
                }
            }
            export { properties_1 as properties };
            let required_2: string[];
            export { required_2 as required };
            let additionalProperties_2: {};
            export { additionalProperties_2 as additionalProperties };
        }
        namespace ChartMetaTradingPeriod {
            let type_31: string;
            export { type_31 as type };
            export namespace properties_3 {
                export namespace timezone_1 {
                    let type_32: string;
                    export { type_32 as type };
                }
                export { timezone_1 as timezone };
                export namespace start {
                    let type_33: string;
                    export { type_33 as type };
                    let format_1: string;
                    export { format_1 as format };
                }
                export namespace end {
                    let type_34: string;
                    export { type_34 as type };
                    let format_2: string;
                    export { format_2 as format };
                }
                export namespace gmtoffset_1 {
                    let type_35: string;
                    export { type_35 as type };
                }
                export { gmtoffset_1 as gmtoffset };
            }
            export { properties_3 as properties };
            let required_3: string[];
            export { required_3 as required };
            let additionalProperties_3: {};
            export { additionalProperties_3 as additionalProperties };
        }
        namespace ChartMetaTradingPeriods {
            let type_36: string;
            export { type_36 as type };
            export namespace properties_4 {
                export namespace pre_1 {
                    let type_37: string;
                    export { type_37 as type };
                    export namespace items_2 {
                        let type_38: string;
                        export { type_38 as type };
                        export namespace items_3 {
                            let $ref_6: string;
                            export { $ref_6 as $ref };
                        }
                        export { items_3 as items };
                    }
                    export { items_2 as items };
                }
                export { pre_1 as pre };
                export namespace post_1 {
                    let type_39: string;
                    export { type_39 as type };
                    export namespace items_4 {
                        let type_40: string;
                        export { type_40 as type };
                        export namespace items_5 {
                            let $ref_7: string;
                            export { $ref_7 as $ref };
                        }
                        export { items_5 as items };
                    }
                    export { items_4 as items };
                }
                export { post_1 as post };
                export namespace regular_1 {
                    let type_41: string;
                    export { type_41 as type };
                    export namespace items_6 {
                        let type_42: string;
                        export { type_42 as type };
                        export namespace items_7 {
                            let $ref_8: string;
                            export { $ref_8 as $ref };
                        }
                        export { items_7 as items };
                    }
                    export { items_6 as items };
                }
                export { regular_1 as regular };
            }
            export { properties_4 as properties };
            let additionalProperties_4: {};
            export { additionalProperties_4 as additionalProperties };
        }
        namespace ChartEventsObject {
            let type_43: string;
            export { type_43 as type };
            export namespace properties_5 {
                namespace dividends {
                    let $ref_9: string;
                    export { $ref_9 as $ref };
                }
                namespace splits {
                    let $ref_10: string;
                    export { $ref_10 as $ref };
                }
            }
            export { properties_5 as properties };
            let additionalProperties_5: {};
            export { additionalProperties_5 as additionalProperties };
        }
        namespace ChartEventDividends {
            let type_44: string;
            export { type_44 as type };
            export namespace additionalProperties_6 {
                let $ref_11: string;
                export { $ref_11 as $ref };
            }
            export { additionalProperties_6 as additionalProperties };
        }
        namespace ChartEventDividend {
            let type_45: string;
            export { type_45 as type };
            export namespace properties_6 {
                namespace amount {
                    let type_46: string;
                    export { type_46 as type };
                }
                namespace date {
                    let type_47: string;
                    export { type_47 as type };
                    let format_3: string;
                    export { format_3 as format };
                }
            }
            export { properties_6 as properties };
            let required_4: string[];
            export { required_4 as required };
            let additionalProperties_7: {};
            export { additionalProperties_7 as additionalProperties };
        }
        namespace ChartEventSplits {
            let type_48: string;
            export { type_48 as type };
            export namespace additionalProperties_8 {
                let $ref_12: string;
                export { $ref_12 as $ref };
            }
            export { additionalProperties_8 as additionalProperties };
        }
        namespace ChartEventSplit {
            let type_49: string;
            export { type_49 as type };
            export namespace properties_7 {
                export namespace date_1 {
                    let type_50: string;
                    export { type_50 as type };
                    let format_4: string;
                    export { format_4 as format };
                }
                export { date_1 as date };
                export namespace numerator {
                    let type_51: string;
                    export { type_51 as type };
                }
                export namespace denominator {
                    let type_52: string;
                    export { type_52 as type };
                }
                export namespace splitRatio {
                    let type_53: string;
                    export { type_53 as type };
                }
            }
            export { properties_7 as properties };
            let required_5: string[];
            export { required_5 as required };
            let additionalProperties_9: {};
            export { additionalProperties_9 as additionalProperties };
        }
        namespace ChartIndicatorsObject {
            let type_54: string;
            export { type_54 as type };
            export namespace properties_8 {
                namespace quote {
                    let type_55: string;
                    export { type_55 as type };
                    export namespace items_8 {
                        let $ref_13: string;
                        export { $ref_13 as $ref };
                    }
                    export { items_8 as items };
                }
                namespace adjclose {
                    let type_56: string;
                    export { type_56 as type };
                    export namespace items_9 {
                        let $ref_14: string;
                        export { $ref_14 as $ref };
                    }
                    export { items_9 as items };
                }
            }
            export { properties_8 as properties };
            let required_6: string[];
            export { required_6 as required };
            let additionalProperties_10: {};
            export { additionalProperties_10 as additionalProperties };
        }
        namespace ChartIndicatorQuote {
            let type_57: string;
            export { type_57 as type };
            export namespace properties_9 {
                namespace high {
                    let type_58: string;
                    export { type_58 as type };
                    export namespace items_10 {
                        let type_59: string[];
                        export { type_59 as type };
                    }
                    export { items_10 as items };
                }
                namespace low {
                    let type_60: string;
                    export { type_60 as type };
                    export namespace items_11 {
                        let type_61: string[];
                        export { type_61 as type };
                    }
                    export { items_11 as items };
                }
                namespace open {
                    let type_62: string;
                    export { type_62 as type };
                    export namespace items_12 {
                        let type_63: string[];
                        export { type_63 as type };
                    }
                    export { items_12 as items };
                }
                namespace close {
                    let type_64: string;
                    export { type_64 as type };
                    export namespace items_13 {
                        let type_65: string[];
                        export { type_65 as type };
                    }
                    export { items_13 as items };
                }
                namespace volume {
                    let type_66: string;
                    export { type_66 as type };
                    export namespace items_14 {
                        let type_67: string[];
                        export { type_67 as type };
                    }
                    export { items_14 as items };
                }
            }
            export { properties_9 as properties };
            let required_7: string[];
            export { required_7 as required };
            let additionalProperties_11: {};
            export { additionalProperties_11 as additionalProperties };
        }
        namespace ChartIndicatorAdjclose {
            let type_68: string;
            export { type_68 as type };
            export namespace properties_10 {
                export namespace adjclose_1 {
                    let type_69: string;
                    export { type_69 as type };
                    export namespace items_15 {
                        let type_70: string[];
                        export { type_70 as type };
                    }
                    export { items_15 as items };
                }
                export { adjclose_1 as adjclose };
            }
            export { properties_10 as properties };
            let additionalProperties_12: {};
            export { additionalProperties_12 as additionalProperties };
        }
        namespace ChartResultArray {
            let type_71: string;
            export { type_71 as type };
            export namespace properties_11 {
                export namespace meta_1 {
                    let $ref_15: string;
                    export { $ref_15 as $ref };
                }
                export { meta_1 as meta };
                export namespace events_1 {
                    let $ref_16: string;
                    export { $ref_16 as $ref };
                }
                export { events_1 as events };
                export namespace quotes {
                    let type_72: string;
                    export { type_72 as type };
                    export namespace items_16 {
                        let $ref_17: string;
                        export { $ref_17 as $ref };
                    }
                    export { items_16 as items };
                }
            }
            export { properties_11 as properties };
            let required_8: string[];
            export { required_8 as required };
            let additionalProperties_13: boolean;
            export { additionalProperties_13 as additionalProperties };
        }
        namespace ChartEventsArray {
            let type_73: string;
            export { type_73 as type };
            export namespace properties_12 {
                export namespace dividends_1 {
                    let type_74: string;
                    export { type_74 as type };
                    export namespace items_17 {
                        let $ref_18: string;
                        export { $ref_18 as $ref };
                    }
                    export { items_17 as items };
                }
                export { dividends_1 as dividends };
                export namespace splits_1 {
                    let type_75: string;
                    export { type_75 as type };
                    export namespace items_18 {
                        let $ref_19: string;
                        export { $ref_19 as $ref };
                    }
                    export { items_18 as items };
                }
                export { splits_1 as splits };
            }
            export { properties_12 as properties };
            let additionalProperties_14: {};
            export { additionalProperties_14 as additionalProperties };
        }
        namespace ChartResultArrayQuote {
            let type_76: string;
            export { type_76 as type };
            export namespace properties_13 {
                export namespace date_2 {
                    let type_77: string;
                    export { type_77 as type };
                    let format_5: string;
                    export { format_5 as format };
                }
                export { date_2 as date };
                export namespace high_1 {
                    let type_78: string[];
                    export { type_78 as type };
                }
                export { high_1 as high };
                export namespace low_1 {
                    let type_79: string[];
                    export { type_79 as type };
                }
                export { low_1 as low };
                export namespace open_1 {
                    let type_80: string[];
                    export { type_80 as type };
                }
                export { open_1 as open };
                export namespace close_1 {
                    let type_81: string[];
                    export { type_81 as type };
                }
                export { close_1 as close };
                export namespace volume_1 {
                    let type_82: string[];
                    export { type_82 as type };
                }
                export { volume_1 as volume };
                export namespace adjclose_2 {
                    let type_83: string[];
                    export { type_83 as type };
                }
                export { adjclose_2 as adjclose };
            }
            export { properties_13 as properties };
            let required_9: string[];
            export { required_9 as required };
            let additionalProperties_15: {};
            export { additionalProperties_15 as additionalProperties };
        }
        namespace ChartOptions {
            let type_84: string;
            export { type_84 as type };
            export namespace properties_14 {
                export namespace period1 {
                    let anyOf_2: ({
                        type: string;
                        format: string;
                    } | {
                        type: string;
                        format?: undefined;
                    })[];
                    export { anyOf_2 as anyOf };
                }
                export namespace period2 {
                    let anyOf_3: ({
                        type: string;
                        format: string;
                    } | {
                        type: string;
                        format?: undefined;
                    })[];
                    export { anyOf_3 as anyOf };
                }
                export namespace useYfid {
                    let type_85: string;
                    export { type_85 as type };
                }
                export namespace interval {
                    let type_86: string;
                    export { type_86 as type };
                    let _enum: string[];
                    export { _enum as enum };
                }
                export namespace includePrePost {
                    let type_87: string;
                    export { type_87 as type };
                }
                export namespace events_2 {
                    let type_88: string;
                    export { type_88 as type };
                }
                export { events_2 as events };
                export namespace lang {
                    let type_89: string;
                    export { type_89 as type };
                }
                export namespace _return {
                    let type_90: string;
                    export { type_90 as type };
                    let _enum_1: string[];
                    export { _enum_1 as enum };
                }
                export { _return as return };
            }
            export { properties_14 as properties };
            let required_10: string[];
            export { required_10 as required };
            let additionalProperties_16: boolean;
            export { additionalProperties_16 as additionalProperties };
        }
        namespace ChartOptionsWithReturnArray {
            let type_91: string;
            export { type_91 as type };
            export namespace properties_15 {
                export namespace period1_1 {
                    let anyOf_4: ({
                        type: string;
                        format: string;
                    } | {
                        type: string;
                        format?: undefined;
                    })[];
                    export { anyOf_4 as anyOf };
                }
                export { period1_1 as period1 };
                export namespace period2_1 {
                    let anyOf_5: ({
                        type: string;
                        format: string;
                    } | {
                        type: string;
                        format?: undefined;
                    })[];
                    export { anyOf_5 as anyOf };
                }
                export { period2_1 as period2 };
                export namespace useYfid_1 {
                    let type_92: string;
                    export { type_92 as type };
                }
                export { useYfid_1 as useYfid };
                export namespace interval_1 {
                    let type_93: string;
                    export { type_93 as type };
                    let _enum_2: string[];
                    export { _enum_2 as enum };
                }
                export { interval_1 as interval };
                export namespace includePrePost_1 {
                    let type_94: string;
                    export { type_94 as type };
                }
                export { includePrePost_1 as includePrePost };
                export namespace events_3 {
                    let type_95: string;
                    export { type_95 as type };
                }
                export { events_3 as events };
                export namespace lang_1 {
                    let type_96: string;
                    export { type_96 as type };
                }
                export { lang_1 as lang };
                export namespace _return_1 {
                    let type_97: string;
                    export { type_97 as type };
                    let _const: string;
                    export { _const as const };
                }
                export { _return_1 as return };
            }
            export { properties_15 as properties };
            let additionalProperties_17: boolean;
            export { additionalProperties_17 as additionalProperties };
            let required_11: string[];
            export { required_11 as required };
        }
        namespace ChartOptionsWithReturnObject {
            let type_98: string;
            export { type_98 as type };
            export namespace properties_16 {
                export namespace period1_2 {
                    let anyOf_6: ({
                        type: string;
                        format: string;
                    } | {
                        type: string;
                        format?: undefined;
                    })[];
                    export { anyOf_6 as anyOf };
                }
                export { period1_2 as period1 };
                export namespace period2_2 {
                    let anyOf_7: ({
                        type: string;
                        format: string;
                    } | {
                        type: string;
                        format?: undefined;
                    })[];
                    export { anyOf_7 as anyOf };
                }
                export { period2_2 as period2 };
                export namespace useYfid_2 {
                    let type_99: string;
                    export { type_99 as type };
                }
                export { useYfid_2 as useYfid };
                export namespace interval_2 {
                    let type_100: string;
                    export { type_100 as type };
                    let _enum_3: string[];
                    export { _enum_3 as enum };
                }
                export { interval_2 as interval };
                export namespace includePrePost_2 {
                    let type_101: string;
                    export { type_101 as type };
                }
                export { includePrePost_2 as includePrePost };
                export namespace events_4 {
                    let type_102: string;
                    export { type_102 as type };
                }
                export { events_4 as events };
                export namespace lang_2 {
                    let type_103: string;
                    export { type_103 as type };
                }
                export { lang_2 as lang };
                export namespace _return_2 {
                    let type_104: string;
                    export { type_104 as type };
                    let _const_1: string;
                    export { _const_1 as const };
                }
                export { _return_2 as return };
            }
            export { properties_16 as properties };
            let required_12: string[];
            export { required_12 as required };
            let additionalProperties_18: boolean;
            export { additionalProperties_18 as additionalProperties };
        }
        let chart: {};
    }
}
export default _default;
//# sourceMappingURL=chart.schema.d.ts.map