export namespace ORTB_MAP {
    namespace imp {
        let invalid: boolean;
    }
    namespace cur {
        import type = TYPES.object;
        export { type };
        export let isArray: boolean;
        import childType = TYPES.string;
        export { childType };
    }
    namespace device {
        import type_1 = TYPES.object;
        export { type_1 as type };
        export namespace children {
            namespace w {
                import type_2 = TYPES.number;
                export { type_2 as type };
            }
            namespace h {
                import type_3 = TYPES.number;
                export { type_3 as type };
            }
        }
    }
    namespace site {
        import type_4 = TYPES.object;
        export { type_4 as type };
        export namespace children_1 {
            namespace name {
                import type_5 = TYPES.string;
                export { type_5 as type };
            }
            namespace domain {
                import type_6 = TYPES.string;
                export { type_6 as type };
            }
            namespace page {
                import type_7 = TYPES.string;
                export { type_7 as type };
            }
            namespace ref {
                import type_8 = TYPES.string;
                export { type_8 as type };
            }
            namespace keywords {
                import type_9 = TYPES.string;
                export { type_9 as type };
            }
            namespace search {
                import type_10 = TYPES.string;
                export { type_10 as type };
            }
            namespace cat {
                import type_11 = TYPES.object;
                export { type_11 as type };
                let isArray_1: boolean;
                export { isArray_1 as isArray };
                import childType_1 = TYPES.string;
                export { childType_1 as childType };
            }
            namespace sectioncat {
                import type_12 = TYPES.object;
                export { type_12 as type };
                let isArray_2: boolean;
                export { isArray_2 as isArray };
                import childType_2 = TYPES.string;
                export { childType_2 as childType };
            }
            namespace pagecat {
                import type_13 = TYPES.object;
                export { type_13 as type };
                let isArray_3: boolean;
                export { isArray_3 as isArray };
                import childType_3 = TYPES.string;
                export { childType_3 as childType };
            }
            namespace content {
                import type_14 = TYPES.object;
                export { type_14 as type };
                let isArray_4: boolean;
                export { isArray_4 as isArray };
                export namespace children_2 {
                    namespace data {
                        import type_15 = TYPES.object;
                        export { type_15 as type };
                        let isArray_5: boolean;
                        export { isArray_5 as isArray };
                        import childType_4 = TYPES.object;
                        export { childType_4 as childType };
                        export let required: string[];
                        export namespace children_3 {
                            export namespace segment {
                                import type_16 = TYPES.object;
                                export { type_16 as type };
                                let isArray_6: boolean;
                                export { isArray_6 as isArray };
                                import childType_5 = TYPES.object;
                                export { childType_5 as childType };
                                let required_1: string[];
                                export { required_1 as required };
                                export namespace children_4 {
                                    namespace id {
                                        import type_17 = TYPES.string;
                                        export { type_17 as type };
                                    }
                                }
                                export { children_4 as children };
                            }
                            export namespace name_1 {
                                import type_18 = TYPES.string;
                                export { type_18 as type };
                            }
                            export { name_1 as name };
                            export namespace ext {
                                import type_19 = TYPES.object;
                                export { type_19 as type };
                            }
                        }
                        export { children_3 as children };
                    }
                }
                export { children_2 as children };
            }
            namespace publisher {
                import type_20 = TYPES.object;
                export { type_20 as type };
                let isArray_7: boolean;
                export { isArray_7 as isArray };
                export namespace children_5 {
                    export namespace id_1 {
                        import type_21 = TYPES.string;
                        export { type_21 as type };
                    }
                    export { id_1 as id };
                    export namespace name_2 {
                        import type_22 = TYPES.string;
                        export { type_22 as type };
                    }
                    export { name_2 as name };
                    export namespace cat_1 {
                        import type_23 = TYPES.object;
                        export { type_23 as type };
                        let isArray_8: boolean;
                        export { isArray_8 as isArray };
                        import childType_6 = TYPES.string;
                        export { childType_6 as childType };
                    }
                    export { cat_1 as cat };
                    export namespace domain_1 {
                        import type_24 = TYPES.string;
                        export { type_24 as type };
                    }
                    export { domain_1 as domain };
                    export namespace ext_1 {
                        import type_25 = TYPES.object;
                        export { type_25 as type };
                        let isArray_9: boolean;
                        export { isArray_9 as isArray };
                    }
                    export { ext_1 as ext };
                }
                export { children_5 as children };
            }
        }
        export { children_1 as children };
    }
    namespace user {
        import type_26 = TYPES.object;
        export { type_26 as type };
        export namespace children_6 {
            export namespace yob {
                import type_27 = TYPES.number;
                export { type_27 as type };
                export let optoutApplies: boolean;
            }
            export namespace gender {
                import type_28 = TYPES.string;
                export { type_28 as type };
                let optoutApplies_1: boolean;
                export { optoutApplies_1 as optoutApplies };
            }
            export namespace keywords_1 {
                import type_29 = TYPES.string;
                export { type_29 as type };
            }
            export { keywords_1 as keywords };
            export namespace data_1 {
                import type_30 = TYPES.object;
                export { type_30 as type };
                let isArray_10: boolean;
                export { isArray_10 as isArray };
                import childType_7 = TYPES.object;
                export { childType_7 as childType };
                let required_2: string[];
                export { required_2 as required };
                export namespace children_7 {
                    export namespace segment_1 {
                        import type_31 = TYPES.object;
                        export { type_31 as type };
                        let isArray_11: boolean;
                        export { isArray_11 as isArray };
                        import childType_8 = TYPES.object;
                        export { childType_8 as childType };
                        let required_3: string[];
                        export { required_3 as required };
                        export namespace children_8 {
                            export namespace id_2 {
                                import type_32 = TYPES.string;
                                export { type_32 as type };
                            }
                            export { id_2 as id };
                        }
                        export { children_8 as children };
                    }
                    export { segment_1 as segment };
                    export namespace name_3 {
                        import type_33 = TYPES.string;
                        export { type_33 as type };
                    }
                    export { name_3 as name };
                    export namespace ext_2 {
                        import type_34 = TYPES.object;
                        export { type_34 as type };
                    }
                    export { ext_2 as ext };
                }
                export { children_7 as children };
            }
            export { data_1 as data };
        }
        export { children_6 as children };
    }
    namespace bcat {
        import type_35 = TYPES.object;
        export { type_35 as type };
        let isArray_12: boolean;
        export { isArray_12 as isArray };
        import childType_9 = TYPES.string;
        export { childType_9 as childType };
    }
    namespace badv {
        import type_36 = TYPES.object;
        export { type_36 as type };
        let isArray_13: boolean;
        export { isArray_13 as isArray };
        import childType_10 = TYPES.string;
        export { childType_10 as childType };
    }
    namespace source {
        import type_37 = TYPES.object;
        export { type_37 as type };
        export namespace children_9 {
            export namespace ext_3 {
                import type_38 = TYPES.object;
                export { type_38 as type };
                let isArray_14: boolean;
                export { isArray_14 as isArray };
            }
            export { ext_3 as ext };
            export namespace schain {
                import type_39 = TYPES.object;
                export { type_39 as type };
                export namespace children_10 {
                    export namespace complete {
                        import type_40 = TYPES.number;
                        export { type_40 as type };
                    }
                    export namespace ver {
                        import type_41 = TYPES.string;
                        export { type_41 as type };
                    }
                    export namespace nodes {
                        import type_42 = TYPES.object;
                        export { type_42 as type };
                        let isArray_15: boolean;
                        export { isArray_15 as isArray };
                        import childType_11 = TYPES.object;
                        export { childType_11 as childType };
                        let required_4: string[];
                        export { required_4 as required };
                        export namespace children_11 {
                            export namespace asi {
                                import type_43 = TYPES.string;
                                export { type_43 as type };
                            }
                            export namespace sid {
                                import type_44 = TYPES.string;
                                export { type_44 as type };
                            }
                            export namespace hp {
                                import type_45 = TYPES.number;
                                export { type_45 as type };
                            }
                            export namespace rid {
                                import type_46 = TYPES.string;
                                export { type_46 as type };
                            }
                            export namespace name_4 {
                                import type_47 = TYPES.string;
                                export { type_47 as type };
                            }
                            export { name_4 as name };
                            export namespace domain_2 {
                                import type_48 = TYPES.string;
                                export { type_48 as type };
                            }
                            export { domain_2 as domain };
                            export namespace ext_4 {
                                import type_49 = TYPES.object;
                                export { type_49 as type };
                            }
                            export { ext_4 as ext };
                        }
                        export { children_11 as children };
                    }
                    export namespace ext_5 {
                        import type_50 = TYPES.object;
                        export { type_50 as type };
                    }
                    export { ext_5 as ext };
                }
                export { children_10 as children };
                let required_5: string[];
                export { required_5 as required };
            }
        }
        export { children_9 as children };
    }
}
declare namespace TYPES {
    let string: string;
    let object: string;
    let number: string;
}
export {};