declare namespace _default {
    let $schema: string;
    let $comment: string;
    namespace definitions {
        namespace HistoricalHistoryResult {
            let type: string;
            namespace items {
                let $ref: string;
            }
        }
        namespace HistoricalRowHistory {
            let type_1: string;
            export { type_1 as type };
            export namespace properties {
                namespace date {
                    let type_2: string;
                    export { type_2 as type };
                    export let format: string;
                }
                namespace open {
                    let type_3: string;
                    export { type_3 as type };
                }
                namespace high {
                    let type_4: string;
                    export { type_4 as type };
                }
                namespace low {
                    let type_5: string;
                    export { type_5 as type };
                }
                namespace close {
                    let type_6: string;
                    export { type_6 as type };
                }
                namespace adjClose {
                    let type_7: string;
                    export { type_7 as type };
                }
                namespace volume {
                    let type_8: string;
                    export { type_8 as type };
                }
            }
            export let required: string[];
            export let additionalProperties: {};
        }
        namespace HistoricalDividendsResult {
            let type_9: string;
            export { type_9 as type };
            export namespace items_1 {
                let $ref_1: string;
                export { $ref_1 as $ref };
            }
            export { items_1 as items };
        }
        namespace HistoricalRowDividend {
            let type_10: string;
            export { type_10 as type };
            export namespace properties_1 {
                export namespace date_1 {
                    let type_11: string;
                    export { type_11 as type };
                    let format_1: string;
                    export { format_1 as format };
                }
                export { date_1 as date };
                export namespace dividends {
                    let type_12: string;
                    export { type_12 as type };
                }
            }
            export { properties_1 as properties };
            let required_1: string[];
            export { required_1 as required };
            let additionalProperties_1: boolean;
            export { additionalProperties_1 as additionalProperties };
        }
        namespace HistoricalStockSplitsResult {
            let type_13: string;
            export { type_13 as type };
            export namespace items_2 {
                let $ref_2: string;
                export { $ref_2 as $ref };
            }
            export { items_2 as items };
        }
        namespace HistoricalRowStockSplit {
            let type_14: string;
            export { type_14 as type };
            export namespace properties_2 {
                export namespace date_2 {
                    let type_15: string;
                    export { type_15 as type };
                    let format_2: string;
                    export { format_2 as format };
                }
                export { date_2 as date };
                export namespace stockSplits {
                    let type_16: string;
                    export { type_16 as type };
                }
            }
            export { properties_2 as properties };
            let required_2: string[];
            export { required_2 as required };
            let additionalProperties_2: boolean;
            export { additionalProperties_2 as additionalProperties };
        }
        namespace HistoricalResult {
            let anyOf: {
                $ref: string;
            }[];
        }
        namespace HistoricalOptions {
            let type_17: string;
            export { type_17 as type };
            export namespace properties_3 {
                namespace period1 {
                    let anyOf_1: ({
                        type: string;
                        format: string;
                    } | {
                        type: string;
                        format?: undefined;
                    })[];
                    export { anyOf_1 as anyOf };
                }
                namespace period2 {
                    let anyOf_2: ({
                        type: string;
                        format: string;
                    } | {
                        type: string;
                        format?: undefined;
                    })[];
                    export { anyOf_2 as anyOf };
                }
                namespace interval {
                    let type_18: string;
                    export { type_18 as type };
                    let _enum: string[];
                    export { _enum as enum };
                }
                namespace events {
                    let type_19: string;
                    export { type_19 as type };
                    let _enum_1: string[];
                    export { _enum_1 as enum };
                }
                namespace includeAdjustedClose {
                    let type_20: string;
                    export { type_20 as type };
                }
            }
            export { properties_3 as properties };
            let required_3: string[];
            export { required_3 as required };
            let additionalProperties_3: boolean;
            export { additionalProperties_3 as additionalProperties };
        }
        namespace HistoricalOptionsEventsHistory {
            let type_21: string;
            export { type_21 as type };
            export namespace properties_4 {
                export namespace period1_1 {
                    let anyOf_3: ({
                        type: string;
                        format: string;
                    } | {
                        type: string;
                        format?: undefined;
                    })[];
                    export { anyOf_3 as anyOf };
                }
                export { period1_1 as period1 };
                export namespace period2_1 {
                    let anyOf_4: ({
                        type: string;
                        format: string;
                    } | {
                        type: string;
                        format?: undefined;
                    })[];
                    export { anyOf_4 as anyOf };
                }
                export { period2_1 as period2 };
                export namespace interval_1 {
                    let type_22: string;
                    export { type_22 as type };
                    let _enum_2: string[];
                    export { _enum_2 as enum };
                }
                export { interval_1 as interval };
                export namespace events_1 {
                    let type_23: string;
                    export { type_23 as type };
                    let _const: string;
                    export { _const as const };
                }
                export { events_1 as events };
                export namespace includeAdjustedClose_1 {
                    let type_24: string;
                    export { type_24 as type };
                }
                export { includeAdjustedClose_1 as includeAdjustedClose };
            }
            export { properties_4 as properties };
            let additionalProperties_4: boolean;
            export { additionalProperties_4 as additionalProperties };
            let required_4: string[];
            export { required_4 as required };
        }
        namespace HistoricalOptionsEventsDividends {
            let type_25: string;
            export { type_25 as type };
            export namespace properties_5 {
                export namespace period1_2 {
                    let anyOf_5: ({
                        type: string;
                        format: string;
                    } | {
                        type: string;
                        format?: undefined;
                    })[];
                    export { anyOf_5 as anyOf };
                }
                export { period1_2 as period1 };
                export namespace period2_2 {
                    let anyOf_6: ({
                        type: string;
                        format: string;
                    } | {
                        type: string;
                        format?: undefined;
                    })[];
                    export { anyOf_6 as anyOf };
                }
                export { period2_2 as period2 };
                export namespace interval_2 {
                    let type_26: string;
                    export { type_26 as type };
                    let _enum_3: string[];
                    export { _enum_3 as enum };
                }
                export { interval_2 as interval };
                export namespace events_2 {
                    let type_27: string;
                    export { type_27 as type };
                    let _const_1: string;
                    export { _const_1 as const };
                }
                export { events_2 as events };
                export namespace includeAdjustedClose_2 {
                    let type_28: string;
                    export { type_28 as type };
                }
                export { includeAdjustedClose_2 as includeAdjustedClose };
            }
            export { properties_5 as properties };
            let required_5: string[];
            export { required_5 as required };
            let additionalProperties_5: boolean;
            export { additionalProperties_5 as additionalProperties };
        }
        namespace HistoricalOptionsEventsSplit {
            let type_29: string;
            export { type_29 as type };
            export namespace properties_6 {
                export namespace period1_3 {
                    let anyOf_7: ({
                        type: string;
                        format: string;
                    } | {
                        type: string;
                        format?: undefined;
                    })[];
                    export { anyOf_7 as anyOf };
                }
                export { period1_3 as period1 };
                export namespace period2_3 {
                    let anyOf_8: ({
                        type: string;
                        format: string;
                    } | {
                        type: string;
                        format?: undefined;
                    })[];
                    export { anyOf_8 as anyOf };
                }
                export { period2_3 as period2 };
                export namespace interval_3 {
                    let type_30: string;
                    export { type_30 as type };
                    let _enum_4: string[];
                    export { _enum_4 as enum };
                }
                export { interval_3 as interval };
                export namespace events_3 {
                    let type_31: string;
                    export { type_31 as type };
                    let _const_2: string;
                    export { _const_2 as const };
                }
                export { events_3 as events };
                export namespace includeAdjustedClose_3 {
                    let type_32: string;
                    export { type_32 as type };
                }
                export { includeAdjustedClose_3 as includeAdjustedClose };
            }
            export { properties_6 as properties };
            let required_6: string[];
            export { required_6 as required };
            let additionalProperties_6: boolean;
            export { additionalProperties_6 as additionalProperties };
        }
        let nullFieldCount: {};
        let historical: {};
    }
}
export default _default;
//# sourceMappingURL=historical.schema.d.ts.map