#[allow(bad_style)]
#[allow(unused_variables)]
impl ProcessJsonToPointers for FedexShipInput {
    fn collect(&self, json: Value) -> Result<Option<ns1__ValidateShipmentRequest>, Vec<String>> {
        let schema_val = from_str(JSON_SCHEMA_FOR_FedexShipInput).expect("40");
        let mut scope = json_schema::Scope::new();
        let r_schema = scope
            .compile_and_return(schema_val, false)
            .expect("The json schema is invalid. Please connact support");
        let validation_state = r_schema.validate(&json);
        if validation_state.errors.len() > 0 {
            let str_errors = validation_state
                .errors
                .into_iter()
                .map(|n_err| {
                    let err = n_err;
                    format!("{}: {}", err.get_path(), err.get_detail().unwrap_or(""))
                })
                .collect::<Vec<_>>();
            return Err(str_errors);
        }
        let mut root = {
            let mut ClientDetail = {
                let mut AccountNumber =
                    get_mut_prt_string(json["ClientDetail"]["AccountNumber"].clone(), true);
                let mut IntegratorId =
                    get_mut_prt_string(json["ClientDetail"]["IntegratorId"].clone(), false);
                let mut Localization = {
                    let mut LanguageCode = get_mut_prt_string(
                        json["ClientDetail"]["Localization"]["LanguageCode"].clone(),
                        true,
                    );
                    let mut LocaleCode =
                        get_mut_prt_string(json["ClientDetail"]["Localization"]["LocaleCode"].clone(), false);
                    let mut ret = if !real {
                        None
                    } else {
                        Some(ns1__Localization {
                            LanguageCode: LanguageCode,
                            LocaleCode: LocaleCode,
                        })
                    };
                    ret
                };
                let mut MeterNumber = get_mut_prt_string(json["ClientDetail"]["MeterNumber"].clone(), true);
                let mut ClientDetail_Localization_ov = if Localization.is_some() {
                    &mut Localization.expect("26") as *mut ns1__Localization
                } else {
                    std::ptr::null_mut() as *mut ns1__Localization
                };
                if json["ClientDetail"].is_null() {
                    return Err(vec![format!("Required obj '{}' not set", "ClientDetail")]);
                }
                let mut ret = if !real {
                    None
                } else {
                    Some(ns1__ClientDetail {
                        AccountNumber: AccountNumber,
                        IntegratorId: IntegratorId,
                        Localization: ClientDetail_Localization_ov,
                        MeterNumber: MeterNumber,
                    })
                };
                ret
            };
            let mut RequestedShipment = {
                let mut BlockInsightVisibility =
                    get_number(json["RequestedShipment"]["BlockInsightVisibility"].clone(), false);
                let mut ConfigurationData = {
                    let mut DangerousGoodsPackageConfigurations_tmp = vec![];
                    for (array_index, array_obj) in json["RequestedShipment"]["ConfigurationData"]
                        ["DangerousGoodsPackageConfigurations"]
                        .clone()
                        .as_array()
                        .expect("36")
                        .iter()
                        .enumerate()
                    {
                        let mut DangerousGoodsPackageConfigurations_arr_item = {
                            let mut Accessibility = get_number(array_obj["Accessibility"].clone(), false);
                            let mut AdditionalHandling =
                                get_mut_prt_string(array_obj["AdditionalHandling"].clone(), false);
                            let mut CargoAircraftOnly =
                                get_number(array_obj["CargoAircraftOnly"].clone(), false);
                            let mut Containers_tmp = vec![];
                            for (array_index, array_obj) in array_obj["Containers"]
                                .clone()
                                .as_array()
                                .expect("36")
                                .iter()
                                .enumerate()
                            {
                                let mut Containers_arr_item = {
                                    let mut ContainerType =
                                        get_mut_prt_string(array_obj["ContainerType"].clone(), false);
                                    let mut HazardousCommodities_tmp = vec![];
                                    for (array_index, array_obj) in array_obj["HazardousCommodities"]
                                        .clone()
                                        .as_array()
                                        .expect("36")
                                        .iter()
                                        .enumerate()
                                    {
                                        let mut HazardousCommodities_arr_item = {
                                            let mut Description = {
                                                let mut Authorization = get_mut_prt_string(
                                                    array_obj["Description"]["Authorization"].clone(),
                                                    false,
                                                );
                                                let mut HazardClass = get_mut_prt_string(
                                                    array_obj["Description"]["HazardClass"].clone(),
                                                    false,
                                                );
                                                let mut Id = get_mut_prt_string(
                                                    array_obj["Description"]["Id"].clone(),
                                                    false,
                                                );
                                                let mut LabelText = get_mut_prt_string(
                                                    array_obj["Description"]["LabelText"].clone(),
                                                    false,
                                                );
                                                let mut PackingDetails = {
                                                    let mut CargoAircraftOnly = get_number(
                                                        array_obj["Description"]["PackingDetails"]
                                                            ["CargoAircraftOnly"]
                                                            .clone(),
                                                        false,
                                                    );
                                                    let mut PackingInstructions = get_mut_prt_string(
                                                        array_obj["Description"]["PackingDetails"]
                                                            ["PackingInstructions"]
                                                            .clone(),
                                                        false,
                                                    );
                                                    let mut ret = if !real {
                                                        None
                                                    } else {
                                                        Some(ns1__HazardousCommodityPackingDetail {
                                                            CargoAircraftOnly: CargoAircraftOnly,
                                                            PackingInstructions: PackingInstructions,
                                                        })
                                                    };
                                                    ret
                                                };
                                                let mut PackingGroup = get_number(
                                                    array_obj["Description"]["PackingGroup"].clone(),
                                                    false,
                                                );
                                                let mut Percentage = get_mut_prt_string(
                                                    array_obj["Description"]["Percentage"].clone(),
                                                    false,
                                                );
                                                let mut ProcessingOptions_tmp = vec![];
                                                for (array_index, array_obj) in array_obj["Description"]
                                                    ["ProcessingOptions"]
                                                    .clone()
                                                    .as_array()
                                                    .expect("36")
                                                    .iter()
                                                    .enumerate()
                                                {
                                                    let mut ProcessingOptions_arr_item =
                                                        get_number(array_obj.clone(), false);
                                                    ProcessingOptions_tmp.push(ProcessingOptions_arr_item);
                                                }
                                                let ProcessingOptions = unsafe {
                                                    libc::malloc(
                                                        std::mem::size_of::<u32>()
                                                            * ProcessingOptions_tmp.len(),
                                                    )
                                                        as *mut u32
                                                };
                                                for i in 0..ProcessingOptions_tmp.len() {
                                                    unsafe {
                                                        ProcessingOptions
                                                            .offset(i as isize)
                                                            .write(ProcessingOptions_tmp[i])
                                                    };
                                                }
                                                let mut ProperShippingName = get_mut_prt_string(
                                                    array_obj["Description"]["ProperShippingName"].clone(),
                                                    false,
                                                );
                                                let mut ReportableQuantity = get_number(
                                                    array_obj["Description"]["ReportableQuantity"].clone(),
                                                    false,
                                                );
                                                let mut SequenceNumber = get_mut_prt_string(
                                                    array_obj["Description"]["SequenceNumber"].clone(),
                                                    false,
                                                );
                                                let mut SubsidiaryClasses_tmp = vec![];
                                                for (array_index, array_obj) in array_obj["Description"]
                                                    ["SubsidiaryClasses"]
                                                    .clone()
                                                    .as_array()
                                                    .expect("36")
                                                    .iter()
                                                    .enumerate()
                                                {
                                                    let mut SubsidiaryClasses_arr_item =
                                                        get_mut_prt_string(array_obj.clone(), false);
                                                    SubsidiaryClasses_tmp.push(SubsidiaryClasses_arr_item);
                                                }
                                                let SubsidiaryClasses = SubsidiaryClasses_tmp.as_mut_ptr();
                                                let mut TechnicalName = get_mut_prt_string(
                                                    array_obj["Description"]["TechnicalName"].clone(),
                                                    false,
                                                );
                                                let mut Description_PackingDetails_ov =
                                                    if PackingDetails.is_some() {
                                                        &mut PackingDetails.expect("26")
                                                            as *mut ns1__HazardousCommodityPackingDetail
                                                    } else {
                                                        std::ptr::null_mut()
                                                            as *mut ns1__HazardousCommodityPackingDetail
                                                    };
                                                let mut ret = if !real {
                                                    None
                                                } else {
                                                    Some(ns1__HazardousCommodityDescription {
                                                        Authorization: Authorization,
                                                        HazardClass: HazardClass,
                                                        Id: Id,
                                                        LabelText: LabelText,
                                                        PackingDetails: Description_PackingDetails_ov,
                                                        PackingGroup: PackingGroup,
                                                        Percentage: Percentage,
                                                        __sizeProcessingOptions: ProcessingOptions_tmp.len()
                                                            as i32,
                                                        ProcessingOptions: ProcessingOptions,
                                                        ProperShippingName: ProperShippingName,
                                                        ReportableQuantity: ReportableQuantity,
                                                        SequenceNumber: SequenceNumber,
                                                        __sizeSubsidiaryClasses: SubsidiaryClasses_tmp.len()
                                                            as i32,
                                                        SubsidiaryClasses: SubsidiaryClasses,
                                                        TechnicalName: TechnicalName,
                                                    })
                                                };
                                                std::mem::forget(ProcessingOptions_tmp);
                                                std::mem::forget(SubsidiaryClasses_tmp);
                                                ret
                                            };
                                            let mut InnerReceptacles_tmp = vec![];
                                            for (array_index, array_obj) in array_obj["InnerReceptacles"]
                                                .clone()
                                                .as_array()
                                                .expect("36")
                                                .iter()
                                                .enumerate()
                                            {
                                                let mut InnerReceptacles_arr_item = {
                                                    let mut Quantity = {
                                                        let mut Amount = get_mut_prt_string(
                                                            array_obj["Quantity"]["Amount"].clone(),
                                                            false,
                                                        );
                                                        let mut QuantityType = get_number(
                                                            array_obj["Quantity"]["QuantityType"].clone(),
                                                            false,
                                                        );
                                                        let mut Units = get_mut_prt_string(
                                                            array_obj["Quantity"]["Units"].clone(),
                                                            false,
                                                        );
                                                        let mut ret = if !real {
                                                            None
                                                        } else {
                                                            Some(ns1__HazardousCommodityQuantityDetail {
                                                                Amount: Amount,
                                                                QuantityType: QuantityType,
                                                                Units: Units,
                                                            })
                                                        };
                                                        ret
                                                    };
                                                    let mut InnerReceptacles_arr_item_Quantity_ov =
                                                        if Quantity.is_some() {
                                                            &mut Quantity.expect("26")
                                                                as *mut ns1__HazardousCommodityQuantityDetail
                                                        } else {
                                                            std::ptr::null_mut()
                                                                as *mut ns1__HazardousCommodityQuantityDetail
                                                        };
                                                    let mut ret = if !real {
                                                        None
                                                    } else {
                                                        Some(ns1__HazardousCommodityInnerReceptacleDetail {
                                                            Quantity: InnerReceptacles_arr_item_Quantity_ov,
                                                        })
                                                    };
                                                    ret
                                                };
                                                if InnerReceptacles_arr_item.is_some() {
                                                    InnerReceptacles_tmp
                                                        .push(InnerReceptacles_arr_item.expect("35"));
                                                }
                                            }
                                            let InnerReceptacles = unsafe {
                                                libc::malloc(
                                                    std::mem::size_of::<
                                                        ns1__HazardousCommodityInnerReceptacleDetail,
                                                    >()
                                                        * InnerReceptacles_tmp.len(),
                                                )
                                                    as *mut ns1__HazardousCommodityInnerReceptacleDetail
                                            };
                                            for i in 0..InnerReceptacles_tmp.len() {
                                                unsafe {
                                                    InnerReceptacles
                                                        .offset(i as isize)
                                                        .write(InnerReceptacles_tmp[i])
                                                };