text:
require_relative 'CloseServiceDefinitions.rb'
require 'soap/mapping'

module FedexWebServices; module Soap; module Close

module CloseServiceDefinitionsMappingRegistry
  EncodedRegistry = ::SOAP::Mapping::EncodedRegistry.new
  LiteralRegistry = ::SOAP::Mapping::LiteralRegistry.new
  NsV4 = "http://fedex.com/ws/close/v4"

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::ClientDetail,
    :schema_type => XSD::QName.new(NsV4, "ClientDetail"),
    :schema_element => [
      ["accountNumber", ["SOAP::SOAPString", XSD::QName.new(NsV4, "AccountNumber")]],
      ["meterNumber", ["SOAP::SOAPString", XSD::QName.new(NsV4, "MeterNumber")]],
      ["integratorId", ["SOAP::SOAPString", XSD::QName.new(NsV4, "IntegratorId")], [0, 1]],
      ["localization", ["FedexWebServices::Soap::Close::Localization", XSD::QName.new(NsV4, "Localization")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseDocument,
    :schema_type => XSD::QName.new(NsV4, "CloseDocument"),
    :schema_element => [
      ["type", ["FedexWebServices::Soap::Close::CloseDocumentType", XSD::QName.new(NsV4, "Type")], [0, 1]],
      ["shippingCycle", ["SOAP::SOAPString", XSD::QName.new(NsV4, "ShippingCycle")], [0, 1]],
      ["shippingDocumentDisposition", ["FedexWebServices::Soap::Close::ShippingDocumentDispositionType", XSD::QName.new(NsV4, "ShippingDocumentDisposition")], [0, 1]],
      ["accessReference", ["SOAP::SOAPString", XSD::QName.new(NsV4, "AccessReference")], [0, 1]],
      ["resolution", ["SOAP::SOAPNonNegativeInteger", XSD::QName.new(NsV4, "Resolution")], [0, 1]],
      ["copiesToPrint", ["SOAP::SOAPNonNegativeInteger", XSD::QName.new(NsV4, "CopiesToPrint")], [0, 1]],
      ["parts", ["FedexWebServices::Soap::Close::ShippingDocumentPart[]", XSD::QName.new(NsV4, "Parts")], [0, nil]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseDocumentFormat,
    :schema_type => XSD::QName.new(NsV4, "CloseDocumentFormat"),
    :schema_element => [
      ["dispositions", ["FedexWebServices::Soap::Close::ShippingDocumentDispositionDetail[]", XSD::QName.new(NsV4, "Dispositions")], [0, nil]],
      ["topOfPageOffset", ["FedexWebServices::Soap::Close::LinearMeasure", XSD::QName.new(NsV4, "TopOfPageOffset")], [0, 1]],
      ["imageType", ["FedexWebServices::Soap::Close::ShippingDocumentImageType", XSD::QName.new(NsV4, "ImageType")], [0, 1]],
      ["stockType", ["FedexWebServices::Soap::Close::ShippingDocumentStockType", XSD::QName.new(NsV4, "StockType")], [0, 1]],
      ["provideInstructions", ["SOAP::SOAPBoolean", XSD::QName.new(NsV4, "ProvideInstructions")], [0, 1]],
      ["localization", ["FedexWebServices::Soap::Close::Localization", XSD::QName.new(NsV4, "Localization")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseDocumentSpecification,
    :schema_type => XSD::QName.new(NsV4, "CloseDocumentSpecification"),
    :schema_element => [
      ["closeDocumentTypes", ["FedexWebServices::Soap::Close::CloseDocumentType[]", XSD::QName.new(NsV4, "CloseDocumentTypes")], [0, nil]],
      ["detailedDeliveryManifestDetail", ["FedexWebServices::Soap::Close::DetailedDeliveryManifestDetail", XSD::QName.new(NsV4, "DetailedDeliveryManifestDetail")], [0, 1]],
      ["manifestDetail", ["FedexWebServices::Soap::Close::ManifestDetail", XSD::QName.new(NsV4, "ManifestDetail")], [0, 1]],
      ["op950Detail", ["FedexWebServices::Soap::Close::Op950Detail", XSD::QName.new(NsV4, "Op950Detail")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseManifestReferenceDetail,
    :schema_type => XSD::QName.new(NsV4, "CloseManifestReferenceDetail"),
    :schema_element => [
      ["type", ["FedexWebServices::Soap::Close::CustomerReferenceType", XSD::QName.new(NsV4, "Type")], [0, 1]],
      ["value", ["SOAP::SOAPString", XSD::QName.new(NsV4, "Value")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseSmartPostDetail,
    :schema_type => XSD::QName.new(NsV4, "CloseSmartPostDetail"),
    :schema_element => [
      ["hubId", ["SOAP::SOAPString", XSD::QName.new(NsV4, "HubId")], [0, 1]],
      ["customerId", ["SOAP::SOAPString", XSD::QName.new(NsV4, "CustomerId")], [0, 1]],
      ["customerManifestId", ["SOAP::SOAPString", XSD::QName.new(NsV4, "CustomerManifestId")], [0, 1]],
      ["destinationCountryCode", ["SOAP::SOAPString", XSD::QName.new(NsV4, "DestinationCountryCode")], [0, 1]],
      ["pickupCarrier", ["FedexWebServices::Soap::Close::CarrierCodeType", XSD::QName.new(NsV4, "PickupCarrier")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseWithDocumentsProcessingOptionsRequested,
    :schema_type => XSD::QName.new(NsV4, "CloseWithDocumentsProcessingOptionsRequested"),
    :schema_element => [
      ["options", ["FedexWebServices::Soap::Close::CloseWithDocumentsProcessingOptionType[]", XSD::QName.new(NsV4, "Options")], [0, nil]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseWithDocumentsReply,
    :schema_type => XSD::QName.new(NsV4, "CloseWithDocumentsReply"),
    :schema_element => [
      ["highestSeverity", ["FedexWebServices::Soap::Close::NotificationSeverityType", XSD::QName.new(NsV4, "HighestSeverity")]],
      ["notifications", ["FedexWebServices::Soap::Close::Notification[]", XSD::QName.new(NsV4, "Notifications")], [1, nil]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["documents", ["FedexWebServices::Soap::Close::CloseDocument[]", XSD::QName.new(NsV4, "Documents")], [0, nil]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseWithDocumentsRequest,
    :schema_type => XSD::QName.new(NsV4, "CloseWithDocumentsRequest"),
    :schema_element => [
      ["webAuthenticationDetail", ["FedexWebServices::Soap::Close::WebAuthenticationDetail", XSD::QName.new(NsV4, "WebAuthenticationDetail")]],
      ["clientDetail", ["FedexWebServices::Soap::Close::ClientDetail", XSD::QName.new(NsV4, "ClientDetail")]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["actionType", ["FedexWebServices::Soap::Close::CloseActionType", XSD::QName.new(NsV4, "ActionType")], [0, 1]],
      ["processingOptions", ["FedexWebServices::Soap::Close::CloseWithDocumentsProcessingOptionsRequested", XSD::QName.new(NsV4, "ProcessingOptions")], [0, 1]],
      ["carrierCode", ["FedexWebServices::Soap::Close::CarrierCodeType", XSD::QName.new(NsV4, "CarrierCode")], [0, 1]],
      ["shippingCycle", ["SOAP::SOAPString", XSD::QName.new(NsV4, "ShippingCycle")], [0, 1]],
      ["reprintCloseDate", ["SOAP::SOAPDateTime", XSD::QName.new(NsV4, "ReprintCloseDate")], [0, 1]],
      ["manifestReferenceDetail", ["FedexWebServices::Soap::Close::CloseManifestReferenceDetail", XSD::QName.new(NsV4, "ManifestReferenceDetail")], [0, 1]],
      ["smartPostDetail", ["FedexWebServices::Soap::Close::CloseSmartPostDetail", XSD::QName.new(NsV4, "SmartPostDetail")], [0, 1]],
      ["closeDocumentSpecification", ["FedexWebServices::Soap::Close::CloseDocumentSpecification", XSD::QName.new(NsV4, "CloseDocumentSpecification")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::CustomerImageUsage,
    :schema_type => XSD::QName.new(NsV4, "CustomerImageUsage"),
    :schema_element => [
      ["type", ["FedexWebServices::Soap::Close::CustomerImageUsageType", XSD::QName.new(NsV4, "Type")], [0, 1]],
      ["id", ["FedexWebServices::Soap::Close::ImageId", XSD::QName.new(NsV4, "Id")], [0, 1]],
      ["internalId", ["SOAP::SOAPString", XSD::QName.new(NsV4, "InternalId")], [0, 1]],
      ["internalImageType", ["FedexWebServices::Soap::Close::InternalImageType", XSD::QName.new(NsV4, "InternalImageType")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::DetailedDeliveryManifestDetail,
    :schema_type => XSD::QName.new(NsV4, "DetailedDeliveryManifestDetail"),
    :schema_element => [
      ["format", ["FedexWebServices::Soap::Close::CloseDocumentFormat", XSD::QName.new(NsV4, "Format")], [0, 1]],
      ["clientTimeZoneOffset", ["SOAP::SOAPString", XSD::QName.new(NsV4, "ClientTimeZoneOffset")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::GroundCloseDocumentsReply,
    :schema_type => XSD::QName.new(NsV4, "GroundCloseDocumentsReply"),
    :schema_element => [
      ["highestSeverity", ["FedexWebServices::Soap::Close::NotificationSeverityType", XSD::QName.new(NsV4, "HighestSeverity")]],
      ["notifications", ["FedexWebServices::Soap::Close::Notification[]", XSD::QName.new(NsV4, "Notifications")], [1, nil]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["closeDocuments", ["FedexWebServices::Soap::Close::CloseDocument[]", XSD::QName.new(NsV4, "CloseDocuments")], [0, nil]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::GroundCloseReply,
    :schema_type => XSD::QName.new(NsV4, "GroundCloseReply"),
    :schema_element => [
      ["highestSeverity", ["FedexWebServices::Soap::Close::NotificationSeverityType", XSD::QName.new(NsV4, "HighestSeverity")]],
      ["notifications", ["FedexWebServices::Soap::Close::Notification[]", XSD::QName.new(NsV4, "Notifications")], [1, nil]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["codReport", ["SOAP::SOAPBase64", XSD::QName.new(NsV4, "CodReport")], [0, 1]],
      ["hazMatCertificate", ["SOAP::SOAPBase64", XSD::QName.new(NsV4, "HazMatCertificate")], [0, 1]],
      ["manifest", ["FedexWebServices::Soap::Close::ManifestFile", XSD::QName.new(NsV4, "Manifest")], [0, 1]],
      ["multiweightReport", ["SOAP::SOAPBase64", XSD::QName.new(NsV4, "MultiweightReport")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::GroundCloseReportsReprintReply,
    :schema_type => XSD::QName.new(NsV4, "GroundCloseReportsReprintReply"),
    :schema_element => [
      ["highestSeverity", ["FedexWebServices::Soap::Close::NotificationSeverityType", XSD::QName.new(NsV4, "HighestSeverity")]],
      ["notifications", ["FedexWebServices::Soap::Close::Notification[]", XSD::QName.new(NsV4, "Notifications")], [1, nil]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["codReport", ["SOAP::SOAPBase64", XSD::QName.new(NsV4, "CodReport")], [0, 1]],
      ["hazMatCertificate", ["SOAP::SOAPBase64", XSD::QName.new(NsV4, "HazMatCertificate")], [0, 1]],
      ["manifests", ["FedexWebServices::Soap::Close::ManifestFile[]", XSD::QName.new(NsV4, "Manifests")], [0, nil]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::GroundCloseReportsReprintRequest,
    :schema_type => XSD::QName.new(NsV4, "GroundCloseReportsReprintRequest"),
    :schema_element => [
      ["webAuthenticationDetail", ["FedexWebServices::Soap::Close::WebAuthenticationDetail", XSD::QName.new(NsV4, "WebAuthenticationDetail")]],
      ["clientDetail", ["FedexWebServices::Soap::Close::ClientDetail", XSD::QName.new(NsV4, "ClientDetail")]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["reportDate", ["SOAP::SOAPDate", XSD::QName.new(NsV4, "ReportDate")], [0, 1]],
      ["trackingNumber", ["SOAP::SOAPString", XSD::QName.new(NsV4, "TrackingNumber")], [0, 1]],
      ["closeReportType", ["FedexWebServices::Soap::Close::CloseReportType", XSD::QName.new(NsV4, "CloseReportType")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::GroundCloseRequest,
    :schema_type => XSD::QName.new(NsV4, "GroundCloseRequest"),
    :schema_element => [
      ["webAuthenticationDetail", ["FedexWebServices::Soap::Close::WebAuthenticationDetail", XSD::QName.new(NsV4, "WebAuthenticationDetail")]],
      ["clientDetail", ["FedexWebServices::Soap::Close::ClientDetail", XSD::QName.new(NsV4, "ClientDetail")]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["closeGrouping", ["FedexWebServices::Soap::Close::CloseGroupingType", XSD::QName.new(NsV4, "CloseGrouping")], [0, 1]],
      ["timeUpToWhichShipmentsAreToBeClosed", ["SOAP::SOAPDateTime", XSD::QName.new(NsV4, "TimeUpToWhichShipmentsAreToBeClosed")], [0, 1]],
      ["manifestReferenceDetail", ["FedexWebServices::Soap::Close::CloseManifestReferenceDetail", XSD::QName.new(NsV4, "ManifestReferenceDetail")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::GroundCloseWithDocumentsRequest,
    :schema_type => XSD::QName.new(NsV4, "GroundCloseWithDocumentsRequest"),
    :schema_element => [
      ["webAuthenticationDetail", ["FedexWebServices::Soap::Close::WebAuthenticationDetail", XSD::QName.new(NsV4, "WebAuthenticationDetail")]],
      ["clientDetail", ["FedexWebServices::Soap::Close::ClientDetail", XSD::QName.new(NsV4, "ClientDetail")]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["closeDate", ["SOAP::SOAPDate", XSD::QName.new(NsV4, "CloseDate")], [0, 1]],
      ["closeDocumentSpecification", ["FedexWebServices::Soap::Close::CloseDocumentSpecification", XSD::QName.new(NsV4, "CloseDocumentSpecification")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::LinearMeasure,
    :schema_type => XSD::QName.new(NsV4, "LinearMeasure"),
    :schema_element => [
      ["value", ["SOAP::SOAPDecimal", XSD::QName.new(NsV4, "Value")], [0, 1]],
      ["units", ["FedexWebServices::Soap::Close::LinearUnits", XSD::QName.new(NsV4, "Units")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::Localization,
    :schema_type => XSD::QName.new(NsV4, "Localization"),
    :schema_element => [
      ["languageCode", ["SOAP::SOAPString", XSD::QName.new(NsV4, "LanguageCode")]],
      ["localeCode", ["SOAP::SOAPString", XSD::QName.new(NsV4, "LocaleCode")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::ManifestDetail,
    :schema_type => XSD::QName.new(NsV4, "ManifestDetail"),
    :schema_element => [
      ["format", ["FedexWebServices::Soap::Close::CloseDocumentFormat", XSD::QName.new(NsV4, "Format")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::ManifestFile,
    :schema_type => XSD::QName.new(NsV4, "ManifestFile"),
    :schema_element => [
      ["fileName", ["SOAP::SOAPString", XSD::QName.new(NsV4, "FileName")], [0, 1]],
      ["file", ["SOAP::SOAPBase64", XSD::QName.new(NsV4, "File")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::Notification,
    :schema_type => XSD::QName.new(NsV4, "Notification"),
    :schema_element => [
      ["severity", ["FedexWebServices::Soap::Close::NotificationSeverityType", XSD::QName.new(NsV4, "Severity")], [0, 1]],
      ["source", ["SOAP::SOAPString", XSD::QName.new(NsV4, "Source")], [0, 1]],
      ["code", ["SOAP::SOAPString", XSD::QName.new(NsV4, "Code")], [0, 1]],
      ["message", ["SOAP::SOAPString", XSD::QName.new(NsV4, "Message")], [0, 1]],
      ["localizedMessage", ["SOAP::SOAPString", XSD::QName.new(NsV4, "LocalizedMessage")], [0, 1]],
      ["messageParameters", ["FedexWebServices::Soap::Close::NotificationParameter[]", XSD::QName.new(NsV4, "MessageParameters")], [0, nil]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::NotificationParameter,
    :schema_type => XSD::QName.new(NsV4, "NotificationParameter"),
    :schema_element => [
      ["id", ["SOAP::SOAPString", XSD::QName.new(NsV4, "Id")], [0, 1]],
      ["value", ["SOAP::SOAPString", XSD::QName.new(NsV4, "Value")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::Op950Detail,
    :schema_type => XSD::QName.new(NsV4, "Op950Detail"),
    :schema_element => [
      ["format", ["FedexWebServices::Soap::Close::CloseDocumentFormat", XSD::QName.new(NsV4, "Format")], [0, 1]],
      ["customerImageUsages", ["FedexWebServices::Soap::Close::CustomerImageUsage[]", XSD::QName.new(NsV4, "CustomerImageUsages")], [0, nil]],
      ["signatureName", ["SOAP::SOAPString", XSD::QName.new(NsV4, "SignatureName")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::ReprintGroundCloseDocumentsRequest,
    :schema_type => XSD::QName.new(NsV4, "ReprintGroundCloseDocumentsRequest"),
    :schema_element => [
      ["webAuthenticationDetail", ["FedexWebServices::Soap::Close::WebAuthenticationDetail", XSD::QName.new(NsV4, "WebAuthenticationDetail")]],
      ["clientDetail", ["FedexWebServices::Soap::Close::ClientDetail", XSD::QName.new(NsV4, "ClientDetail")]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["reprintOption", ["FedexWebServices::Soap::Close::ReprintGroundCloseDocumentsOptionType", XSD::QName.new(NsV4, "ReprintOption")], [0, 1]],
      ["closeDate", ["SOAP::SOAPDate", XSD::QName.new(NsV4, "CloseDate")], [0, 1]],
      ["trackingNumber", ["SOAP::SOAPString", XSD::QName.new(NsV4, "TrackingNumber")], [0, 1]],
      ["closeDocumentSpecification", ["FedexWebServices::Soap::Close::CloseDocumentSpecification", XSD::QName.new(NsV4, "CloseDocumentSpecification")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::ShippingDocumentDispositionDetail,
    :schema_type => XSD::QName.new(NsV4, "ShippingDocumentDispositionDetail"),
    :schema_element => [
      ["dispositionType", ["FedexWebServices::Soap::Close::ShippingDocumentDispositionType", XSD::QName.new(NsV4, "DispositionType")], [0, 1]],
      ["grouping", ["FedexWebServices::Soap::Close::ShippingDocumentGroupingType", XSD::QName.new(NsV4, "Grouping")], [0, 1]],
      ["storageDetail", ["FedexWebServices::Soap::Close::ShippingDocumentStorageDetail", XSD::QName.new(NsV4, "StorageDetail")], [0, 1]],
      ["eMailDetail", ["FedexWebServices::Soap::Close::ShippingDocumentEMailDetail", XSD::QName.new(NsV4, "EMailDetail")], [0, 1]],
      ["printDetail", ["FedexWebServices::Soap::Close::ShippingDocumentPrintDetail", XSD::QName.new(NsV4, "PrintDetail")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::ShippingDocumentEMailDetail,
    :schema_type => XSD::QName.new(NsV4, "ShippingDocumentEMailDetail"),
    :schema_element => [
      ["eMailRecipients", ["FedexWebServices::Soap::Close::ShippingDocumentEMailRecipient[]", XSD::QName.new(NsV4, "EMailRecipients")], [0, nil]],
      ["grouping", ["FedexWebServices::Soap::Close::ShippingDocumentEMailGroupingType", XSD::QName.new(NsV4, "Grouping")], [0, 1]],
      ["localization", ["FedexWebServices::Soap::Close::Localization", XSD::QName.new(NsV4, "Localization")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::ShippingDocumentEMailRecipient,
    :schema_type => XSD::QName.new(NsV4, "ShippingDocumentEMailRecipient"),
    :schema_element => [
      ["recipientType", ["FedexWebServices::Soap::Close::EMailNotificationRecipientType", XSD::QName.new(NsV4, "RecipientType")], [0, 1]],
      ["address", ["SOAP::SOAPString", XSD::QName.new(NsV4, "Address")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::ShippingDocumentPart,
    :schema_type => XSD::QName.new(NsV4, "ShippingDocumentPart"),
    :schema_element => [
      ["documentPartSequenceNumber", ["SOAP::SOAPPositiveInteger", XSD::QName.new(NsV4, "DocumentPartSequenceNumber")], [0, 1]],
      ["image", ["SOAP::SOAPBase64", XSD::QName.new(NsV4, "Image")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::ShippingDocumentPrintDetail,
    :schema_type => XSD::QName.new(NsV4, "ShippingDocumentPrintDetail"),
    :schema_element => [
      ["printerId", ["SOAP::SOAPString", XSD::QName.new(NsV4, "PrinterId")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::ShippingDocumentStorageDetail,
    :schema_type => XSD::QName.new(NsV4, "ShippingDocumentStorageDetail"),
    :schema_element => [
      ["filePath", ["SOAP::SOAPString", XSD::QName.new(NsV4, "FilePath")], [0, 1]],
      ["fileNaming", ["FedexWebServices::Soap::Close::ShippingDocumentNamingType", XSD::QName.new(NsV4, "FileNaming")], [0, 1]],
      ["fileSuffix", ["SOAP::SOAPString", XSD::QName.new(NsV4, "FileSuffix")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::SmartPostCloseReply,
    :schema_type => XSD::QName.new(NsV4, "SmartPostCloseReply"),
    :schema_element => [
      ["highestSeverity", ["FedexWebServices::Soap::Close::NotificationSeverityType", XSD::QName.new(NsV4, "HighestSeverity")]],
      ["notifications", ["FedexWebServices::Soap::Close::Notification[]", XSD::QName.new(NsV4, "Notifications")], [1, nil]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::SmartPostCloseRequest,
    :schema_type => XSD::QName.new(NsV4, "SmartPostCloseRequest"),
    :schema_element => [
      ["webAuthenticationDetail", ["FedexWebServices::Soap::Close::WebAuthenticationDetail", XSD::QName.new(NsV4, "WebAuthenticationDetail")]],
      ["clientDetail", ["FedexWebServices::Soap::Close::ClientDetail", XSD::QName.new(NsV4, "ClientDetail")]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["hubId", ["SOAP::SOAPString", XSD::QName.new(NsV4, "HubId")], [0, 1]],
      ["customerManifestId", ["SOAP::SOAPString", XSD::QName.new(NsV4, "CustomerManifestId")], [0, 1]],
      ["destinationCountryCode", ["SOAP::SOAPString", XSD::QName.new(NsV4, "DestinationCountryCode")], [0, 1]],
      ["pickUpCarrier", ["FedexWebServices::Soap::Close::CarrierCodeType", XSD::QName.new(NsV4, "PickUpCarrier")], [0, 1]],
      ["manifestReferenceDetail", ["FedexWebServices::Soap::Close::CloseManifestReferenceDetail", XSD::QName.new(NsV4, "ManifestReferenceDetail")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::TransactionDetail,
    :schema_type => XSD::QName.new(NsV4, "TransactionDetail"),
    :schema_element => [
      ["customerTransactionId", ["SOAP::SOAPString", XSD::QName.new(NsV4, "CustomerTransactionId")], [0, 1]],
      ["localization", ["FedexWebServices::Soap::Close::Localization", XSD::QName.new(NsV4, "Localization")], [0, 1]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::WebAuthenticationDetail,
    :schema_type => XSD::QName.new(NsV4, "WebAuthenticationDetail"),
    :schema_element => [
      ["parentCredential", ["FedexWebServices::Soap::Close::WebAuthenticationCredential", XSD::QName.new(NsV4, "ParentCredential")], [0, 1]],
      ["userCredential", ["FedexWebServices::Soap::Close::WebAuthenticationCredential", XSD::QName.new(NsV4, "UserCredential")]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::WebAuthenticationCredential,
    :schema_type => XSD::QName.new(NsV4, "WebAuthenticationCredential"),
    :schema_element => [
      ["key", ["SOAP::SOAPString", XSD::QName.new(NsV4, "Key")]],
      ["password", ["SOAP::SOAPString", XSD::QName.new(NsV4, "Password")]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::VersionId,
    :schema_type => XSD::QName.new(NsV4, "VersionId"),
    :schema_element => [
      ["serviceId", ["SOAP::SOAPString", XSD::QName.new(NsV4, "ServiceId")]],
      ["major", ["SOAP::SOAPInt", XSD::QName.new(NsV4, "Major")]],
      ["intermediate", ["SOAP::SOAPInt", XSD::QName.new(NsV4, "Intermediate")]],
      ["minor", ["SOAP::SOAPInt", XSD::QName.new(NsV4, "Minor")]]
    ]
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::CarrierCodeType,
    :schema_type => XSD::QName.new(NsV4, "CarrierCodeType")
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseActionType,
    :schema_type => XSD::QName.new(NsV4, "CloseActionType")
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseDocumentType,
    :schema_type => XSD::QName.new(NsV4, "CloseDocumentType")
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseGroupingType,
    :schema_type => XSD::QName.new(NsV4, "CloseGroupingType")
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseReportType,
    :schema_type => XSD::QName.new(NsV4, "CloseReportType")
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseWithDocumentsProcessingOptionType,
    :schema_type => XSD::QName.new(NsV4, "CloseWithDocumentsProcessingOptionType")
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::CustomerImageUsageType,
    :schema_type => XSD::QName.new(NsV4, "CustomerImageUsageType")
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::CustomerReferenceType,
    :schema_type => XSD::QName.new(NsV4, "CustomerReferenceType")
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::EMailNotificationRecipientType,
    :schema_type => XSD::QName.new(NsV4, "EMailNotificationRecipientType")
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::ImageId,
    :schema_type => XSD::QName.new(NsV4, "ImageId")
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::InternalImageType,
    :schema_type => XSD::QName.new(NsV4, "InternalImageType")
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::LinearUnits,
    :schema_type => XSD::QName.new(NsV4, "LinearUnits")
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::NotificationSeverityType,
    :schema_type => XSD::QName.new(NsV4, "NotificationSeverityType")
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::ReprintGroundCloseDocumentsOptionType,
    :schema_type => XSD::QName.new(NsV4, "ReprintGroundCloseDocumentsOptionType")
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::ShippingDocumentDispositionType,
    :schema_type => XSD::QName.new(NsV4, "ShippingDocumentDispositionType")
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::ShippingDocumentEMailGroupingType,
    :schema_type => XSD::QName.new(NsV4, "ShippingDocumentEMailGroupingType")
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::ShippingDocumentGroupingType,
    :schema_type => XSD::QName.new(NsV4, "ShippingDocumentGroupingType")
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::ShippingDocumentImageType,
    :schema_type => XSD::QName.new(NsV4, "ShippingDocumentImageType")
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::ShippingDocumentNamingType,
    :schema_type => XSD::QName.new(NsV4, "ShippingDocumentNamingType")
  )

  EncodedRegistry.register(
    :class => FedexWebServices::Soap::Close::ShippingDocumentStockType,
    :schema_type => XSD::QName.new(NsV4, "ShippingDocumentStockType")
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::ClientDetail,
    :schema_type => XSD::QName.new(NsV4, "ClientDetail"),
    :schema_element => [
      ["accountNumber", ["SOAP::SOAPString", XSD::QName.new(NsV4, "AccountNumber")]],
      ["meterNumber", ["SOAP::SOAPString", XSD::QName.new(NsV4, "MeterNumber")]],
      ["integratorId", ["SOAP::SOAPString", XSD::QName.new(NsV4, "IntegratorId")], [0, 1]],
      ["localization", ["FedexWebServices::Soap::Close::Localization", XSD::QName.new(NsV4, "Localization")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseDocument,
    :schema_type => XSD::QName.new(NsV4, "CloseDocument"),
    :schema_element => [
      ["type", ["FedexWebServices::Soap::Close::CloseDocumentType", XSD::QName.new(NsV4, "Type")], [0, 1]],
      ["shippingCycle", ["SOAP::SOAPString", XSD::QName.new(NsV4, "ShippingCycle")], [0, 1]],
      ["shippingDocumentDisposition", ["FedexWebServices::Soap::Close::ShippingDocumentDispositionType", XSD::QName.new(NsV4, "ShippingDocumentDisposition")], [0, 1]],
      ["accessReference", ["SOAP::SOAPString", XSD::QName.new(NsV4, "AccessReference")], [0, 1]],
      ["resolution", ["SOAP::SOAPNonNegativeInteger", XSD::QName.new(NsV4, "Resolution")], [0, 1]],
      ["copiesToPrint", ["SOAP::SOAPNonNegativeInteger", XSD::QName.new(NsV4, "CopiesToPrint")], [0, 1]],
      ["parts", ["FedexWebServices::Soap::Close::ShippingDocumentPart[]", XSD::QName.new(NsV4, "Parts")], [0, nil]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseDocumentFormat,
    :schema_type => XSD::QName.new(NsV4, "CloseDocumentFormat"),
    :schema_element => [
      ["dispositions", ["FedexWebServices::Soap::Close::ShippingDocumentDispositionDetail[]", XSD::QName.new(NsV4, "Dispositions")], [0, nil]],
      ["topOfPageOffset", ["FedexWebServices::Soap::Close::LinearMeasure", XSD::QName.new(NsV4, "TopOfPageOffset")], [0, 1]],
      ["imageType", ["FedexWebServices::Soap::Close::ShippingDocumentImageType", XSD::QName.new(NsV4, "ImageType")], [0, 1]],
      ["stockType", ["FedexWebServices::Soap::Close::ShippingDocumentStockType", XSD::QName.new(NsV4, "StockType")], [0, 1]],
      ["provideInstructions", ["SOAP::SOAPBoolean", XSD::QName.new(NsV4, "ProvideInstructions")], [0, 1]],
      ["localization", ["FedexWebServices::Soap::Close::Localization", XSD::QName.new(NsV4, "Localization")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseDocumentSpecification,
    :schema_type => XSD::QName.new(NsV4, "CloseDocumentSpecification"),
    :schema_element => [
      ["closeDocumentTypes", ["FedexWebServices::Soap::Close::CloseDocumentType[]", XSD::QName.new(NsV4, "CloseDocumentTypes")], [0, nil]],
      ["detailedDeliveryManifestDetail", ["FedexWebServices::Soap::Close::DetailedDeliveryManifestDetail", XSD::QName.new(NsV4, "DetailedDeliveryManifestDetail")], [0, 1]],
      ["manifestDetail", ["FedexWebServices::Soap::Close::ManifestDetail", XSD::QName.new(NsV4, "ManifestDetail")], [0, 1]],
      ["op950Detail", ["FedexWebServices::Soap::Close::Op950Detail", XSD::QName.new(NsV4, "Op950Detail")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseManifestReferenceDetail,
    :schema_type => XSD::QName.new(NsV4, "CloseManifestReferenceDetail"),
    :schema_element => [
      ["type", ["FedexWebServices::Soap::Close::CustomerReferenceType", XSD::QName.new(NsV4, "Type")], [0, 1]],
      ["value", ["SOAP::SOAPString", XSD::QName.new(NsV4, "Value")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseSmartPostDetail,
    :schema_type => XSD::QName.new(NsV4, "CloseSmartPostDetail"),
    :schema_element => [
      ["hubId", ["SOAP::SOAPString", XSD::QName.new(NsV4, "HubId")], [0, 1]],
      ["customerId", ["SOAP::SOAPString", XSD::QName.new(NsV4, "CustomerId")], [0, 1]],
      ["customerManifestId", ["SOAP::SOAPString", XSD::QName.new(NsV4, "CustomerManifestId")], [0, 1]],
      ["destinationCountryCode", ["SOAP::SOAPString", XSD::QName.new(NsV4, "DestinationCountryCode")], [0, 1]],
      ["pickupCarrier", ["FedexWebServices::Soap::Close::CarrierCodeType", XSD::QName.new(NsV4, "PickupCarrier")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseWithDocumentsProcessingOptionsRequested,
    :schema_type => XSD::QName.new(NsV4, "CloseWithDocumentsProcessingOptionsRequested"),
    :schema_element => [
      ["options", ["FedexWebServices::Soap::Close::CloseWithDocumentsProcessingOptionType[]", XSD::QName.new(NsV4, "Options")], [0, nil]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseWithDocumentsReply,
    :schema_type => XSD::QName.new(NsV4, "CloseWithDocumentsReply"),
    :schema_element => [
      ["highestSeverity", ["FedexWebServices::Soap::Close::NotificationSeverityType", XSD::QName.new(NsV4, "HighestSeverity")]],
      ["notifications", ["FedexWebServices::Soap::Close::Notification[]", XSD::QName.new(NsV4, "Notifications")], [1, nil]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["documents", ["FedexWebServices::Soap::Close::CloseDocument[]", XSD::QName.new(NsV4, "Documents")], [0, nil]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseWithDocumentsRequest,
    :schema_type => XSD::QName.new(NsV4, "CloseWithDocumentsRequest"),
    :schema_element => [
      ["webAuthenticationDetail", ["FedexWebServices::Soap::Close::WebAuthenticationDetail", XSD::QName.new(NsV4, "WebAuthenticationDetail")]],
      ["clientDetail", ["FedexWebServices::Soap::Close::ClientDetail", XSD::QName.new(NsV4, "ClientDetail")]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["actionType", ["FedexWebServices::Soap::Close::CloseActionType", XSD::QName.new(NsV4, "ActionType")], [0, 1]],
      ["processingOptions", ["FedexWebServices::Soap::Close::CloseWithDocumentsProcessingOptionsRequested", XSD::QName.new(NsV4, "ProcessingOptions")], [0, 1]],
      ["carrierCode", ["FedexWebServices::Soap::Close::CarrierCodeType", XSD::QName.new(NsV4, "CarrierCode")], [0, 1]],
      ["shippingCycle", ["SOAP::SOAPString", XSD::QName.new(NsV4, "ShippingCycle")], [0, 1]],
      ["reprintCloseDate", ["SOAP::SOAPDateTime", XSD::QName.new(NsV4, "ReprintCloseDate")], [0, 1]],
      ["manifestReferenceDetail", ["FedexWebServices::Soap::Close::CloseManifestReferenceDetail", XSD::QName.new(NsV4, "ManifestReferenceDetail")], [0, 1]],
      ["smartPostDetail", ["FedexWebServices::Soap::Close::CloseSmartPostDetail", XSD::QName.new(NsV4, "SmartPostDetail")], [0, 1]],
      ["closeDocumentSpecification", ["FedexWebServices::Soap::Close::CloseDocumentSpecification", XSD::QName.new(NsV4, "CloseDocumentSpecification")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::CustomerImageUsage,
    :schema_type => XSD::QName.new(NsV4, "CustomerImageUsage"),
    :schema_element => [
      ["type", ["FedexWebServices::Soap::Close::CustomerImageUsageType", XSD::QName.new(NsV4, "Type")], [0, 1]],
      ["id", ["FedexWebServices::Soap::Close::ImageId", XSD::QName.new(NsV4, "Id")], [0, 1]],
      ["internalId", ["SOAP::SOAPString", XSD::QName.new(NsV4, "InternalId")], [0, 1]],
      ["internalImageType", ["FedexWebServices::Soap::Close::InternalImageType", XSD::QName.new(NsV4, "InternalImageType")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::DetailedDeliveryManifestDetail,
    :schema_type => XSD::QName.new(NsV4, "DetailedDeliveryManifestDetail"),
    :schema_element => [
      ["format", ["FedexWebServices::Soap::Close::CloseDocumentFormat", XSD::QName.new(NsV4, "Format")], [0, 1]],
      ["clientTimeZoneOffset", ["SOAP::SOAPString", XSD::QName.new(NsV4, "ClientTimeZoneOffset")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::GroundCloseDocumentsReply,
    :schema_type => XSD::QName.new(NsV4, "GroundCloseDocumentsReply"),
    :schema_element => [
      ["highestSeverity", ["FedexWebServices::Soap::Close::NotificationSeverityType", XSD::QName.new(NsV4, "HighestSeverity")]],
      ["notifications", ["FedexWebServices::Soap::Close::Notification[]", XSD::QName.new(NsV4, "Notifications")], [1, nil]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["closeDocuments", ["FedexWebServices::Soap::Close::CloseDocument[]", XSD::QName.new(NsV4, "CloseDocuments")], [0, nil]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::GroundCloseReply,
    :schema_type => XSD::QName.new(NsV4, "GroundCloseReply"),
    :schema_element => [
      ["highestSeverity", ["FedexWebServices::Soap::Close::NotificationSeverityType", XSD::QName.new(NsV4, "HighestSeverity")]],
      ["notifications", ["FedexWebServices::Soap::Close::Notification[]", XSD::QName.new(NsV4, "Notifications")], [1, nil]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["codReport", ["SOAP::SOAPBase64", XSD::QName.new(NsV4, "CodReport")], [0, 1]],
      ["hazMatCertificate", ["SOAP::SOAPBase64", XSD::QName.new(NsV4, "HazMatCertificate")], [0, 1]],
      ["manifest", ["FedexWebServices::Soap::Close::ManifestFile", XSD::QName.new(NsV4, "Manifest")], [0, 1]],
      ["multiweightReport", ["SOAP::SOAPBase64", XSD::QName.new(NsV4, "MultiweightReport")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::GroundCloseReportsReprintReply,
    :schema_type => XSD::QName.new(NsV4, "GroundCloseReportsReprintReply"),
    :schema_element => [
      ["highestSeverity", ["FedexWebServices::Soap::Close::NotificationSeverityType", XSD::QName.new(NsV4, "HighestSeverity")]],
      ["notifications", ["FedexWebServices::Soap::Close::Notification[]", XSD::QName.new(NsV4, "Notifications")], [1, nil]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["codReport", ["SOAP::SOAPBase64", XSD::QName.new(NsV4, "CodReport")], [0, 1]],
      ["hazMatCertificate", ["SOAP::SOAPBase64", XSD::QName.new(NsV4, "HazMatCertificate")], [0, 1]],
      ["manifests", ["FedexWebServices::Soap::Close::ManifestFile[]", XSD::QName.new(NsV4, "Manifests")], [0, nil]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::GroundCloseReportsReprintRequest,
    :schema_type => XSD::QName.new(NsV4, "GroundCloseReportsReprintRequest"),
    :schema_element => [
      ["webAuthenticationDetail", ["FedexWebServices::Soap::Close::WebAuthenticationDetail", XSD::QName.new(NsV4, "WebAuthenticationDetail")]],
      ["clientDetail", ["FedexWebServices::Soap::Close::ClientDetail", XSD::QName.new(NsV4, "ClientDetail")]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["reportDate", ["SOAP::SOAPDate", XSD::QName.new(NsV4, "ReportDate")], [0, 1]],
      ["trackingNumber", ["SOAP::SOAPString", XSD::QName.new(NsV4, "TrackingNumber")], [0, 1]],
      ["closeReportType", ["FedexWebServices::Soap::Close::CloseReportType", XSD::QName.new(NsV4, "CloseReportType")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::GroundCloseRequest,
    :schema_type => XSD::QName.new(NsV4, "GroundCloseRequest"),
    :schema_element => [
      ["webAuthenticationDetail", ["FedexWebServices::Soap::Close::WebAuthenticationDetail", XSD::QName.new(NsV4, "WebAuthenticationDetail")]],
      ["clientDetail", ["FedexWebServices::Soap::Close::ClientDetail", XSD::QName.new(NsV4, "ClientDetail")]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["closeGrouping", ["FedexWebServices::Soap::Close::CloseGroupingType", XSD::QName.new(NsV4, "CloseGrouping")], [0, 1]],
      ["timeUpToWhichShipmentsAreToBeClosed", ["SOAP::SOAPDateTime", XSD::QName.new(NsV4, "TimeUpToWhichShipmentsAreToBeClosed")], [0, 1]],
      ["manifestReferenceDetail", ["FedexWebServices::Soap::Close::CloseManifestReferenceDetail", XSD::QName.new(NsV4, "ManifestReferenceDetail")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::GroundCloseWithDocumentsRequest,
    :schema_type => XSD::QName.new(NsV4, "GroundCloseWithDocumentsRequest"),
    :schema_element => [
      ["webAuthenticationDetail", ["FedexWebServices::Soap::Close::WebAuthenticationDetail", XSD::QName.new(NsV4, "WebAuthenticationDetail")]],
      ["clientDetail", ["FedexWebServices::Soap::Close::ClientDetail", XSD::QName.new(NsV4, "ClientDetail")]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["closeDate", ["SOAP::SOAPDate", XSD::QName.new(NsV4, "CloseDate")], [0, 1]],
      ["closeDocumentSpecification", ["FedexWebServices::Soap::Close::CloseDocumentSpecification", XSD::QName.new(NsV4, "CloseDocumentSpecification")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::LinearMeasure,
    :schema_type => XSD::QName.new(NsV4, "LinearMeasure"),
    :schema_element => [
      ["value", ["SOAP::SOAPDecimal", XSD::QName.new(NsV4, "Value")], [0, 1]],
      ["units", ["FedexWebServices::Soap::Close::LinearUnits", XSD::QName.new(NsV4, "Units")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::Localization,
    :schema_type => XSD::QName.new(NsV4, "Localization"),
    :schema_element => [
      ["languageCode", ["SOAP::SOAPString", XSD::QName.new(NsV4, "LanguageCode")]],
      ["localeCode", ["SOAP::SOAPString", XSD::QName.new(NsV4, "LocaleCode")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::ManifestDetail,
    :schema_type => XSD::QName.new(NsV4, "ManifestDetail"),
    :schema_element => [
      ["format", ["FedexWebServices::Soap::Close::CloseDocumentFormat", XSD::QName.new(NsV4, "Format")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::ManifestFile,
    :schema_type => XSD::QName.new(NsV4, "ManifestFile"),
    :schema_element => [
      ["fileName", ["SOAP::SOAPString", XSD::QName.new(NsV4, "FileName")], [0, 1]],
      ["file", ["SOAP::SOAPBase64", XSD::QName.new(NsV4, "File")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::Notification,
    :schema_type => XSD::QName.new(NsV4, "Notification"),
    :schema_element => [
      ["severity", ["FedexWebServices::Soap::Close::NotificationSeverityType", XSD::QName.new(NsV4, "Severity")], [0, 1]],
      ["source", ["SOAP::SOAPString", XSD::QName.new(NsV4, "Source")], [0, 1]],
      ["code", ["SOAP::SOAPString", XSD::QName.new(NsV4, "Code")], [0, 1]],
      ["message", ["SOAP::SOAPString", XSD::QName.new(NsV4, "Message")], [0, 1]],
      ["localizedMessage", ["SOAP::SOAPString", XSD::QName.new(NsV4, "LocalizedMessage")], [0, 1]],
      ["messageParameters", ["FedexWebServices::Soap::Close::NotificationParameter[]", XSD::QName.new(NsV4, "MessageParameters")], [0, nil]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::NotificationParameter,
    :schema_type => XSD::QName.new(NsV4, "NotificationParameter"),
    :schema_element => [
      ["id", ["SOAP::SOAPString", XSD::QName.new(NsV4, "Id")], [0, 1]],
      ["value", ["SOAP::SOAPString", XSD::QName.new(NsV4, "Value")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::Op950Detail,
    :schema_type => XSD::QName.new(NsV4, "Op950Detail"),
    :schema_element => [
      ["format", ["FedexWebServices::Soap::Close::CloseDocumentFormat", XSD::QName.new(NsV4, "Format")], [0, 1]],
      ["customerImageUsages", ["FedexWebServices::Soap::Close::CustomerImageUsage[]", XSD::QName.new(NsV4, "CustomerImageUsages")], [0, nil]],
      ["signatureName", ["SOAP::SOAPString", XSD::QName.new(NsV4, "SignatureName")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::ReprintGroundCloseDocumentsRequest,
    :schema_type => XSD::QName.new(NsV4, "ReprintGroundCloseDocumentsRequest"),
    :schema_element => [
      ["webAuthenticationDetail", ["FedexWebServices::Soap::Close::WebAuthenticationDetail", XSD::QName.new(NsV4, "WebAuthenticationDetail")]],
      ["clientDetail", ["FedexWebServices::Soap::Close::ClientDetail", XSD::QName.new(NsV4, "ClientDetail")]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["reprintOption", ["FedexWebServices::Soap::Close::ReprintGroundCloseDocumentsOptionType", XSD::QName.new(NsV4, "ReprintOption")], [0, 1]],
      ["closeDate", ["SOAP::SOAPDate", XSD::QName.new(NsV4, "CloseDate")], [0, 1]],
      ["trackingNumber", ["SOAP::SOAPString", XSD::QName.new(NsV4, "TrackingNumber")], [0, 1]],
      ["closeDocumentSpecification", ["FedexWebServices::Soap::Close::CloseDocumentSpecification", XSD::QName.new(NsV4, "CloseDocumentSpecification")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::ShippingDocumentDispositionDetail,
    :schema_type => XSD::QName.new(NsV4, "ShippingDocumentDispositionDetail"),
    :schema_element => [
      ["dispositionType", ["FedexWebServices::Soap::Close::ShippingDocumentDispositionType", XSD::QName.new(NsV4, "DispositionType")], [0, 1]],
      ["grouping", ["FedexWebServices::Soap::Close::ShippingDocumentGroupingType", XSD::QName.new(NsV4, "Grouping")], [0, 1]],
      ["storageDetail", ["FedexWebServices::Soap::Close::ShippingDocumentStorageDetail", XSD::QName.new(NsV4, "StorageDetail")], [0, 1]],
      ["eMailDetail", ["FedexWebServices::Soap::Close::ShippingDocumentEMailDetail", XSD::QName.new(NsV4, "EMailDetail")], [0, 1]],
      ["printDetail", ["FedexWebServices::Soap::Close::ShippingDocumentPrintDetail", XSD::QName.new(NsV4, "PrintDetail")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::ShippingDocumentEMailDetail,
    :schema_type => XSD::QName.new(NsV4, "ShippingDocumentEMailDetail"),
    :schema_element => [
      ["eMailRecipients", ["FedexWebServices::Soap::Close::ShippingDocumentEMailRecipient[]", XSD::QName.new(NsV4, "EMailRecipients")], [0, nil]],
      ["grouping", ["FedexWebServices::Soap::Close::ShippingDocumentEMailGroupingType", XSD::QName.new(NsV4, "Grouping")], [0, 1]],
      ["localization", ["FedexWebServices::Soap::Close::Localization", XSD::QName.new(NsV4, "Localization")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::ShippingDocumentEMailRecipient,
    :schema_type => XSD::QName.new(NsV4, "ShippingDocumentEMailRecipient"),
    :schema_element => [
      ["recipientType", ["FedexWebServices::Soap::Close::EMailNotificationRecipientType", XSD::QName.new(NsV4, "RecipientType")], [0, 1]],
      ["address", ["SOAP::SOAPString", XSD::QName.new(NsV4, "Address")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::ShippingDocumentPart,
    :schema_type => XSD::QName.new(NsV4, "ShippingDocumentPart"),
    :schema_element => [
      ["documentPartSequenceNumber", ["SOAP::SOAPPositiveInteger", XSD::QName.new(NsV4, "DocumentPartSequenceNumber")], [0, 1]],
      ["image", ["SOAP::SOAPBase64", XSD::QName.new(NsV4, "Image")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::ShippingDocumentPrintDetail,
    :schema_type => XSD::QName.new(NsV4, "ShippingDocumentPrintDetail"),
    :schema_element => [
      ["printerId", ["SOAP::SOAPString", XSD::QName.new(NsV4, "PrinterId")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::ShippingDocumentStorageDetail,
    :schema_type => XSD::QName.new(NsV4, "ShippingDocumentStorageDetail"),
    :schema_element => [
      ["filePath", ["SOAP::SOAPString", XSD::QName.new(NsV4, "FilePath")], [0, 1]],
      ["fileNaming", ["FedexWebServices::Soap::Close::ShippingDocumentNamingType", XSD::QName.new(NsV4, "FileNaming")], [0, 1]],
      ["fileSuffix", ["SOAP::SOAPString", XSD::QName.new(NsV4, "FileSuffix")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::SmartPostCloseReply,
    :schema_type => XSD::QName.new(NsV4, "SmartPostCloseReply"),
    :schema_element => [
      ["highestSeverity", ["FedexWebServices::Soap::Close::NotificationSeverityType", XSD::QName.new(NsV4, "HighestSeverity")]],
      ["notifications", ["FedexWebServices::Soap::Close::Notification[]", XSD::QName.new(NsV4, "Notifications")], [1, nil]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::SmartPostCloseRequest,
    :schema_type => XSD::QName.new(NsV4, "SmartPostCloseRequest"),
    :schema_element => [
      ["webAuthenticationDetail", ["FedexWebServices::Soap::Close::WebAuthenticationDetail", XSD::QName.new(NsV4, "WebAuthenticationDetail")]],
      ["clientDetail", ["FedexWebServices::Soap::Close::ClientDetail", XSD::QName.new(NsV4, "ClientDetail")]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["hubId", ["SOAP::SOAPString", XSD::QName.new(NsV4, "HubId")], [0, 1]],
      ["customerManifestId", ["SOAP::SOAPString", XSD::QName.new(NsV4, "CustomerManifestId")], [0, 1]],
      ["destinationCountryCode", ["SOAP::SOAPString", XSD::QName.new(NsV4, "DestinationCountryCode")], [0, 1]],
      ["pickUpCarrier", ["FedexWebServices::Soap::Close::CarrierCodeType", XSD::QName.new(NsV4, "PickUpCarrier")], [0, 1]],
      ["manifestReferenceDetail", ["FedexWebServices::Soap::Close::CloseManifestReferenceDetail", XSD::QName.new(NsV4, "ManifestReferenceDetail")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::TransactionDetail,
    :schema_type => XSD::QName.new(NsV4, "TransactionDetail"),
    :schema_element => [
      ["customerTransactionId", ["SOAP::SOAPString", XSD::QName.new(NsV4, "CustomerTransactionId")], [0, 1]],
      ["localization", ["FedexWebServices::Soap::Close::Localization", XSD::QName.new(NsV4, "Localization")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::WebAuthenticationDetail,
    :schema_type => XSD::QName.new(NsV4, "WebAuthenticationDetail"),
    :schema_element => [
      ["parentCredential", ["FedexWebServices::Soap::Close::WebAuthenticationCredential", XSD::QName.new(NsV4, "ParentCredential")], [0, 1]],
      ["userCredential", ["FedexWebServices::Soap::Close::WebAuthenticationCredential", XSD::QName.new(NsV4, "UserCredential")]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::WebAuthenticationCredential,
    :schema_type => XSD::QName.new(NsV4, "WebAuthenticationCredential"),
    :schema_element => [
      ["key", ["SOAP::SOAPString", XSD::QName.new(NsV4, "Key")]],
      ["password", ["SOAP::SOAPString", XSD::QName.new(NsV4, "Password")]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::VersionId,
    :schema_type => XSD::QName.new(NsV4, "VersionId"),
    :schema_element => [
      ["serviceId", ["SOAP::SOAPString", XSD::QName.new(NsV4, "ServiceId")]],
      ["major", ["SOAP::SOAPInt", XSD::QName.new(NsV4, "Major")]],
      ["intermediate", ["SOAP::SOAPInt", XSD::QName.new(NsV4, "Intermediate")]],
      ["minor", ["SOAP::SOAPInt", XSD::QName.new(NsV4, "Minor")]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::CarrierCodeType,
    :schema_type => XSD::QName.new(NsV4, "CarrierCodeType")
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseActionType,
    :schema_type => XSD::QName.new(NsV4, "CloseActionType")
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseDocumentType,
    :schema_type => XSD::QName.new(NsV4, "CloseDocumentType")
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseGroupingType,
    :schema_type => XSD::QName.new(NsV4, "CloseGroupingType")
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseReportType,
    :schema_type => XSD::QName.new(NsV4, "CloseReportType")
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseWithDocumentsProcessingOptionType,
    :schema_type => XSD::QName.new(NsV4, "CloseWithDocumentsProcessingOptionType")
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::CustomerImageUsageType,
    :schema_type => XSD::QName.new(NsV4, "CustomerImageUsageType")
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::CustomerReferenceType,
    :schema_type => XSD::QName.new(NsV4, "CustomerReferenceType")
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::EMailNotificationRecipientType,
    :schema_type => XSD::QName.new(NsV4, "EMailNotificationRecipientType")
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::ImageId,
    :schema_type => XSD::QName.new(NsV4, "ImageId")
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::InternalImageType,
    :schema_type => XSD::QName.new(NsV4, "InternalImageType")
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::LinearUnits,
    :schema_type => XSD::QName.new(NsV4, "LinearUnits")
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::NotificationSeverityType,
    :schema_type => XSD::QName.new(NsV4, "NotificationSeverityType")
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::ReprintGroundCloseDocumentsOptionType,
    :schema_type => XSD::QName.new(NsV4, "ReprintGroundCloseDocumentsOptionType")
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::ShippingDocumentDispositionType,
    :schema_type => XSD::QName.new(NsV4, "ShippingDocumentDispositionType")
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::ShippingDocumentEMailGroupingType,
    :schema_type => XSD::QName.new(NsV4, "ShippingDocumentEMailGroupingType")
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::ShippingDocumentGroupingType,
    :schema_type => XSD::QName.new(NsV4, "ShippingDocumentGroupingType")
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::ShippingDocumentImageType,
    :schema_type => XSD::QName.new(NsV4, "ShippingDocumentImageType")
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::ShippingDocumentNamingType,
    :schema_type => XSD::QName.new(NsV4, "ShippingDocumentNamingType")
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::ShippingDocumentStockType,
    :schema_type => XSD::QName.new(NsV4, "ShippingDocumentStockType")
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseWithDocumentsReply,
    :schema_name => XSD::QName.new(NsV4, "CloseWithDocumentsReply"),
    :schema_element => [
      ["highestSeverity", ["FedexWebServices::Soap::Close::NotificationSeverityType", XSD::QName.new(NsV4, "HighestSeverity")]],
      ["notifications", ["FedexWebServices::Soap::Close::Notification[]", XSD::QName.new(NsV4, "Notifications")], [1, nil]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["documents", ["FedexWebServices::Soap::Close::CloseDocument[]", XSD::QName.new(NsV4, "Documents")], [0, nil]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::CloseWithDocumentsRequest,
    :schema_name => XSD::QName.new(NsV4, "CloseWithDocumentsRequest"),
    :schema_element => [
      ["webAuthenticationDetail", ["FedexWebServices::Soap::Close::WebAuthenticationDetail", XSD::QName.new(NsV4, "WebAuthenticationDetail")]],
      ["clientDetail", ["FedexWebServices::Soap::Close::ClientDetail", XSD::QName.new(NsV4, "ClientDetail")]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["actionType", ["FedexWebServices::Soap::Close::CloseActionType", XSD::QName.new(NsV4, "ActionType")], [0, 1]],
      ["processingOptions", ["FedexWebServices::Soap::Close::CloseWithDocumentsProcessingOptionsRequested", XSD::QName.new(NsV4, "ProcessingOptions")], [0, 1]],
      ["carrierCode", ["FedexWebServices::Soap::Close::CarrierCodeType", XSD::QName.new(NsV4, "CarrierCode")], [0, 1]],
      ["shippingCycle", ["SOAP::SOAPString", XSD::QName.new(NsV4, "ShippingCycle")], [0, 1]],
      ["reprintCloseDate", ["SOAP::SOAPDateTime", XSD::QName.new(NsV4, "ReprintCloseDate")], [0, 1]],
      ["manifestReferenceDetail", ["FedexWebServices::Soap::Close::CloseManifestReferenceDetail", XSD::QName.new(NsV4, "ManifestReferenceDetail")], [0, 1]],
      ["smartPostDetail", ["FedexWebServices::Soap::Close::CloseSmartPostDetail", XSD::QName.new(NsV4, "SmartPostDetail")], [0, 1]],
      ["closeDocumentSpecification", ["FedexWebServices::Soap::Close::CloseDocumentSpecification", XSD::QName.new(NsV4, "CloseDocumentSpecification")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::GroundCloseDocumentsReply,
    :schema_name => XSD::QName.new(NsV4, "GroundCloseDocumentsReply"),
    :schema_element => [
      ["highestSeverity", ["FedexWebServices::Soap::Close::NotificationSeverityType", XSD::QName.new(NsV4, "HighestSeverity")]],
      ["notifications", ["FedexWebServices::Soap::Close::Notification[]", XSD::QName.new(NsV4, "Notifications")], [1, nil]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["closeDocuments", ["FedexWebServices::Soap::Close::CloseDocument[]", XSD::QName.new(NsV4, "CloseDocuments")], [0, nil]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::GroundCloseReply,
    :schema_name => XSD::QName.new(NsV4, "GroundCloseReply"),
    :schema_element => [
      ["highestSeverity", ["FedexWebServices::Soap::Close::NotificationSeverityType", XSD::QName.new(NsV4, "HighestSeverity")]],
      ["notifications", ["FedexWebServices::Soap::Close::Notification[]", XSD::QName.new(NsV4, "Notifications")], [1, nil]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["codReport", ["SOAP::SOAPBase64", XSD::QName.new(NsV4, "CodReport")], [0, 1]],
      ["hazMatCertificate", ["SOAP::SOAPBase64", XSD::QName.new(NsV4, "HazMatCertificate")], [0, 1]],
      ["manifest", ["FedexWebServices::Soap::Close::ManifestFile", XSD::QName.new(NsV4, "Manifest")], [0, 1]],
      ["multiweightReport", ["SOAP::SOAPBase64", XSD::QName.new(NsV4, "MultiweightReport")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::GroundCloseReportsReprintReply,
    :schema_name => XSD::QName.new(NsV4, "GroundCloseReportsReprintReply"),
    :schema_element => [
      ["highestSeverity", ["FedexWebServices::Soap::Close::NotificationSeverityType", XSD::QName.new(NsV4, "HighestSeverity")]],
      ["notifications", ["FedexWebServices::Soap::Close::Notification[]", XSD::QName.new(NsV4, "Notifications")], [1, nil]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["codReport", ["SOAP::SOAPBase64", XSD::QName.new(NsV4, "CodReport")], [0, 1]],
      ["hazMatCertificate", ["SOAP::SOAPBase64", XSD::QName.new(NsV4, "HazMatCertificate")], [0, 1]],
      ["manifests", ["FedexWebServices::Soap::Close::ManifestFile[]", XSD::QName.new(NsV4, "Manifests")], [0, nil]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::GroundCloseReportsReprintRequest,
    :schema_name => XSD::QName.new(NsV4, "GroundCloseReportsReprintRequest"),
    :schema_element => [
      ["webAuthenticationDetail", ["FedexWebServices::Soap::Close::WebAuthenticationDetail", XSD::QName.new(NsV4, "WebAuthenticationDetail")]],
      ["clientDetail", ["FedexWebServices::Soap::Close::ClientDetail", XSD::QName.new(NsV4, "ClientDetail")]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["reportDate", ["SOAP::SOAPDate", XSD::QName.new(NsV4, "ReportDate")], [0, 1]],
      ["trackingNumber", ["SOAP::SOAPString", XSD::QName.new(NsV4, "TrackingNumber")], [0, 1]],
      ["closeReportType", ["FedexWebServices::Soap::Close::CloseReportType", XSD::QName.new(NsV4, "CloseReportType")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::GroundCloseRequest,
    :schema_name => XSD::QName.new(NsV4, "GroundCloseRequest"),
    :schema_element => [
      ["webAuthenticationDetail", ["FedexWebServices::Soap::Close::WebAuthenticationDetail", XSD::QName.new(NsV4, "WebAuthenticationDetail")]],
      ["clientDetail", ["FedexWebServices::Soap::Close::ClientDetail", XSD::QName.new(NsV4, "ClientDetail")]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["closeGrouping", ["FedexWebServices::Soap::Close::CloseGroupingType", XSD::QName.new(NsV4, "CloseGrouping")], [0, 1]],
      ["timeUpToWhichShipmentsAreToBeClosed", ["SOAP::SOAPDateTime", XSD::QName.new(NsV4, "TimeUpToWhichShipmentsAreToBeClosed")], [0, 1]],
      ["manifestReferenceDetail", ["FedexWebServices::Soap::Close::CloseManifestReferenceDetail", XSD::QName.new(NsV4, "ManifestReferenceDetail")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::GroundCloseWithDocumentsRequest,
    :schema_name => XSD::QName.new(NsV4, "GroundCloseWithDocumentsRequest"),
    :schema_element => [
      ["webAuthenticationDetail", ["FedexWebServices::Soap::Close::WebAuthenticationDetail", XSD::QName.new(NsV4, "WebAuthenticationDetail")]],
      ["clientDetail", ["FedexWebServices::Soap::Close::ClientDetail", XSD::QName.new(NsV4, "ClientDetail")]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["closeDate", ["SOAP::SOAPDate", XSD::QName.new(NsV4, "CloseDate")], [0, 1]],
      ["closeDocumentSpecification", ["FedexWebServices::Soap::Close::CloseDocumentSpecification", XSD::QName.new(NsV4, "CloseDocumentSpecification")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::ReprintGroundCloseDocumentsRequest,
    :schema_name => XSD::QName.new(NsV4, "ReprintGroundCloseDocumentsRequest"),
    :schema_element => [
      ["webAuthenticationDetail", ["FedexWebServices::Soap::Close::WebAuthenticationDetail", XSD::QName.new(NsV4, "WebAuthenticationDetail")]],
      ["clientDetail", ["FedexWebServices::Soap::Close::ClientDetail", XSD::QName.new(NsV4, "ClientDetail")]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["reprintOption", ["FedexWebServices::Soap::Close::ReprintGroundCloseDocumentsOptionType", XSD::QName.new(NsV4, "ReprintOption")], [0, 1]],
      ["closeDate", ["SOAP::SOAPDate", XSD::QName.new(NsV4, "CloseDate")], [0, 1]],
      ["trackingNumber", ["SOAP::SOAPString", XSD::QName.new(NsV4, "TrackingNumber")], [0, 1]],
      ["closeDocumentSpecification", ["FedexWebServices::Soap::Close::CloseDocumentSpecification", XSD::QName.new(NsV4, "CloseDocumentSpecification")], [0, 1]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::SmartPostCloseReply,
    :schema_name => XSD::QName.new(NsV4, "SmartPostCloseReply"),
    :schema_element => [
      ["highestSeverity", ["FedexWebServices::Soap::Close::NotificationSeverityType", XSD::QName.new(NsV4, "HighestSeverity")]],
      ["notifications", ["FedexWebServices::Soap::Close::Notification[]", XSD::QName.new(NsV4, "Notifications")], [1, nil]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]]
    ]
  )

  LiteralRegistry.register(
    :class => FedexWebServices::Soap::Close::SmartPostCloseRequest,
    :schema_name => XSD::QName.new(NsV4, "SmartPostCloseRequest"),
    :schema_element => [
      ["webAuthenticationDetail", ["FedexWebServices::Soap::Close::WebAuthenticationDetail", XSD::QName.new(NsV4, "WebAuthenticationDetail")]],
      ["clientDetail", ["FedexWebServices::Soap::Close::ClientDetail", XSD::QName.new(NsV4, "ClientDetail")]],
      ["transactionDetail", ["FedexWebServices::Soap::Close::TransactionDetail", XSD::QName.new(NsV4, "TransactionDetail")], [0, 1]],
      ["version", ["FedexWebServices::Soap::Close::VersionId", XSD::QName.new(NsV4, "Version")]],
      ["hubId", ["SOAP::SOAPString", XSD::QName.new(NsV4, "HubId")], [0, 1]],
      ["customerManifestId", ["SOAP::SOAPString", XSD::QName.new(NsV4, "CustomerManifestId")], [0, 1]],
      ["destinationCountryCode", ["SOAP::SOAPString", XSD::QName.new(NsV4, "DestinationCountryCode")], [0, 1]],
      ["pickUpCarrier", ["FedexWebServices::Soap::Close::CarrierCodeType", XSD::QName.new(NsV4, "PickUpCarrier")], [0, 1]],
      ["manifestReferenceDetail", ["FedexWebServices::Soap::Close::CloseManifestReferenceDetail", XSD::QName.new(NsV4, "ManifestReferenceDetail")], [0, 1]]
    ]
  )
end

end; end; end


text:
package com.perrinn.appservice.beans;

import java.sql.Date;

/**
 * Created by alessandrosilacci on 27/09/16.
 */
public class ActivityEntity {
    private int id;
    private Date createDate;
    private Integer createId;
    private Date changeDate;
    private Integer changeId;
    private byte active;
    private String content;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Date getCreateDate() {
        return createDate;
    }

    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }

    public Integer getCreateId() {
        return createId;
    }

    public void setCreateId(Integer createId) {
        this.createId = createId;
    }

    public Date getChangeDate() {
        return changeDate;
    }

    public void setChangeDate(Date changeDate) {
        this.changeDate = changeDate;
    }

    public Integer getChangeId() {
        return changeId;
    }

    public void setChangeId(Integer changeId) {
        this.changeId = changeId;
    }

    public byte getActive() {
        return active;
    }

    public void setActive(byte active) {
        this.active = active;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        ActivityEntity that = (ActivityEntity) o;

        if (id != that.id) return false;
        if (active != that.active) return false;
        if (createDate != null ? !createDate.equals(that.createDate) : that.createDate != null) return false;
        if (createId != null ? !createId.equals(that.createId) : that.createId != null) return false;
        if (changeDate != null ? !changeDate.equals(that.changeDate) : that.changeDate != null) return false;
        if (changeId != null ? !changeId.equals(that.changeId) : that.changeId != null) return false;
        if (content != null ? !content.equals(that.content) : that.content != null) return false;

        return true;
    }

    @Override
    public int hashCode() {
        int result = id;
        result = 31 * result + (createDate != null ? createDate.hashCode() : 0);
        result = 31 * result + (createId != null ? createId.hashCode() : 0);
        result = 31 * result + (changeDate != null ? changeDate.hashCode() : 0);
        result = 31 * result + (changeId != null ? changeId.hashCode() : 0);
        result = 31 * result + (int) active;
        result = 31 * result + (content != null ? content.hashCode() : 0);
        return result;
    }
}

redpajama_set_name: RedPajamaGithub


text:
package jhi.buntata.data;

import java.sql.*;

/**
 * @author Sebastian Raubach
 */
class DatabaseUtils
{
	static PreparedStatement getStatement(Connection con, String query, Object... bits) throws SQLException
	{
		PreparedStatement stmt = con.prepareStatement(query);

		int i = 1;
		if (bits != null)
		{
			for (Object bit : bits)
				stmt.setObject(i++, bit);
		}

		return stmt;
	}
}


text:
<?php

namespace App\Entities\Base;

use Doctrine\ORM\Mapping as ORM;
use Doctrine\Common\Collections\ArrayCollection;

/**
 * App\Entities\Base\Asset
 *
 * @ORM\MappedSuperclass
 * @ORM\Table(name="`assets`", indexes={@ORM\Index(name="assets_user_fk_idx", columns={"`user_id`"}), @ORM\Index(name="assets_file_fk", columns={"`file_id`"})})
 */
class Asset extends AbstractEntity
{
    /** Table name constant */
    const TABLE_NAME = 'assets';

    /** Column name constants */
    const NAME          = 'name';
    const CPE           = 'cpe';
    const VENDOR        = 'vendor';
    const IP_ADDRESS_V4 = 'ip_address_v4';
    const IP_ADDRESS_V6 = 'ip_address_v6';
    const HOSTNAME      = 'hostname';
    const MAC_ADDRESS   = 'mac_address';
    const MAC_VENDOR    = 'mac_vendor';
    const OS_VERSION    = 'os_version';
    const NETBIOS       = 'netbios';
    const UPTIME        = 'uptime';
    const LAST_BOOT     = 'last_boot';
    const FILE_ID       = 'file_id';
    const USER_ID       = 'user_id';
    const SUPPRESSED    = 'suppressed';
    const DELETED       = 'deleted';
    const OPENPORTS     = 'openPorts';
    const FILE          = 'file';
    const USER          = 'user';

    /**
     * @ORM\Id
     * @ORM\Column(name="`id`", type="integer", options={"unsigned":true})
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    protected $id;

    /**
     * @ORM\Column(name="`name`", type="string", length=255)
     */
    protected $name;

    /**
     * @ORM\Column(name="`cpe`", type="string", length=255, nullable=true)
     */
    protected $cpe;

    /**
     * @ORM\Column(name="`vendor`", type="string", length=45, nullable=true)
     */
    protected $vendor;

    /**
     * @ORM\Column(name="`ip_address_v4`", type="string", length=15, nullable=true)
     */
    protected $ip_address_v4;

    /**
     * @ORM\Column(name="`ip_address_v6`", type="string", length=45, nullable=true)
     */
    protected $ip_address_v6;

    /**
     * @ORM\Column(name="`hostname`", type="string", length=255, nullable=true)
     */
    protected $hostname;

    /**
     * @ORM\Column(name="`mac_address`", type="string", length=25, nullable=true)
     */
    protected $mac_address;

    /**
     * @ORM\Column(name="`mac_vendor`", type="string", length=100, nullable=true)
     */
    protected $mac_vendor;

    /**
     * @ORM\Column(name="`os_version`", type="string", length=20, nullable=true)
     */
    protected $os_version;

    /**
     * @ORM\Column(name="`netbios`", type="string", length=255, nullable=true)
     */
    protected $netbios;

    /**
     * @ORM\Column(name="`uptime`", type="integer", nullable=true, options={"unsigned":true})
     */
    protected $uptime;

    /**
     * @ORM\Column(name="`last_boot`", type="datetime", nullable=true)
     */
    protected $last_boot;

    /**
     * @ORM\Column(name="`file_id`", type="integer", options={"unsigned":true})
     */
    protected $file_id;

    /**
     * @ORM\Column(name="`user_id`", type="integer", options={"unsigned":true})
     */
    protected $user_id;

    /**
     * @ORM\Column(name="`suppressed`", type="boolean", options={"unsigned":true})
     */
    protected $suppressed;

    /**
     * @ORM\Column(name="`deleted`", type="boolean", options={"unsigned":true})
     */
    protected $deleted;

    /**
     * @ORM\Column(name="`created_at`", type="datetime")
     */
    protected $created_at;

    /**
     * @ORM\Column(name="`updated_at`", type="datetime")
     */
    protected $updated_at;

    /**
     * @ORM\OneToMany(targetEntity="OpenPort", mappedBy="asset", cascade={"persist"})
     * @ORM\JoinColumn(name="`id`", referencedColumnName="`asset_id`", nullable=false, onDelete="CASCADE")
     */
    protected $openPorts;

    /**
     * @ORM\ManyToOne(targetEntity="File", inversedBy="assets", cascade={"persist"})
     * @ORM\JoinColumn(name="`file_id`", referencedColumnName="`id`", nullable=false, onDelete="CASCADE")
     * @var File
     */
    protected $file;

    /**
     * @ORM\ManyToOne(targetEntity="User", inversedBy="assets", cascade={"persist"})
     * @ORM\JoinColumn(name="`user_id`", referencedColumnName="`id`", nullable=false)
     */
    protected $user;

    public function __construct()
    {
        $this->openPorts = new ArrayCollection();
    }

    /**
     * Set the value of id.
     *
     * @param integer $id
     * @return \App\Entities\Base\Asset
     */
    public function setId($id)
    {
        $this->id = $id;

        return $this;
    }

    /**
     * Get the value of id.
     *
     * @return integer
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * Set the value of name.
     *
     * @param string $name
     * @return \App\Entities\Base\Asset
     */
    public function setName($name)
    {
        $this->name = $name;

        return $this;
    }

    /**
     * Get the value of name.
     *
     * @return string
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * Set the value of cpe.
     *
     * @param string $cpe
     * @return \App\Entities\Base\Asset
     */
    public function setCpe($cpe)
    {
        $this->cpe = $cpe;

        return $this;
    }

    /**
     * Get the value of cpe.
     *
     * @return string
     */
    public function getCpe()
    {
        return $this->cpe;
    }

    /**
     * Set the value of vendor.
     *
     * @param string $vendor
     * @return \App\Entities\Base\Asset
     */
    public function setVendor($vendor)
    {
        $this->vendor = $vendor;

        return $this;
    }

    /**
     * Get the value of vendor.
     *
     * @return string
     */
    public function getVendor()
    {
        return $this->vendor;
    }

    /**
     * Set the value of ip_address_v4.
     *
     * @param string $ip_address_v4
     * @return \App\Entities\Base\Asset
     */
    public function setIpAddressV4($ip_address_v4)
    {
        $this->ip_address_v4 = $ip_address_v4;

        return $this;
    }

    /**
     * Get the value of ip_address_v4.
     *
     * @return string
     */
    public function getIpAddressV4()
    {
        return $this->ip_address_v4;
    }

    /**
     * Set the value of ip_address_v6.
     *
     * @param string $ip_address_v6
     * @return \App\Entities\Base\Asset
     */
    public function setIpAddressV6($ip_address_v6)
    {
        $this->ip_address_v6 = $ip_address_v6;

        return $this;
    }

    /**
     * Get the value of ip_address_v6.
     *
     * @return string
     */
    public function getIpAddressV6()
    {
        return $this->ip_address_v6;
    }

    /**
     * Set the value of hostname.
     *
     * @param string $hostname
     * @return \App\Entities\Base\Asset
     */
    public function setHostname($hostname)
    {
        $this->hostname = $hostname;

        return $this;
    }

    /**
     * Get the value of hostname.
     *
     * @return string
     */
    public function getHostname()
    {
        return $this->hostname;
    }

    /**
     * Set the value of mac_address.
     *
     * @param string $mac_address
     * @return \App\Entities\Base\Asset
     */
    public function setMacAddress($mac_address)
    {
        $this->mac_address = $mac_address;

        return $this;
    }

    /**
     * Get the value of mac_address.
     *
     * @return string
     */
    public function getMacAddress()
    {
        return $this->mac_address;
    }

    /**
     * Set the value of mac_vendor.
     *
     * @param string $mac_vendor
     * @return \App\Entities\Base\Asset
     */
    public function setMacVendor($mac_vendor)
    {
        $this->mac_vendor = $mac_vendor;

        return $this;
    }

    /**
     * Get the value of mac_vendor.
     *
     * @return string
     */
    public function getMacVendor()
    {
        return $this->mac_vendor;
    }

    /**
     * Set the value of os_version.
     *
     * @param string $os_version
     * @return \App\Entities\Base\Asset
     */
    public function setOsVersion($os_version)
    {
        $this->os_version = $os_version;

        return $this;
    }

    /**
     * Get the value of os_version.
     *
     * @return string
     */
    public function getOsVersion()
    {
        return $this->os_version;
    }

    /**
     * Set the value of netbios.
     *
     * @param string $netbios
     * @return \App\Entities\Base\Asset
     */
    public function setNetbios($netbios)
    {
        $this->netbios = $netbios;

        return $this;
    }

    /**
     * Get the value of netbios.
     *
     * @return string
     */
    public function getNetbios()
    {
        return $this->netbios;
    }

    /**
     * Set the value of uptime.
     *
     * @param integer $uptime
     * @return \App\Entities\Base\Asset
     */
    public function setUptime($uptime)
    {
        $this->uptime = $uptime;

        return $this;
    }

    /**
     * Get the value of uptime.
     *
     * @return integer
     */
    public function getUptime()
    {
        return $this->uptime;
    }

    /**
     * Set the value of last_boot.
     *
     * @param \DateTime $last_boot
     * @return \App\Entities\Base\Asset
     */
    public function setLastBoot($last_boot)
    {
        $this->last_boot = $last_boot;

        return $this;
    }

    /**
     * Get the value of last_boot.
     *
     * @return \DateTime
     */
    public function getLastBoot()
    {
        return $this->last_boot;
    }

    /**
     * Set the value of file_id.
     *
     * @param integer $file_id
     * @return \App\Entities\Base\Asset
     */
    public function setFileId($file_id)
    {
        $this->file_id = $file_id;

        return $this;
    }

    /**
     * Get the value of file_id.
     *
     * @return integer
     */
    public function getFileId()
    {
        return $this->file_id;
    }

    /**
     * Set the value of user_id.
     *
     * @param integer $user_id
     * @return \App\Entities\Base\Asset
     */
    public function setUserId($user_id)
    {
        $this->user_id = $user_id;

        return $this;
    }

    /**
     * Get the value of user_id.
     *
     * @return integer
     */
    public function getUserId()
    {
        return $this->user_id;
    }

    /**
     * Set the value of suppressed.
     *
     * @param boolean $suppressed
     * @return \App\Entities\Base\Asset
     */
    public function setSuppressed($suppressed)
    {
        $this->suppressed = $suppressed;

        return $this;
    }

    /**
     * Get the value of suppressed.
     *
     * @return boolean
     */
    public function getSuppressed()
    {
        return $this->suppressed;
    }

    /**
     * Set the value of deleted.
     *
     * @param boolean $deleted
     * @return \App\Entities\Base\Asset
     */
    public function setDeleted($deleted)
    {
        $this->deleted = $deleted;

        return $this;
    }

    /**
     * Get the value of deleted.
     *
     * @return boolean
     */
    public function getDeleted()
    {
        return $this->deleted;
    }

    /**
     * Set the value of created_at.
     *
     * @param \DateTime $created_at
     * @return \App\Entities\Base\Asset
     */
    public function setCreatedAt($created_at)
    {
        $this->created_at = $created_at;

        return $this;
    }

    /**
     * Get the value of created_at.
     *
     * @return \DateTime
     */
    public function getCreatedAt()
    {
        return $this->created_at;
    }

    /**
     * Set the value of updated_at.
     *
     * @param \DateTime $updated_at
     * @return \App\Entities\Base\Asset
     */
    public function setUpdatedAt($updated_at)
    {
        $this->updated_at = $updated_at;

        return $this;
    }

    /**
     * Get the value of updated_at.
     *
     * @return \DateTime
     */
    public function getUpdatedAt()
    {
        return $this->updated_at;
    }

    /**
     * Add OpenPort entity to collection (one to many).
     *
     * @param \App\Entities\Base\OpenPort $openPort
     * @return \App\Entities\Base\Asset
     */
    public function addOpenPort(OpenPort $openPort)
    {
        $this->openPorts[] = $openPort;

        return $this;
    }

    /**
     * Remove OpenPort entity from collection (one to many).
     *
     * @param \App\Entities\Base\OpenPort $openPort
     * @return \App\Entities\Base\Asset
     */
    public function removeOpenPort(OpenPort $openPort)
    {
        $this->openPorts->removeElement($openPort);

        return $this;
    }

    /**
     * Get OpenPort entity collection (one to many).
     *
     * @return \Doctrine\Common\Collections\Collection
     */
    public function getOpenPorts()
    {
        return $this->openPorts;
    }

    /**
     * Set File entity (many to one).
     *
     * @param \App\Entities\Base\File $file
     * @return \App\Entities\Base\Asset
     */
    public function setFile(File $file = null)
    {
        $this->file = $file;

        return $this;
    }

    /**
     * Get File entity (many to one).
     *
     * @return \App\Entities\Base\File
     */
    public function getFile()
    {
        return $this->file;
    }

    /**
     * Set User entity (many to one).
     *
     * @param \App\Entities\Base\User $user
     * @return \App\Entities\Base\Asset
     */
    public function setUser(User $user = null)
    {
        $this->user = $user;

        return $this;
    }

    /**
     * Get User entity (many to one).
     *
     * @return \App\Entities\Base\User
     */
    public function getUser()
    {
        return $this->user;
    }

    /**
     * Get the display name for the entity
     *
     * @param bool $plural
     * @return string
     */
    public function getDisplayName(bool $plural = false): string
    {
        return $plural === false ? 'Asset' : 'Assets';
    }

    public function __sleep()
    {
        return array('id', 'name', 'cpe', 'vendor', 'ip_address_v4', 'ip_address_v6', 'hostname', 'mac_address', 'mac_vendor', 'os_version', 'netbios', 'uptime', 'last_boot', 'file_id', 'user_id', 'suppressed', 'deleted', 'created_at', 'updated_at');
    }
}


text:
package me.liamdawson.firefighter.http.resources

import me.liamdawson.firefighter.http.Request
import org.http4s.blaze.http._

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future

trait Resource {

  def handleRequest(request: Request): Future[Response] = {
    // See http://for-get.github.io/http-decision-diagram/httpdd.fsm.html for the cryptic decision codes
    // (commit 971e86822e5bdc1fa837de7cc5030abf34dbe350)

    // To make this truly async, this function needs to return a rather convoluted Future.

    // B24
    isServiceAvailable(request) flatMap { available =>
      if (!available) {
        Future.successful(HttpResponse(503))
      } else {
        // B13
        if (!allowedMethods(request).contains(request.method)) {
          Future.successful(HttpResponse(405))
        } else {
          Future.successful(HttpResponse.Ok("wat"))
        }
      }
    }
  }

  def allowedMethods(request: Request): Seq[Method] = {
    Seq("HEAD", "GET")
  }

  def isServiceAvailable(request: Request): Future[Boolean] = {
    Future.successful(true)
  }

}


text:
<!--
********************************************************************************
	Project owner:		RageQuit community
	Project name: 		GTW-RPG
	Developers:   		Mr_Moose

	Source code:		https://github.com/404rq/GTW-RPG/
	Bugtracker: 		https://discuss.404rq.com/t/issues
	Suggestions:		https://discuss.404rq.com/t/development

	Version:    		Open source
	License:    		BSD 2-Clause
	Status:     		Stable release
********************************************************************************
-->

<meta>
    <info author="GTWGames" type="script" name="GTWplayerblips" description="Display player blips and manage their visibility" version="68" />
    <script src="playerblips.lua" type="server" />
</meta>


text:
"use strict";
var __extends = (this && this.__extends) || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    function __() { this.constructor = d; }
    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
/**
 * Created by fabri_000 on 27/05/2017.
 */
var core_1 = require("@angular/core");
var http_1 = require("@angular/http");
var environment_1 = require("./environment");
var InterceptorsHttp = (function (_super) {
    __extends(InterceptorsHttp, _super);
    function InterceptorsHttp(backend, defaultOptions) {
        _super.call(this, backend, defaultOptions);
    }
    InterceptorsHttp.prototype.request = function (url, options) {
        return _super.prototype.request.call(this, url, options);
    };
    InterceptorsHttp.prototype.get = function (url, options) {
        url = this.updateUrl(url);
        return _super.prototype.get.call(this, url, this.getRequestOptionArgs(options));
    };
    InterceptorsHttp.prototype.post = function (url, body, options) {
        url = this.updateUrl(url);
        return _super.prototype.post.call(this, url, body, this.getRequestOptionArgs(options));
    };
    InterceptorsHttp.prototype.put = function (url, body, options) {
        url = this.updateUrl(url);
        return _super.prototype.put.call(this, url, body, this.getRequestOptionArgs(options));
    };
    InterceptorsHttp.prototype.delete = function (url, options) {
        url = this.updateUrl(url);
        return _super.prototype.delete.call(this, url, this.getRequestOptionArgs(options));
    };
    InterceptorsHttp.prototype.updateUrl = function (req) {
        return environment_1.environment.origin + req;
    };
    InterceptorsHttp.prototype.getRequestOptionArgs = function (options) {
        if (options == null) {
            options = new http_1.RequestOptions();
        }
        if (options.headers == null) {
            options.headers = new http_1.Headers();
        }
        var token = localStorage.getItem('id_token');
        if (token) {
            options.headers.append('Authorization', "Bearer " + token);
        }
        if (!options.headers.get('Content-type')) {
            options.headers.append('Content-Type', 'application/json');
        }
        return options;
    };
    InterceptorsHttp = __decorate([
        core_1.Injectable(),
        __metadata('design:paramtypes', [http_1.ConnectionBackend, http_1.RequestOptions])
    ], InterceptorsHttp);
    return InterceptorsHttp;
}(http_1.Http));
exports.InterceptorsHttp = InterceptorsHttp;
//# sourceMappingURL=http.interceptor.js.map


text:
from openstack import exceptions
from openstack.tests import fakes
from openstack.tests.unit import base

class TestMicroversions(base.TestCase):

    def setUp(self):
        super(TestMicroversions, self).setUp()
        self.use_compute_discovery()

    def test_get_bad_inferred_max_microversion(self):

        self.cloud.config.config['compute_api_version'] = '2.61'

        self.assertRaises(
            exceptions.ConfigException,
            self.cloud.get_server, 'doesNotExist',
        )

        self.assert_calls()

    def test_get_bad_default_max_microversion(self):

        self.cloud.config.config['compute_default_microversion'] = '2.61'

        self.assertRaises(
            exceptions.ConfigException,
            self.cloud.get_server, 'doesNotExist',
        )

        self.assert_calls()

    def test_get_bad_inferred_min_microversion(self):

        self.cloud.config.config['compute_api_version'] = '2.7'

        self.assertRaises(
            exceptions.ConfigException,
            self.cloud.get_server, 'doesNotExist',
        )

        self.assert_calls()

    def test_get_bad_default_min_microversion(self):

        self.cloud.config.config['compute_default_microversion'] = '2.7'

        self.assertRaises(
            exceptions.ConfigException,
            self.cloud.get_server, 'doesNotExist',
        )

        self.assert_calls()

    def test_inferred_default_microversion(self):

        self.cloud.config.config['compute_api_version'] = '2.42'

        server1 = fakes.make_fake_server('123', 'mickey')
        server2 = fakes.make_fake_server('345', 'mouse')

        self.register_uris([
            dict(method='GET',
                 uri=self.get_mock_url(
                     'compute', 'public', append=['servers', 'detail']),
                 request_headers={'OpenStack-API-Version': 'compute 2.42'},
                 json={'servers': [server1, server2]}),
        ])

        r = self.cloud.get_server('mickey', bare=True)
        self.assertIsNotNone(r)
        self.assertEqual(server1['name'], r['name'])

        self.assert_calls()

    def test_default_microversion(self):

        self.cloud.config.config['compute_default_microversion'] = '2.42'

        server1 = fakes.make_fake_server('123', 'mickey')
        server2 = fakes.make_fake_server('345', 'mouse')

        self.register_uris([
            dict(method='GET',
                 uri=self.get_mock_url(
                     'compute', 'public', append=['servers', 'detail']),
                 request_headers={'OpenStack-API-Version': 'compute 2.42'},
                 json={'servers': [server1, server2]}),
        ])

        r = self.cloud.get_server('mickey', bare=True)
        self.assertIsNotNone(r)
        self.assertEqual(server1['name'], r['name'])

        self.assert_calls()

    def test_conflicting_implied_and_direct(self):

        self.cloud.config.config['compute_default_microversion'] = '2.7'
        self.cloud.config.config['compute_api_version'] = '2.13'

        self.assertRaises(exceptions.ConfigException, self.cloud.get_server)

        # We should fail before we even authenticate
        self.assertEqual(0, len(self.adapter.request_history))


text:
require 'spec_helper'
module Alf
  describe "(restrict xxx, :keyword => ...)" do

    it "should support using a keyword on Relation" do
      rel = Relation(when: "now")
      rel.restrict(when: "now").should eq(rel)
    end

    it "should support using a keyword on Lispy" do
      Alf.examples.query do
        (restrict (extend suppliers, {:when => lambda{"notnow"}}), {:when => "now"})
      end.should eq(Relation::DUM)
    end

  end
end


text:
<!DOCTYPE html>

  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
  <meta name="description" content="">
  <meta name="author" content="">

  <title>The Programming club</title>

  <meta name="theme-color" content="#2C3E50">

  <link rel="shortcut icon" type="image/x-icon" href="favicon.ico">
  <link rel="shortcut icon big" sizes="192x192" href="img/profile.png ">

  <meta name="mobile-web-app-capable" content="yes">

  <link rel="shortcut icon" href="favicon.ico" />
  <link rel="icon" type="image/vnd.microsoft.icon" href="favicon.ico" />

  <link href="vendor/bootstrap/css/bootstrap.min.css" rel="stylesheet">

  <link href="vendor/font-awesome/css/font-awesome.min.css" rel="stylesheet" type="text/css">
  <link href="https://fonts.googleapis.com/css?family=Montserrat:400,700" rel="stylesheet" type="text/css">
  <link href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic,700italic" rel="stylesheet" type="text/css">

  <link href="css/main.min.css" rel="stylesheet">

      {{header}}
      <button class="navbar-toggler navbar-toggler-right" type="button" data-toggle="collapse" data-target="#navbarResponsive"
        aria-controls="navbarResponsive" aria-expanded="false" aria-label="Toggle navigation">
          Menu

        </button>

            {{item.title}}

        {{title}}
        {{subtitle}}

Projects

{{item.title}}

              See More

Weekly Challenges

              {{item.title}}

              {{item.author}}

              {{item.subtitle}}

                See More

About Us

Location

                    Meet the team

Around the Web

{{item.title}}

                  {{item.author}}

                  "{{item.subtitle}}"

                  <button class="btn btn-success" type="button" data-dismiss="modal">

                        Close</button>

{{item.title}}

                      Domain:  {{item.domain}}

                      Date:  {{item.date}}

                      GitHub:
                      Repository

                  <button class="btn btn-success" type="button" data-dismiss="modal">

                          Close</button>


text:
Spree::LineItem.class_eval do
  validates_with Spree::Stock::PosAvailabilityValidator, :if => "order.is_pos?"

  #remove the validation of Spree::Stock::Avilability and then re assign it to be for only non-pos orders
  _validators[nil].reject! { |v| v.class == Spree::Stock::AvailabilityValidator }
  _validate_callbacks.reject! { |c| c.raw_filter.class == Spree::Stock::AvailabilityValidator }

  validates_with Spree::Stock::AvailabilityValidator, :unless => "order.is_pos?"
end