function add_component(
    proxyManager: UAProxyManager,
    obj: any,
    reference: ReferenceDescription,
    callback: (err?: Error) => void) {

    const session = proxyManager.session;

    const name = lowerFirstLetter(reference.browseName.name || "");

    proxyManager.getObject(reference.nodeId, (err?: Error | null, childObj?: any) => {

        // istanbul ignore else
        if (!err) {
            childObj = new ObjectExplorer({
                name,
                nodeId: reference.nodeId,
                parent: obj,
                proxyManager,
            });
            obj[name] = childObj;
            obj.$components.push(childObj);

            childObj.$resolve(callback);
        } else {
            callback(err);
        }
    });
}

            _.zip(outputArgsDef, callResult.outputArguments).forEach((pair: any) => {
                const arg = pair[0];
                const variant = pair[1];

                const propName = lowerFirstLetter(arg.name);
                outputArgs[propName] = variant.value;

            });

 function setUInt32(propName: string) {
     const lowerCase = utils.lowerFirstLetter(propName);
     if (!historyServerCapabilities.hasOwnProperty(lowerCase)) {
         throw new Error("cannot find " + lowerCase);
     }
     const value = defaultProperties[lowerCase];
     const prop = historyServerCapabilities.getChildByName(propName);
     prop.setValueFromSource({ dataType: DataType.UInt32, value });
 }

            session.read(nodesToRead, (err2: Error | null, dataValues?: DataValue[]) => {

                if (err2) {
                    return callback(err2);
                }
                if (!dataValues) {
                    return callback(new Error("Internal Error"));
                }

                for (let i = 0; i < dataValues.length; i++) {
                    const propName = lowerFirstLetter(properties[i]);
                    data[propName] = dataValues[i].value as Variant;
                }
                callback(null, data);
            });

function add_property(
    proxyManager: UAProxyManager,
    obj: any,
    reference: ReferenceDescription,
    callback: (err?: Error) => void
) {

    const session = proxyManager.session;

    const name = lowerFirstLetter(reference.browseName.name || "");

    obj[name] = new ProxyVariable(proxyManager, reference.nodeId, reference);
    obj.$properties[name] = obj[name];

    setImmediate(callback);
}

function buildField(fieldLight: FieldInterfaceOptions): FieldType {

    const category = figureOutFieldCategory(fieldLight);
    const schema = figureOutSchema(fieldLight, category);

    return {
        name: lowerFirstLetter(fieldLight.name),

        category,
        defaultValue: fieldLight.defaultValue,
        isArray: fieldLight.isArray,

        documentation: fieldLight.documentation,
        fieldType: fieldLight.fieldType,
        schema
    };
}

    function installMethod(methodName: string, toState: string) {

        let method = programStateMachine.getMethodByName(methodName);

        if (!method) {
            // 'method' has ModellingRule=OptionalPlaceholder and should be created from the type definition
            let methodToClone = programStateMachine.typeDefinitionObj.getMethodByName(methodName);
            if (!methodToClone) {
                methodToClone = programStateMachine.typeDefinitionObj!.subtypeOfObj!.getMethodByName(methodName)!;
            }
            methodToClone.clone({
                componentOf: programStateMachine
            });
            method = programStateMachine.getMethodByName(methodName)!;
            assert(method !== null, "Method clone should cause parent object to be extended");

        }
        assert(method.nodeClass === NodeClass.Method);

        method._getExecutableFlag = function(/* sessionContext: SessionContext */) {
            // must use  a function here to capture 'this'
            return MygetExecutableFlag(this as UAMethod, toState, methodName);
        };

        method.bindMethod(
          function(
            this: UAMethod,
            inputArguments: VariantLike[],
            context: SessionContext,
            callback: (err: Error | null, callMethodResult: CallMethodResultOptions) => void
          ) {
              const stateMachineW = this.parent! as StateMachine;
              // tslint:disable-next-line:no-console
              console.log("Boiler System :  " + methodName + " about to process");
              stateMachineW.setState(toState);
              callback(null, {
                  outputArguments: [],
                  statusCode: StatusCodes.Good,
              });
          });

        assert(programStateMachine.getMethodByName(methodName) !== null,
          "Method " + methodName + " should be added to parent object (checked with getMethodByName)");
        const lc_name = lowerFirstLetter(methodName);
    }

        const inputArguments: Variant[] = inputArgsDef.map((arg: any) => {

            const dataType = convertNodeIdToDataType(arg.dataType);

            const arrayType = (arg.valueRank === 1) ? VariantArrayType.Array : VariantArrayType.Scalar;

            // xx console.log("xxx ",arg.toString());
            const propName = lowerFirstLetter(arg.name);

            const value = inputArgs[propName];
            if (value === undefined) {
                throw new Error("expecting input argument " + propName);
            }
            if (arrayType === VariantArrayType.Array) {
                if (!_.isArray(value)) {
                    throw new Error("expecting value to be an Array or a TypedArray");
                }
            }
            return new Variant({arrayType, dataType, value});
        });

