android-Debug/gen/codelabs/mojo_examples/mojom/interface.mojom.js

// codelabs/mojo_examples/mojom/interface.mojom.js is auto generated by mojom_bindings_generator.py, do not edit

// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

'use strict';

(function() {
  var mojomId = 'codelabs/mojo_examples/mojom/interface.mojom';
  if (mojo.internal.isMojomLoaded(mojomId)) {
    console.warn('The following mojom is loaded multiple times: ' + mojomId);
    return;
  }
  mojo.internal.markMojomLoaded(mojomId);
  var bindings = mojo;
  var associatedBindings = mojo;
  var codec = mojo.internal;
  var validator = mojo.internal;

  var exports = mojo.internal.exposeNamespace('codelabs.mojom');



  function ObjectA_DoA_Params(values) {
    this.initDefaults_();
    this.initFields_(values);
  }


  ObjectA_DoA_Params.prototype.initDefaults_ = function() {
  };
  ObjectA_DoA_Params.prototype.initFields_ = function(fields) {
    for(var field in fields) {
        if (this.hasOwnProperty(field))
          this[field] = fields[field];
    }
  };

  ObjectA_DoA_Params.validate = function(messageValidator, offset) {
    var err;
    err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
    if (err !== validator.validationError.NONE)
        return err;

    var kVersionSizes = [
      {version: 0, numBytes: 8}
    ];
    err = messageValidator.validateStructVersion(offset, kVersionSizes);
    if (err !== validator.validationError.NONE)
        return err;

    return validator.validationError.NONE;
  };

  ObjectA_DoA_Params.encodedSize = codec.kStructHeaderSize + 0;

  ObjectA_DoA_Params.decode = function(decoder) {
    var packed;
    var val = new ObjectA_DoA_Params();
    var numberOfBytes = decoder.readUint32();
    var version = decoder.readUint32();
    return val;
  };

  ObjectA_DoA_Params.encode = function(encoder, val) {
    var packed;
    encoder.writeUint32(ObjectA_DoA_Params.encodedSize);
    encoder.writeUint32(0);
  };
  function ObjectB_DoB_Params(values) {
    this.initDefaults_();
    this.initFields_(values);
  }


  ObjectB_DoB_Params.prototype.initDefaults_ = function() {
  };
  ObjectB_DoB_Params.prototype.initFields_ = function(fields) {
    for(var field in fields) {
        if (this.hasOwnProperty(field))
          this[field] = fields[field];
    }
  };

  ObjectB_DoB_Params.validate = function(messageValidator, offset) {
    var err;
    err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
    if (err !== validator.validationError.NONE)
        return err;

    var kVersionSizes = [
      {version: 0, numBytes: 8}
    ];
    err = messageValidator.validateStructVersion(offset, kVersionSizes);
    if (err !== validator.validationError.NONE)
        return err;

    return validator.validationError.NONE;
  };

  ObjectB_DoB_Params.encodedSize = codec.kStructHeaderSize + 0;

  ObjectB_DoB_Params.decode = function(decoder) {
    var packed;
    var val = new ObjectB_DoB_Params();
    var numberOfBytes = decoder.readUint32();
    var version = decoder.readUint32();
    return val;
  };

  ObjectB_DoB_Params.encode = function(encoder, val) {
    var packed;
    encoder.writeUint32(ObjectB_DoB_Params.encodedSize);
    encoder.writeUint32(0);
  };
  function AssociatedProcess_SetProcess_Params(values) {
    this.initDefaults_();
    this.initFields_(values);
  }


  AssociatedProcess_SetProcess_Params.prototype.initDefaults_ = function() {
    this.process = new bindings.InterfaceRequest();
  };
  AssociatedProcess_SetProcess_Params.prototype.initFields_ = function(fields) {
    for(var field in fields) {
        if (this.hasOwnProperty(field))
          this[field] = fields[field];
    }
  };

  AssociatedProcess_SetProcess_Params.validate = function(messageValidator, offset) {
    var err;
    err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
    if (err !== validator.validationError.NONE)
        return err;

    var kVersionSizes = [
      {version: 0, numBytes: 16}
    ];
    err = messageValidator.validateStructVersion(offset, kVersionSizes);
    if (err !== validator.validationError.NONE)
        return err;


    // validate AssociatedProcess_SetProcess_Params.process
    err = messageValidator.validateInterfaceRequest(offset + codec.kStructHeaderSize + 0, false)
    if (err !== validator.validationError.NONE)
        return err;

    return validator.validationError.NONE;
  };

  AssociatedProcess_SetProcess_Params.encodedSize = codec.kStructHeaderSize + 8;

  AssociatedProcess_SetProcess_Params.decode = function(decoder) {
    var packed;
    var val = new AssociatedProcess_SetProcess_Params();
    var numberOfBytes = decoder.readUint32();
    var version = decoder.readUint32();
    val.process =
        decoder.decodeStruct(codec.InterfaceRequest);
    decoder.skip(1);
    decoder.skip(1);
    decoder.skip(1);
    decoder.skip(1);
    return val;
  };

  AssociatedProcess_SetProcess_Params.encode = function(encoder, val) {
    var packed;
    encoder.writeUint32(AssociatedProcess_SetProcess_Params.encodedSize);
    encoder.writeUint32(0);
    encoder.encodeStruct(codec.InterfaceRequest, val.process);
    encoder.skip(1);
    encoder.skip(1);
    encoder.skip(1);
    encoder.skip(1);
  };
  function Process_SayHello_Params(values) {
    this.initDefaults_();
    this.initFields_(values);
  }


  Process_SayHello_Params.prototype.initDefaults_ = function() {
  };
  Process_SayHello_Params.prototype.initFields_ = function(fields) {
    for(var field in fields) {
        if (this.hasOwnProperty(field))
          this[field] = fields[field];
    }
  };

  Process_SayHello_Params.validate = function(messageValidator, offset) {
    var err;
    err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
    if (err !== validator.validationError.NONE)
        return err;

    var kVersionSizes = [
      {version: 0, numBytes: 8}
    ];
    err = messageValidator.validateStructVersion(offset, kVersionSizes);
    if (err !== validator.validationError.NONE)
        return err;

    return validator.validationError.NONE;
  };

  Process_SayHello_Params.encodedSize = codec.kStructHeaderSize + 0;

  Process_SayHello_Params.decode = function(decoder) {
    var packed;
    var val = new Process_SayHello_Params();
    var numberOfBytes = decoder.readUint32();
    var version = decoder.readUint32();
    return val;
  };

  Process_SayHello_Params.encode = function(encoder, val) {
    var packed;
    encoder.writeUint32(Process_SayHello_Params.encodedSize);
    encoder.writeUint32(0);
  };
  function Process_GetAssociatedInterface_Params(values) {
    this.initDefaults_();
    this.initFields_(values);
  }


  Process_GetAssociatedInterface_Params.prototype.initDefaults_ = function() {
    this.name = null;
    this.receiver = new associatedBindings.AssociatedInterfaceRequest();
  };
  Process_GetAssociatedInterface_Params.prototype.initFields_ = function(fields) {
    for(var field in fields) {
        if (this.hasOwnProperty(field))
          this[field] = fields[field];
    }
  };

  Process_GetAssociatedInterface_Params.validate = function(messageValidator, offset) {
    var err;
    err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
    if (err !== validator.validationError.NONE)
        return err;

    var kVersionSizes = [
      {version: 0, numBytes: 24}
    ];
    err = messageValidator.validateStructVersion(offset, kVersionSizes);
    if (err !== validator.validationError.NONE)
        return err;


    // validate Process_GetAssociatedInterface_Params.name
    err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 0, false)
    if (err !== validator.validationError.NONE)
        return err;


    // validate Process_GetAssociatedInterface_Params.receiver
    err = messageValidator.validateAssociatedInterfaceRequest(offset + codec.kStructHeaderSize + 8, false)
    if (err !== validator.validationError.NONE)
        return err;

    return validator.validationError.NONE;
  };

  Process_GetAssociatedInterface_Params.encodedSize = codec.kStructHeaderSize + 16;

  Process_GetAssociatedInterface_Params.decode = function(decoder) {
    var packed;
    var val = new Process_GetAssociatedInterface_Params();
    var numberOfBytes = decoder.readUint32();
    var version = decoder.readUint32();
    val.name =
        decoder.decodeStruct(codec.String);
    val.receiver =
        decoder.decodeStruct(codec.AssociatedInterfaceRequest);
    decoder.skip(1);
    decoder.skip(1);
    decoder.skip(1);
    decoder.skip(1);
    return val;
  };

  Process_GetAssociatedInterface_Params.encode = function(encoder, val) {
    var packed;
    encoder.writeUint32(Process_GetAssociatedInterface_Params.encodedSize);
    encoder.writeUint32(0);
    encoder.encodeStruct(codec.String, val.name);
    encoder.encodeStruct(codec.AssociatedInterfaceRequest, val.receiver);
    encoder.skip(1);
    encoder.skip(1);
    encoder.skip(1);
    encoder.skip(1);
  };
  var kObjectA_DoA_Name = 0;

  function ObjectAPtr(handleOrPtrInfo) {
    this.ptr = new bindings.InterfacePtrController(ObjectA,
                                                   handleOrPtrInfo);
  }

  function ObjectAAssociatedPtr(associatedInterfacePtrInfo) {
    this.ptr = new associatedBindings.AssociatedInterfacePtrController(
        ObjectA, associatedInterfacePtrInfo);
  }

  ObjectAAssociatedPtr.prototype =
      Object.create(ObjectAPtr.prototype);
  ObjectAAssociatedPtr.prototype.constructor =
      ObjectAAssociatedPtr;

  function ObjectAProxy(receiver) {
    this.receiver_ = receiver;
  }
  ObjectAPtr.prototype.doA = function() {
    return ObjectAProxy.prototype.doA
        .apply(this.ptr.getProxy(), arguments);
  };

  ObjectAProxy.prototype.doA = function() {
    var params_ = new ObjectA_DoA_Params();
    var builder = new codec.MessageV0Builder(
        kObjectA_DoA_Name,
        codec.align(ObjectA_DoA_Params.encodedSize));
    builder.encodeStruct(ObjectA_DoA_Params, params_);
    var message = builder.finish();
    this.receiver_.accept(message);
  };

  function ObjectAStub(delegate) {
    this.delegate_ = delegate;
  }
  ObjectAStub.prototype.doA = function() {
    return this.delegate_ && this.delegate_.doA && this.delegate_.doA();
  }

  ObjectAStub.prototype.accept = function(message) {
    var reader = new codec.MessageReader(message);
    switch (reader.messageName) {
    case kObjectA_DoA_Name:
      var params = reader.decodeStruct(ObjectA_DoA_Params);
      this.doA();
      return true;
    default:
      return false;
    }
  };

  ObjectAStub.prototype.acceptWithResponder =
      function(message, responder) {
    var reader = new codec.MessageReader(message);
    switch (reader.messageName) {
    default:
      return false;
    }
  };

  function validateObjectARequest(messageValidator) {
    var message = messageValidator.message;
    var paramsClass = null;
    switch (message.getName()) {
      case kObjectA_DoA_Name:
        if (!message.expectsResponse() && !message.isResponse())
          paramsClass = ObjectA_DoA_Params;
      break;
    }
    if (paramsClass === null)
      return validator.validationError.NONE;
    return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes());
  }

  function validateObjectAResponse(messageValidator) {
    return validator.validationError.NONE;
  }

  var ObjectA = {
    name: 'codelabs.mojom.ObjectA',
    kVersion: 0,
    ptrClass: ObjectAPtr,
    proxyClass: ObjectAProxy,
    stubClass: ObjectAStub,
    validateRequest: validateObjectARequest,
    validateResponse: null,
  };
  ObjectAStub.prototype.validator = validateObjectARequest;
  ObjectAProxy.prototype.validator = null;
  var kObjectB_DoB_Name = 0;

  function ObjectBPtr(handleOrPtrInfo) {
    this.ptr = new bindings.InterfacePtrController(ObjectB,
                                                   handleOrPtrInfo);
  }

  function ObjectBAssociatedPtr(associatedInterfacePtrInfo) {
    this.ptr = new associatedBindings.AssociatedInterfacePtrController(
        ObjectB, associatedInterfacePtrInfo);
  }

  ObjectBAssociatedPtr.prototype =
      Object.create(ObjectBPtr.prototype);
  ObjectBAssociatedPtr.prototype.constructor =
      ObjectBAssociatedPtr;

  function ObjectBProxy(receiver) {
    this.receiver_ = receiver;
  }
  ObjectBPtr.prototype.doB = function() {
    return ObjectBProxy.prototype.doB
        .apply(this.ptr.getProxy(), arguments);
  };

  ObjectBProxy.prototype.doB = function() {
    var params_ = new ObjectB_DoB_Params();
    var builder = new codec.MessageV0Builder(
        kObjectB_DoB_Name,
        codec.align(ObjectB_DoB_Params.encodedSize));
    builder.encodeStruct(ObjectB_DoB_Params, params_);
    var message = builder.finish();
    this.receiver_.accept(message);
  };

  function ObjectBStub(delegate) {
    this.delegate_ = delegate;
  }
  ObjectBStub.prototype.doB = function() {
    return this.delegate_ && this.delegate_.doB && this.delegate_.doB();
  }

  ObjectBStub.prototype.accept = function(message) {
    var reader = new codec.MessageReader(message);
    switch (reader.messageName) {
    case kObjectB_DoB_Name:
      var params = reader.decodeStruct(ObjectB_DoB_Params);
      this.doB();
      return true;
    default:
      return false;
    }
  };

  ObjectBStub.prototype.acceptWithResponder =
      function(message, responder) {
    var reader = new codec.MessageReader(message);
    switch (reader.messageName) {
    default:
      return false;
    }
  };

  function validateObjectBRequest(messageValidator) {
    var message = messageValidator.message;
    var paramsClass = null;
    switch (message.getName()) {
      case kObjectB_DoB_Name:
        if (!message.expectsResponse() && !message.isResponse())
          paramsClass = ObjectB_DoB_Params;
      break;
    }
    if (paramsClass === null)
      return validator.validationError.NONE;
    return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes());
  }

  function validateObjectBResponse(messageValidator) {
    return validator.validationError.NONE;
  }

  var ObjectB = {
    name: 'codelabs.mojom.ObjectB',
    kVersion: 0,
    ptrClass: ObjectBPtr,
    proxyClass: ObjectBProxy,
    stubClass: ObjectBStub,
    validateRequest: validateObjectBRequest,
    validateResponse: null,
  };
  ObjectBStub.prototype.validator = validateObjectBRequest;
  ObjectBProxy.prototype.validator = null;
  var kAssociatedProcess_SetProcess_Name = 0;

  function AssociatedProcessPtr(handleOrPtrInfo) {
    this.ptr = new bindings.InterfacePtrController(AssociatedProcess,
                                                   handleOrPtrInfo);
  }

  function AssociatedProcessAssociatedPtr(associatedInterfacePtrInfo) {
    this.ptr = new associatedBindings.AssociatedInterfacePtrController(
        AssociatedProcess, associatedInterfacePtrInfo);
  }

  AssociatedProcessAssociatedPtr.prototype =
      Object.create(AssociatedProcessPtr.prototype);
  AssociatedProcessAssociatedPtr.prototype.constructor =
      AssociatedProcessAssociatedPtr;

  function AssociatedProcessProxy(receiver) {
    this.receiver_ = receiver;
  }
  AssociatedProcessPtr.prototype.setProcess = function() {
    return AssociatedProcessProxy.prototype.setProcess
        .apply(this.ptr.getProxy(), arguments);
  };

  AssociatedProcessProxy.prototype.setProcess = function(process) {
    var params_ = new AssociatedProcess_SetProcess_Params();
    params_.process = process;
    var builder = new codec.MessageV0Builder(
        kAssociatedProcess_SetProcess_Name,
        codec.align(AssociatedProcess_SetProcess_Params.encodedSize));
    builder.encodeStruct(AssociatedProcess_SetProcess_Params, params_);
    var message = builder.finish();
    this.receiver_.accept(message);
  };

  function AssociatedProcessStub(delegate) {
    this.delegate_ = delegate;
  }
  AssociatedProcessStub.prototype.setProcess = function(process) {
    return this.delegate_ && this.delegate_.setProcess && this.delegate_.setProcess(process);
  }

  AssociatedProcessStub.prototype.accept = function(message) {
    var reader = new codec.MessageReader(message);
    switch (reader.messageName) {
    case kAssociatedProcess_SetProcess_Name:
      var params = reader.decodeStruct(AssociatedProcess_SetProcess_Params);
      this.setProcess(params.process);
      return true;
    default:
      return false;
    }
  };

  AssociatedProcessStub.prototype.acceptWithResponder =
      function(message, responder) {
    var reader = new codec.MessageReader(message);
    switch (reader.messageName) {
    default:
      return false;
    }
  };

  function validateAssociatedProcessRequest(messageValidator) {
    var message = messageValidator.message;
    var paramsClass = null;
    switch (message.getName()) {
      case kAssociatedProcess_SetProcess_Name:
        if (!message.expectsResponse() && !message.isResponse())
          paramsClass = AssociatedProcess_SetProcess_Params;
      break;
    }
    if (paramsClass === null)
      return validator.validationError.NONE;
    return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes());
  }

  function validateAssociatedProcessResponse(messageValidator) {
    return validator.validationError.NONE;
  }

  var AssociatedProcess = {
    name: 'codelabs.mojom.AssociatedProcess',
    kVersion: 0,
    ptrClass: AssociatedProcessPtr,
    proxyClass: AssociatedProcessProxy,
    stubClass: AssociatedProcessStub,
    validateRequest: validateAssociatedProcessRequest,
    validateResponse: null,
  };
  AssociatedProcessStub.prototype.validator = validateAssociatedProcessRequest;
  AssociatedProcessProxy.prototype.validator = null;

  function GenericInterfacePtr(handleOrPtrInfo) {
    this.ptr = new bindings.InterfacePtrController(GenericInterface,
                                                   handleOrPtrInfo);
  }

  function GenericInterfaceAssociatedPtr(associatedInterfacePtrInfo) {
    this.ptr = new associatedBindings.AssociatedInterfacePtrController(
        GenericInterface, associatedInterfacePtrInfo);
  }

  GenericInterfaceAssociatedPtr.prototype =
      Object.create(GenericInterfacePtr.prototype);
  GenericInterfaceAssociatedPtr.prototype.constructor =
      GenericInterfaceAssociatedPtr;

  function GenericInterfaceProxy(receiver) {
    this.receiver_ = receiver;
  }

  function GenericInterfaceStub(delegate) {
    this.delegate_ = delegate;
  }

  GenericInterfaceStub.prototype.accept = function(message) {
    var reader = new codec.MessageReader(message);
    switch (reader.messageName) {
    default:
      return false;
    }
  };

  GenericInterfaceStub.prototype.acceptWithResponder =
      function(message, responder) {
    var reader = new codec.MessageReader(message);
    switch (reader.messageName) {
    default:
      return false;
    }
  };

  function validateGenericInterfaceRequest(messageValidator) {
    return validator.validationError.NONE;
  }

  function validateGenericInterfaceResponse(messageValidator) {
    return validator.validationError.NONE;
  }

  var GenericInterface = {
    name: 'codelabs.mojom.GenericInterface',
    kVersion: 0,
    ptrClass: GenericInterfacePtr,
    proxyClass: GenericInterfaceProxy,
    stubClass: GenericInterfaceStub,
    validateRequest: validateGenericInterfaceRequest,
    validateResponse: null,
  };
  GenericInterfaceStub.prototype.validator = validateGenericInterfaceRequest;
  GenericInterfaceProxy.prototype.validator = null;
  var kProcess_SayHello_Name = 0;
  var kProcess_GetAssociatedInterface_Name = 1;

  function ProcessPtr(handleOrPtrInfo) {
    this.ptr = new bindings.InterfacePtrController(Process,
                                                   handleOrPtrInfo);
  }

  function ProcessAssociatedPtr(associatedInterfacePtrInfo) {
    this.ptr = new associatedBindings.AssociatedInterfacePtrController(
        Process, associatedInterfacePtrInfo);
  }

  ProcessAssociatedPtr.prototype =
      Object.create(ProcessPtr.prototype);
  ProcessAssociatedPtr.prototype.constructor =
      ProcessAssociatedPtr;

  function ProcessProxy(receiver) {
    this.receiver_ = receiver;
  }
  ProcessPtr.prototype.sayHello = function() {
    return ProcessProxy.prototype.sayHello
        .apply(this.ptr.getProxy(), arguments);
  };

  ProcessProxy.prototype.sayHello = function() {
    var params_ = new Process_SayHello_Params();
    var builder = new codec.MessageV0Builder(
        kProcess_SayHello_Name,
        codec.align(Process_SayHello_Params.encodedSize));
    builder.encodeStruct(Process_SayHello_Params, params_);
    var message = builder.finish();
    this.receiver_.accept(message);
  };
  ProcessPtr.prototype.getAssociatedInterface = function() {
    return ProcessProxy.prototype.getAssociatedInterface
        .apply(this.ptr.getProxy(), arguments);
  };

  ProcessProxy.prototype.getAssociatedInterface = function(name, receiver) {
    var params_ = new Process_GetAssociatedInterface_Params();
    params_.name = name;
    params_.receiver = receiver;
    var builder = new codec.MessageV2Builder(
        kProcess_GetAssociatedInterface_Name,
        codec.align(Process_GetAssociatedInterface_Params.encodedSize));
    builder.setPayload(Process_GetAssociatedInterface_Params, params_);
    var message = builder.finish();
    this.receiver_.accept(message);
  };

  function ProcessStub(delegate) {
    this.delegate_ = delegate;
  }
  ProcessStub.prototype.sayHello = function() {
    return this.delegate_ && this.delegate_.sayHello && this.delegate_.sayHello();
  }
  ProcessStub.prototype.getAssociatedInterface = function(name, receiver) {
    return this.delegate_ && this.delegate_.getAssociatedInterface && this.delegate_.getAssociatedInterface(name, receiver);
  }

  ProcessStub.prototype.accept = function(message) {
    var reader = new codec.MessageReader(message);
    switch (reader.messageName) {
    case kProcess_SayHello_Name:
      var params = reader.decodeStruct(Process_SayHello_Params);
      this.sayHello();
      return true;
    case kProcess_GetAssociatedInterface_Name:
      var params = reader.decodeStruct(Process_GetAssociatedInterface_Params);
      this.getAssociatedInterface(params.name, params.receiver);
      return true;
    default:
      return false;
    }
  };

  ProcessStub.prototype.acceptWithResponder =
      function(message, responder) {
    var reader = new codec.MessageReader(message);
    switch (reader.messageName) {
    default:
      return false;
    }
  };

  function validateProcessRequest(messageValidator) {
    var message = messageValidator.message;
    var paramsClass = null;
    switch (message.getName()) {
      case kProcess_SayHello_Name:
        if (!message.expectsResponse() && !message.isResponse())
          paramsClass = Process_SayHello_Params;
      break;
      case kProcess_GetAssociatedInterface_Name:
        if (!message.expectsResponse() && !message.isResponse())
          paramsClass = Process_GetAssociatedInterface_Params;
      break;
    }
    if (paramsClass === null)
      return validator.validationError.NONE;
    return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes());
  }

  function validateProcessResponse(messageValidator) {
    return validator.validationError.NONE;
  }

  var Process = {
    name: 'codelabs.mojom.Process',
    kVersion: 0,
    ptrClass: ProcessPtr,
    proxyClass: ProcessProxy,
    stubClass: ProcessStub,
    validateRequest: validateProcessRequest,
    validateResponse: null,
  };
  ProcessStub.prototype.validator = validateProcessRequest;
  ProcessProxy.prototype.validator = null;
  exports.ObjectA = ObjectA;
  exports.ObjectAPtr = ObjectAPtr;
  exports.ObjectAAssociatedPtr = ObjectAAssociatedPtr;
  exports.ObjectB = ObjectB;
  exports.ObjectBPtr = ObjectBPtr;
  exports.ObjectBAssociatedPtr = ObjectBAssociatedPtr;
  exports.AssociatedProcess = AssociatedProcess;
  exports.AssociatedProcessPtr = AssociatedProcessPtr;
  exports.AssociatedProcessAssociatedPtr = AssociatedProcessAssociatedPtr;
  exports.GenericInterface = GenericInterface;
  exports.GenericInterfacePtr = GenericInterfacePtr;
  exports.GenericInterfaceAssociatedPtr = GenericInterfaceAssociatedPtr;
  exports.Process = Process;
  exports.ProcessPtr = ProcessPtr;
  exports.ProcessAssociatedPtr = ProcessAssociatedPtr;
})();