function addFolderElement(
    proxyManager: UAProxyManager,
    obj: any,
    reference: ReferenceDescription,
    callback: (err?: Error) => void
) {

    const session = proxyManager.session;

    const name = lowerFirstLetter(reference.browseName.name || "");

    const childObj = new ObjectExplorer({
        name,
        nodeId: reference.nodeId,
        parent: obj,
        proxyManager,
    });

    obj[name] = childObj;
    obj.$organizes.push(childObj);
    childObj.$resolve(callback);
}

function buildConstructorFromDefinition(
  addressSpace: AddressSpace,
  dataType: UADataType
) {

    if (doDebug) {
        debugLog("buildConstructorFromDefinition#", dataType.nodeId.toString());
    }

    assert(dataType.definition && _.isArray(dataType.definition));
    const enumeration = addressSpace.findDataType("Enumeration");

    const className = dataType.browseName.name!.replace("DataType", "");

    assert(enumeration, "Enumeration Type not found: please check your nodeset file");
    const structure = addressSpace.findDataType("Structure");
    assert(structure, "Structure Type not found: please check your nodeset file");

    const Constructor = new Function("options", "_extensionobject_construct.apply(this,arguments);");
    assert(_.isFunction(Constructor));
    Object.defineProperty(Constructor, "name", { value: className });

    (Constructor as any).definition = dataType.definition;
    (Constructor as any).dataType = dataType;
    util.inherits(Constructor, ExtensionObject);
    Constructor.prototype.encode = _extensionobject_encode;
    Constructor.prototype.decode = _extensionobject_decode;

    for (const field of dataType.definition) {

        if (field.valueRank === 1) {
            field.$$name$$ = lowerFirstLetter(field.name.replace("ListOf", ""));
        } else {
            field.$$name$$ = lowerFirstLetter(field.name);
        }
        const dataTypeId = resolveNodeId(field.dataType);
        const fieldDataType = addressSpace.findDataType(dataTypeId) as UADataType;
        if (!fieldDataType) {
            throw new Error(" cannot find description for object " + dataTypeId +
              ". Check that this node exists in the nodeset.xml file");
        }
        // check if  dataType is an enumeration or a structure or  a basic type
        field.$$dataTypeId$$ = dataTypeId;
        field.$$dataType$$ = fieldDataType;
        field.$$isEnum$$ = false;
        field.$$isStructure$$ = false;
        if (fieldDataType.isSupertypeOf(enumeration as any)) {
            field.$$isEnum$$ = true;
            // todo repair
            // makeEnumeration(fieldDataType);
        } else if (fieldDataType.isSupertypeOf(structure as any)) {
            field.$$isStructure$$ = true;
            const FieldConstructor = makeStructure(fieldDataType);
            assert(_.isFunction(FieldConstructor));
            // xx field
            field.$$func_encode$$ = struct_encode;
            field.$$func_decode$$ = struct_decode;
            field.$$Constructor$$ = FieldConstructor;
            field.$$initialize$$ = initialize_Structure.bind(null, field);
        } else {
            const stuff = findBuiltInType(fieldDataType.browseName.name);
            field.$$func_encode$$ = stuff.encode;
            field.$$func_decode$$ = stuff.decode;
            assert(_.isFunction(field.$$func_encode$$));
            assert(_.isFunction(field.$$func_decode$$));
            field.schema = stuff;
            field.$$initialize$$ = initialize_field.bind(null, field);
        }
        if (field.valueRank === 1) {
            field.$$initialize$$ = initialize_array.bind(null, field.$$initialize$$);
            field.$$func_encode$$ = encode_array.bind(null, field.$$func_encode$$);
            field.$$func_decode$$ = decode_array.bind(null, field.$$func_decode$$);
        }
    }

    // reconstruct _schema form
    const fields = [];
    for (const field of dataType.definition) {
        const data: any = {
            fieldType: field.$$dataType$$.browseName.name,
            isArray: (field.valueRank === 1),
            name: field.$$name$$
        };
        if (field.$$isEnum$$) {
            data.category = FieldCategory.enumeration;
        } else if (field.$$isStructure$$) {
            data.category = FieldCategory.complex;
            data.fieldTypeConstructor = field.$$Constructor$$;
        } else {
            data.category = FieldCategory.basic;
        }
        fields.push(data);
    }

    Constructor.prototype.schema = {
        fields,
        id: -1,
        name: className
    };
    return Constructor;
//.........这里部分代码省略.........