###############################################################################
# Copyright (c) 2001, 2004 IBM Corporation and others.
# All rights reserved. This program and the accompanying materials
# are made available under the terms of the Eclipse Public License v1.0
# which accompanies this distribution, and is available at
# http://www.eclipse.org/legal/epl-v10.html
# 
# Contributors:
#     IBM Corporation - initial API and implementation
###############################################################################

title=UDDI

# Nodes
NODE_NAME_UDDI_MAIN=UDDI Main
NODE_NAME_QUERIES_FOLDER=Executed Queries
NODE_NAME_PUBLISHED_BUSINESSES_FOLDER=Published Businesses
NODE_NAME_PUBLISHED_SERVICES_FOLDER=Published Services
NODE_NAME_PUBLISHED_SERVICE_INTERFACES_FOLDER=Published Service Interfaces

# OpenRegistryAction
ALT_OPEN_REGISTRY=Open Registry
FORM_LABEL_OPEN_REGISTRY_DESC=Specify the name and inquiry URL of the registry to be opened. Selecting a favorite registry will automatically fill in the required information. Press <strong>Go</strong> to open the registry.
FORM_LABEL_FAVORITE_REGISTRY=Favorite Registry
FORM_LABEL_REGISTRY_NAME=Registry Name
FORM_LABEL_INQUIRY_URL=Inquiry URL
FORM_LABEL_CHECK_USER_DEFINED_CATEGORIES=Check for user-defined categories
MSG_ERROR_INVALID_REGISTRY_NAME=IWAB0136E Enter a valid registry name.
MSG_ERROR_INVALID_INQUIRY_URL=IWAB0138E Enter a valid inquiry URL.
MSG_INFO_REGISTRY_OPENED=IWAB0139I The registry named %1 located at %2 was opened successfully.
FORM_LABEL_IS_WEBSPHERE_UDDI_REGISTRY=Is WebSphere UDDI registry?
DEFAULT_REGISTRY_NAME_WEBSPHERE=IBM WebSphere Private UDDI Registry
FORM_LABEL_REGISTRY_HOST=Host
FORM_LABEL_REGISTRY_PORT=Port

# User-defined Categories
FORM_LABEL_ADD_CATEGORY_DATA=<a href="%1">Click here</a> to load this category's data.
FORM_CONTROL_TITLE_CATEGORY_FILE=Category data file name
MSG_INFO_NO_USER_DEFINED_CATEGORIES_FOUND=IWAB0371I No user defined categories detected.
MSG_INFO_NO_CATEGORY_DATA=IWAB0372I Category data for %1 is not available or is invalid.
MSG_INFO_USER_DEFINED_CATEGORY_DATA_LOADED=IWAB0373I Data for user defined category %1 was successfully loaded.
MSG_ERROR_INVALID_USER_DEFINED_CATEGORY_DATA_FILE_KEY=IWAB0374E Invalid data file for user defined category %1. A category key '%2' was found but '%3' was expected.
MSG_ERROR_INVALID_USER_DEFINED_CATEGORY_DATA_FILE_FORMAT=IWAB0473E Unknown format in line: %1 of the data file for user defined category %2. The line is: "%3"
MSG_ERROR_INVALID_USER_DEFINED_CATEGORY_DATA_FILE=IWAB0375E Invalid data file for user defined category %1.
MSG_ERROR_SAVING_CATEGORY_DATA=IWAB0474E An error occured while saving data for category %1. Exception text: %2

# UDDI Category Browser
TITLE_CATEGORY_BROWSER=Category Browser
ALT_CATEGORIES=Categories

# Details
ALT_REGISTRY_DETAILS=Registry Details
ALT_BUSINESS_DETAILS=Business Details
ALT_SERVICE_DETAILS=Service Details
ALT_SERVICE_INTERFACE_DETAILS=Service Interface Details
FORM_LABEL_DETAILS_EDITABLE=Details for <strong>%1</strong> are shown below. Some items may be added, removed, or changed. Authentication may be required for changes. Other actions are listed at the bottom of this page.

# Get
ALT_GET=Get

# Common Form Control Title
FORM_CONTROL_TITLE_NAME_TEXT_VALUE=Name value
FORM_CONTROL_TITLE_DESCRIPTION_TEXT_VALUE=Description value
FORM_CONTROL_TITLE_CATEGORY_KEY_NAME=Category key name
FORM_CONTROL_TITLE_CATEGORY_KEY_VALUE=Category key value
FORM_CONTROL_TITLE_IDENTIFIER_KEY_NAME=Identifier key name
FORM_CONTROL_TITLE_IDENTIFIER_KEY_VALUE=Identifier key value
FORM_CONTROL_TITLE_DISCOVERY_URL=Discovery URL

# Find actions
ALT_FIND=Find
ALT_SUBQUERY=Find %1 Subquery
FORM_LABEL_QUERY_NAME=Name of this query
DEFAULT_QUERY_NAME=query results
DEFAULT_SUBQUERY_NAME=%1 - %2 subquery
FORM_LABEL_SEARCH_FOR=Search for
FORM_OPTION_BUSINESSES=Businesses
FORM_OPTION_SERVICES=Services
FORM_OPTION_SERVICE_INTERFACES=Service Interfaces
FORM_LABEL_SEARCH_TYPE=Type of search
FORM_RADIO_SIMPLE=Simple
FORM_RADIO_ADVANCED=Advanced
FORM_RADIO_UUID=UUID
FORM_LABEL_FIND_BUSINESSES_SIMPLE_DESC=Enter the partial or complete name of a business to search for. The '%' symbol can be used as a wildcard that matches any character. Press <strong>Go</strong> to execute the search.
FORM_LABEL_FIND_ADVANCED_DESC=Enter values for one or more of the parameters listed below. The '%' symbol can be used as a wildcard that matches any character in the Name field of the Names table. Authentication may be required. Press <strong>Go</strong> to execute the search.
FORM_LABEL_FIND_BUSINESS_UUID_DESC=Enter the UUID of the business to search for. Press <strong>Go</strong> to execute the search.
FORM_LABEL_NAMES=Names
FORM_LINK_ADD=Add
FORM_LINK_GET=Get
FORM_LINK_FIND=Find
FORM_LINK_REMOVE=Remove
FORM_LABEL_OWNED=Owned
FORM_LABEL_PUBLISH_URL=Publish URL
FORM_LABEL_USERID=User ID
FORM_LABEL_PASSWORD=Password
FORM_LABEL_LANGUAGE=Language
FORM_LABEL_NAME=Name
FORM_LABEL_DESCRIPTION=Description
FORM_OPTION_LANGUAGE_EN=English
FORM_OPTION_LANGUAGE_AA=Afar
FORM_OPTION_LANGUAGE_AB=Abkhazian
FORM_OPTION_LANGUAGE_AF=Afrikaans
FORM_OPTION_LANGUAGE_AM=Amharic
FORM_OPTION_LANGUAGE_AR=Arabic
FORM_OPTION_LANGUAGE_AS=Assamese
FORM_OPTION_LANGUAGE_AY=Aymara
FORM_OPTION_LANGUAGE_AZ=Azerbaijani
FORM_OPTION_LANGUAGE_BA=Bashkir
FORM_OPTION_LANGUAGE_BE=Byelorussian
FORM_OPTION_LANGUAGE_BG=Bulgarian
FORM_OPTION_LANGUAGE_BH=Bihari
FORM_OPTION_LANGUAGE_BI=Bislama
FORM_OPTION_LANGUAGE_BN=Bengali; Bangla
FORM_OPTION_LANGUAGE_BO=Tibetan
FORM_OPTION_LANGUAGE_BR=Breton
FORM_OPTION_LANGUAGE_CA=Catalan
FORM_OPTION_LANGUAGE_CO=Corsican
FORM_OPTION_LANGUAGE_CZ=Czech
FORM_OPTION_LANGUAGE_CY=Welsh
FORM_OPTION_LANGUAGE_DA=Danish
FORM_OPTION_LANGUAGE_DE=German
FORM_OPTION_LANGUAGE_DZ=Bhutani
FORM_OPTION_LANGUAGE_EL=Greek
FORM_OPTION_LANGUAGE_EO=Esperanto
FORM_OPTION_LANGUAGE_ES=Spanish
FORM_OPTION_LANGUAGE_ET=Estonian
FORM_OPTION_LANGUAGE_EU=Basque
FORM_OPTION_LANGUAGE_FA=Persian
FORM_OPTION_LANGUAGE_FI=Finnish
FORM_OPTION_LANGUAGE_FJ=Fiji
FORM_OPTION_LANGUAGE_FO=Faeroese
FORM_OPTION_LANGUAGE_FR=French
FORM_OPTION_LANGUAGE_FY=Frisian
FORM_OPTION_LANGUAGE_GA=Irish
FORM_OPTION_LANGUAGE_GD=Scots Gaelic
FORM_OPTION_LANGUAGE_GL=Galician
FORM_OPTION_LANGUAGE_GN=Guarani
FORM_OPTION_LANGUAGE_GU=Gujarati
FORM_OPTION_LANGUAGE_HA=Hausa
FORM_OPTION_LANGUAGE_HI=Hindi
FORM_OPTION_LANGUAGE_HR=Croatian
FORM_OPTION_LANGUAGE_HU=Hungarian
FORM_OPTION_LANGUAGE_HY=Armenian
FORM_OPTION_LANGUAGE_IA=Interlingua
FORM_OPTION_LANGUAGE_IE=Interlingue
FORM_OPTION_LANGUAGE_IK=Inupiak
FORM_OPTION_LANGUAGE_IN=Indonesian
FORM_OPTION_LANGUAGE_IS=Icelandic
FORM_OPTION_LANGUAGE_IT=Italian
FORM_OPTION_LANGUAGE_IW=Hebrew
FORM_OPTION_LANGUAGE_JA=Japanese
FORM_OPTION_LANGUAGE_JI=Yiddish
FORM_OPTION_LANGUAGE_JW=Javanese
FORM_OPTION_LANGUAGE_KA=Georgian
FORM_OPTION_LANGUAGE_KK=Kazakh
FORM_OPTION_LANGUAGE_KL=Greenlandic
FORM_OPTION_LANGUAGE_KM=Cambodian
FORM_OPTION_LANGUAGE_KN=Kannada
FORM_OPTION_LANGUAGE_KO=Korean
FORM_OPTION_LANGUAGE_KS=Kashmiri
FORM_OPTION_LANGUAGE_KU=Kurdish
FORM_OPTION_LANGUAGE_KY=Kirghiz
FORM_OPTION_LANGUAGE_LA=Latin
FORM_OPTION_LANGUAGE_LN=Lingala
FORM_OPTION_LANGUAGE_LO=Laothian
FORM_OPTION_LANGUAGE_LT=Lithuanian
FORM_OPTION_LANGUAGE_LV=Latvian, Lettish
FORM_OPTION_LANGUAGE_MG=Malagasy
FORM_OPTION_LANGUAGE_MI=Maori
FORM_OPTION_LANGUAGE_MK=Macedonian
FORM_OPTION_LANGUAGE_ML=Malayalam
FORM_OPTION_LANGUAGE_MN=Mongolian
FORM_OPTION_LANGUAGE_MO=Moldavian
FORM_OPTION_LANGUAGE_MR=Marathi
FORM_OPTION_LANGUAGE_MS=Malay
FORM_OPTION_LANGUAGE_MT=Maltese
FORM_OPTION_LANGUAGE_MY=Burmese
FORM_OPTION_LANGUAGE_NA=Nauru
FORM_OPTION_LANGUAGE_NE=Nepali
FORM_OPTION_LANGUAGE_NL=Dutch
FORM_OPTION_LANGUAGE_NO=Norwegian
FORM_OPTION_LANGUAGE_OC=Occitan
FORM_OPTION_LANGUAGE_OM=(Afan) Oromo
FORM_OPTION_LANGUAGE_OR=Oriya
FORM_OPTION_LANGUAGE_PA=Punjabi
FORM_OPTION_LANGUAGE_PL=Polish
FORM_OPTION_LANGUAGE_PS=Pashto, Pushto
FORM_OPTION_LANGUAGE_PT=Portuguese
FORM_OPTION_LANGUAGE_QU=Quechua
FORM_OPTION_LANGUAGE_RM=Rhaeto-Romance
FORM_OPTION_LANGUAGE_RN=Kirundi
FORM_OPTION_LANGUAGE_RO=Romanian
FORM_OPTION_LANGUAGE_RU=Russian
FORM_OPTION_LANGUAGE_RW=Kinyarwanda
FORM_OPTION_LANGUAGE_SA=Sanskrit
FORM_OPTION_LANGUAGE_SD=Sindhi
FORM_OPTION_LANGUAGE_SG=Sangro
FORM_OPTION_LANGUAGE_SH=Serbo-Croatian
FORM_OPTION_LANGUAGE_SI=Singhalese
FORM_OPTION_LANGUAGE_SK=Slovak
FORM_OPTION_LANGUAGE_SL=Slovenian
FORM_OPTION_LANGUAGE_SM=Samoan
FORM_OPTION_LANGUAGE_SN=Shona
FORM_OPTION_LANGUAGE_SO=Somali
FORM_OPTION_LANGUAGE_SQ=Albanian
FORM_OPTION_LANGUAGE_SR=Serbian
FORM_OPTION_LANGUAGE_SS=Siswati
FORM_OPTION_LANGUAGE_ST=Sesotho
FORM_OPTION_LANGUAGE_SU=Sundanese
FORM_OPTION_LANGUAGE_SV=Swedish
FORM_OPTION_LANGUAGE_SW=Swahili
FORM_OPTION_LANGUAGE_TA=Tamil
FORM_OPTION_LANGUAGE_TE=Tegulu
FORM_OPTION_LANGUAGE_TG=Tajik
FORM_OPTION_LANGUAGE_TH=Thai
FORM_OPTION_LANGUAGE_TI=Tigrinya
FORM_OPTION_LANGUAGE_TK=Turkmen
FORM_OPTION_LANGUAGE_TL=Tagalog
FORM_OPTION_LANGUAGE_TN=Setswana
FORM_OPTION_LANGUAGE_TO=Tonga
FORM_OPTION_LANGUAGE_TR=Turkish
FORM_OPTION_LANGUAGE_TS=Tsonga
FORM_OPTION_LANGUAGE_TT=Tatar
FORM_OPTION_LANGUAGE_TW=Twi
FORM_OPTION_LANGUAGE_UK=Ukrainian
FORM_OPTION_LANGUAGE_UR=Urdu
FORM_OPTION_LANGUAGE_UZ=Uzbek
FORM_OPTION_LANGUAGE_VI=Vietnamese
FORM_OPTION_LANGUAGE_VO=Volapuk
FORM_OPTION_LANGUAGE_WO=Wolof
FORM_OPTION_LANGUAGE_XH=Xhosa
FORM_OPTION_LANGUAGE_YO=Yoruba
FORM_OPTION_LANGUAGE_ZH=Chinese
FORM_OPTION_LANGUAGE_ZU=Zulu
FORM_LABEL_EXACT_NAME_MATCH=Exact match
FORM_LABEL_CASE_SENSITIVE_MATCH=Case sensitive
FORM_LABEL_SOUNDEX=Sound alike
FORM_LABEL_IDENTIFIERS=Identifiers
FORM_LABEL_IDENTIFIER_TYPE=Type

# Do not translate the two items below.
FORM_OPTION_IDENTIFIER_DUNS=D-U-N-S
FORM_OPTION_IDENTIFIER_THOMAS_REGISTRY=Thomas Registry

FORM_LABEL_KEY_NAME=Key name
FORM_LABEL_KEY_VALUE=Key value
FORM_LABEL_CATEGORIES=Categories
FORM_LABEL_CATEGORY_TYPE=Type
FORM_OPTION_CATEGORY_NAICS=NAICS
FORM_OPTION_CATEGORY_UNSPSC_73=UNSPSC 7.3
FORM_OPTION_CATEGORY_GEO=GEO
FORM_LABEL_BUSINESS_CATEGORIES=Compare with:
FORM_OPTION_BUSINESSES_ONLY=Businesses only
FORM_OPTION_SERVICES_ONLY=Services only
FORM_OPTION_BOTH=Businesses and Services
FORM_LABEL_DISCOVERYURLS=Discovery URLs
FORM_LABEL_DISCOVERYURL=Discovery URL
FORM_LABEL_FINDQUALIFIERS=Find Qualifiers
FORM_LABEL_COMBINE_KEYS=Combine keys:
FORM_OPTION_ANDALLKEYS=And
FORM_OPTION_ORALLKEYS=Or
FORM_OPTION_ORLIKEKEYS=Or Like
FORM_LABEL_SORT_BY_NAME=Sort by name:
FORM_RADIO_SORT_ASC=Ascending
FORM_RADIO_SORT_DESC=Descending
FORM_LABEL_SORT_BY_DATE=Sort by date:
FORM_LABEL_MAX_SEARCH_SET=Maximum size of search set:
FORM_LABEL_MAX_RESULTS=Maximum number of results:
FORM_LABEL_FIND_SERVICES_SIMPLE_DESC=Enter the partial or complete name of a service to search for. The '%' symbol can be used as a wildcard that matches any character. Press <strong>Go</strong> to execute the search.
FORM_LABEL_FIND_SERVICE_UUID_DESC=Enter the UUID of the service to search for. Press <strong>Go</strong> to execute the search.
FORM_LABEL_FIND_SERVICE_INTERFACES_SIMPLE_DESC=Enter the partial or complete name of a service interface to search for. The '%' symbol can be used as a wildcard that matches any character. Press <strong>Go</strong> to execute the search.
FORM_LABEL_FIND_SERVICE_INTERFACE_UUID_DESC=Enter the UUID of the service interface to search for. Press <strong>Go</strong> to execute the search.
FORM_LABEL_SERVICE_INTERFACES=Service Interfaces
FORM_LABEL_UUID_KEY=UUID Key:
FORM_LABEL_USE_SERVICE=Use service
FORM_LABEL_SERVICE=Service
FORM_LABEL_BUSINESS=Business
FORM_LABEL_PUBLISH_ASSERTIONS=Publisher Assertions
FORM_LABEL_DIRECTION=Direction
FORM_LABEL_FROM_KEY=From Key
FORM_LABEL_TO_KEY=To Key
FORM_LABEL_STATUS=Status
FORM_LABEL_ASSERTION_TYPE=Assertion Type
FORM_OPTION_ASSERTION_TYPE_PARENT_CHILD=Parent-Child
FORM_OPTION_ASSERTION_TYPE_PEER_TO_PEER=Peer-Peer
FORM_OPTION_ASSERTION_TYPE_IDENTITY=Identity
FORM_LABEL_ASSERTION_DIRETION_DESC=Direction <strong>From</strong> will create a publisher assertion from this business to the businesses above.  Direction <strong>To</strong> will create a publisher assertion from the above businesses to this business.
FORM_OPTION_ASSERTION_DIRECTION_FROM=--->
FORM_OPTION_ASSERTION_DIRECTION_TO=<---
FORM_LABEL_THIS_BUSINESS=This
MSG_ERROR_INVALID_QUERY_NAME=IWAB0140E Enter a valid name for the query.
MSG_ERROR_INVALID_NAMES=IWAB0141E Enter a series of valid names.
MSG_ERROR_INVALID_PUBLISH_URL=IWAB0142E Enter a valid publish URL.
MSG_ERROR_INVALID_USERID=IWAB0143E Enter a valid user ID.
MSG_ERROR_INVALID_MAX_SEARCH_SET=IWAB0145E Enter a valid size for the maximum search set.
MSG_ERROR_INVALID_MAX_RESULTS=IWAB0146E Enter a valid size for the maximum number of results.
MSG_INFO_BUSINESSES_FOUND=IWAB0147I Number of businesses found: %1
MSG_ERROR_NO_BUSINESSES_FOUND=IWAB0148E No businesses found.
MSG_INFO_SERVICES_FOUND=IWAB0149I Number of services found: %1
MSG_ERROR_NO_SERVICES_FOUND=IWAB0150E No services found.
MSG_ERROR_SINGLE_ITEM=IWAB0151E Select just one item.
MSG_QUESTION_ITEM_REPLACEMENT=The selection will replace an item already in the target. Do you wish to proceed?
MSG_INFO_SERVICE_INTERFACES_FOUND=IWAB0152I Number of service interfaces found: %1
MSG_ERROR_NO_SERVICE_INTERFACES_FOUND=IWAB0153E No service interfaces found.
MSG_ERROR_NOTHING_SELECTED=IWAB0154E Select at least one item.
MSG_ERROR_INVALID_UUID_KEY=IWAB0155E Enter a valid UUID key.
MSG_ERROR_QUERY_NAME_CONFLICT=IWAB0156E The subquery's query name cannot be the same as the originator.
MSG_ERROR_NO_ITEMS_TO_GET=IWAB0157E No items of the specified type have been published or discovered yet.
MSG_INFO_NO_BUSINESSES_OR_SERVICE_INTERFACES_FOUND=IWAB0162I No Businesses, Services or Service Interfaces found.

# Results
ALT_QUERY_RESULTS=Query Results
FORM_LABEL_SUBQUERY=The results may be used as inputs of another operation. Click the <strong>target</strong> link at the top to see the operation. Selected results can be used in the operation by clicking the <strong>Transfer</strong> button.
FORM_LABEL_QUERY=Select a result to see more details or select a set of results and click a button to perform an operation.
FORM_LINK_TARGET=target
FORM_BUTTON_TRANSFER=Transfer
FORM_BUTTON_REFRESH=Refresh
FORM_BUTTON_ADD_TO_FAVORITES=Add to favorites
FORM_BUTTON_UNPUBLISH=Unpublish
FORM_BUTTON_CLEAR=Clear

# Publish actions
ALT_PUBLISH=Publish
FORM_LABEL_PUBLISH=Publish:
FORM_OPTION_BUSINESS=Business
FORM_OPTION_SERVICE=Service
FORM_OPTION_SERVICE_INTERFACE=Service Interface
FORM_LABEL_PUBLISH_BUSINESS_SIMPLE_DESC=Enter a name and an optional description for the business to be published. Authentication may be required.
FORM_LABEL_PUBLISH_BUSINESS_ADVANCED_DESC=Provide a name for the business to be published. Other parameters may also be specified. Authentication may be required.
FORM_LABEL_PUBLISH_SERVICE_SIMPLE_DESC=Get or find a business and then provide the WSDL URL, name and an optional description for the service to be published. Authentication may be required.
FORM_LABEL_PUBLISH_SERVICE_ADVANCED_DESC=Get or find a business and then provide the WSDL URL and a name for the service to be published. Other parameters may also be specified. Authentication may be required.
FORM_LABEL_BUSINESS_PUBLISH_SERVICE_SIMPLE_DESC=Provide the WSDL URL, name and an optional description for the service to be published. Authentication may be required.
FORM_LABEL_BUSINESS_PUBLISH_SERVICE_ADVANCED_DESC=Provide the WSDL URL and a name for the service to be published. Other parameters may also be specified. Authentication may be required.
FORM_LABEL_PUBLISH_SERVICE_INTERFACE_SIMPLE_DESC=Enter a WSDL URL, name and an optional description for the service interface to be published. Authentication may be required.
FORM_LABEL_PUBLISH_SERVICE_INTERFACE_ADVANCED_DESC=Provide the WSDL URL and name for the service interface to be published. Other parameters may also be specified. Authentication may be required.
FORM_LABEL_PUBLISH_FORM=Publication format
FORM_LABEL_DESCRIPTION=Description
FORM_LABEL_DESCRIPTIONS=Descriptions
MSG_INFO_BUSINESS_PUBLISHED=IWAB0158I Business %1 was successfully published.
MSG_INFO_SERVICE_PUBLISHED=IWAB0159I Service %1 was successfully published.
MSG_INFO_SERVICE_INTERFACE_PUBLISHED=IWAB0160I Service interface %1 was successfully published.
MSG_ERROR_INVALID_NAME=IWAB0161E Enter a valid name.
MSG_ERROR_ROW_BLANK_LANGUAGE=IWAB0250E Select a non-blank language for the %1 in row %2. Only the first row can have a blank language.
MSG_ERROR_ROW_DUPLICATE_LANGUAGE=IWAB0251E Change the language for the %1 in row %2. The current one is already in use.
MSG_ERROR_ROW_INVALID_TEXT=IWAB0252E Enter a valid %1 in row %2
MSG_ERROR_INVALID_WSDL_URL=IWAB0253E Enter a valid WSDL URL.
MSG_ERROR_NO_NAMES=IWAB0254E Add at least one name.
MSG_ERROR_INVALID_SERVICE=IWAB0255E Provide a valid service.
MSG_ERROR_INVALID_BUSINESS=IWAB0256E Provide a valid business.

# Business Publish Service action
ALT_PUBLISH_SERVICE=Publish Service

# Login actions
ALT_LOGIN=Login
ALT_LOGOUT=Logout
MSG_INFO_NO_MULTIPLE_LOGIN=Multiple logins with same ID not allowed
MSG_INFO_LOGGED_IN_NODE=%1 - logged in as %2

# WSDL Browser
TITLE_WSDL_BROWSER=WSDL Browser - %1
FORM_LABEL_WSDL_SOURCE=Select a WSDL source:
FORM_LABEL_WSDL_SOURCE_WEBPROJECTS=Web Projects
FORM_LABEL_WSDL_SOURCE_FAVORITES=Favorites
FORM_LABEL_WEB_PROJECT=Web Project
FORM_LABEL_WSDL_URL=WSDL URL
ALT_WSDL_BROWSER=WSDL Browser

# Details
FORM_LINK_EDIT=Edit
FORM_LINK_CANCEL=Cancel
FORM_LABEL_BUSINESS_KEY=Business Key
FORM_LABEL_SERVICE_KEY=Service Key
FORM_LABEL_SERVICE_INTERFACE_KEY=TModel Key
FORM_LABEL_USER_DEFINED_CATEGORIES=User Defined Categories
FORM_LABEL_CHECKED=Checked
FORM_LABEL_FILE=File
MSG_QUESTION_PUBLISH_ITEM=The item could not be found in the registry. Do you wish to publish it?
MSG_QUESTION_SERVICE_PUBLISH_BUSINESS=The service and its business could not be found in the registry. Proceed to publish?
MSG_INFO_BUSINESS_UPDATED=IWAB0257I Business %1 was successfully updated.
MSG_INFO_SERVICE_UPDATED=IWAB0258I Service %1 was successfully updated.
MSG_INFO_SERVICE_INTERFACE_UPDATED=IWAB0259I Service Interface %1 was successfully updated.
MSG_INFO_REGISTRY_UPDATED=IWAB0323I Registry %1 was successfully updated.

# UnpublishAction
ALT_UNPUBLISH_BUSINESS=Unpublish Business
ALT_UNPUBLISH_SERVICE=Unpublish Service
ALT_UNPUBLISH_SERVICE_INTERFACE=Unpublish Service Interface
FORM_LABEL_UNPUBLISH_DESC=Press <strong>Go</strong> to unpublish this object. Authentication may be required.
MSG_INFO_BUSINESS_UNPUBLISHED=IWAB0260I Business %1 was successfully unpublished.
MSG_INFO_SERVICE_UNPUBLISHED=IWAB0261I Service %1 was successfully unpublished.
MSG_INFO_SERVICE_INTERFACE_UNPUBLISHED=IWAB0262I Service Interface %1 was successfully unpublished.

# Add to WSDL Perspective
ALT_ADD_TO_WSDL_PERSPECTIVE=Add To WSDL Page
MSG_INFO_WSDL_ADDED_TO_WSDL_PERSPECTIVE=IWAB0376I %1 was successfully added to WSDL page.
MSG_ERROR_WSDL_NOT_ADDED_TO_WSDL_PERSPECTIVE=IWAB0377E %1 could not be added to WSDL page.

# Add to Favorites
ALT_ADD_TO_FAVORITES=Add To Favorites
MSG_INFO_FAVORITE_ADDED=IWAB0263I %1 was successfully added to favorites.
MSG_ERROR_FAVORITE_NOT_ADDED=IWAB0264E %1 could not be added to favorites.
MSG_ERROR_FAVORITE_ALREADY_EXISTS=IWAB0324E %1 already exists in favorties.
MSG_QUESTION_OVERWRITE_FAVORITES=Favorite already exists.  Do you wish to overwrite?

# Refresh
MSG_INFO_NODE_REFRESHED=IWAB0265I %1 refreshed.
MSG_QUESTION_REMOVE_NODE=%1 could not be found in the registry. Do you wish to clear it?

# ManageReferencedServices
ALT_MANAGE_REFERENCED_SERVICES=Manage Referenced Services
FORM_LABEL_MANAGE_REFERENCED_SERVICES_DESC=Add discovered or published services to the list of referenced services by clicking the <strong>Add Services</strong> button. Remove selected references by clicking the <strong>Remove References</strong> button. Authentication may be required for changes.
FORM_LABEL_REFERENCED_SERVICES=Referenced Services
FORM_BUTTON_ADD_SERVICES=Add Services
FORM_BUTTON_REMOVE_REFERENCES=Remove References
MSG_ERROR_NO_REFERENCE_SELECTED=IWAB0266E Select at least one referenced service before proceeding.
MSG_ERROR_NO_SERVICES=IWAB0267E Get or find at least one service before proceeding.
MSG_ERROR_SERVICE_NOT_REFERENCED=IWAB0268E Service %1 could not be referenced.
MSG_ERROR_REFERENCE_NOT_REMOVED=IWAB0269E Service reference %1 could not be removed.
MSG_INFO_SERVICE_REFERENCED=IWAB0270I Service %1 was successfully referenced.
MSG_INFO_SERVICE_REFERENCE_REMOVED=IWAB0271I Service reference %1 was successfully removed.

# ManagePublisherAssertions
ALT_MANAGE_PUBLISHER_ASSERTIONS=Manage Publisher Assertions
FORM_LABEL_MANAGE_PUBLISHER_ASSERTIONS_DESC=Add discovered or published businesses to the list of publisher assertions by clicking <strong>Add Assertions</strong>. Remove selected assertions by clicking <strong>Remove Assertions</strong>. Complete selected assertions by clicking <strong>Complete Assertions</strong>. Click <strong>Refresh Assertions</strong> to refresh the list of assertions.
FORM_LABEL_INCOMPLETE_ASSERTIONS_VISIBILITY_DESC=Please note that incomplete publisher assertions are visible only to the owner of the business.
FORM_LABEL_BUSINESSES=Businesses
FORM_BUTTON_SHOW_ALL_PUBLISHER_ASSERTIONS=Refresh Assertions
FORM_BUTTON_COMPLETE_PUBLISHER_ASSERTIONS=Complete Assertions
FORM_BUTTON_ADD_PUBLISHER_ASSERTIONS=Add Assertions
FORM_BUTTON_REMOVE_PUBLISHER_ASSERTIONS=Remove Assertions
MSG_INFO_PUBLISHER_ASSERTIONS_REFRESHED=IWAB0325I Publisher Assertions are refreshed.
MSG_ERROR_NO_INCOMPLETE_ASSERTION_SELECTED=IWAB0326E Select at least one incomplete publisher assertion.
MSG_ERROR_NOT_OWNED_BUSINESS=IWAB0327E This operation cannot be performed on a business owned by another party.

# GetBusinesses
ALT_GET_BUSINESS=Get Business
ALT_GET_BUSINESSES=Get Businesses
NODE_NAME_SERVICE_BUSINESS=Business for service %1
NODE_NAME_SI_BUSINESSES=Businesses for service interface %1
MSG_QUESTION_REMOVE_SERVICE_NODE=The service could not be found in the registry. Do you wish to remove this node?

# GetServiceInterfaces
ALT_GET_SERVICE_INTERFACES=Get Service Interfaces
NODE_NAME_SERVICE_SERVICE_INTERFACES=Service interfaces for service %1
MSG_QUESTION_GET_SI_REMOVE_SERVICE_NODE=The service could not be found in the registry. Do you wish to remove this node?

# GetServices
ALT_GET_SERVICES=Get Services
NODE_NAME_SI_SERVICES=Services for service interface %1
NODE_NAME_BUSINESS_SERVICES=Services for business %1
MSG_QUESTION_REMOVE_SI_NODE=The service interface could not be found in the registry. Do you wish to remove this node?
MSG_QUESTION_REMOVE_BUSINESS_NODE=The business could not be found in the registry. Do you wish to remove this node?

# RefreshUDDINodesAction
MSG_ERROR_NODE_DATA_VALIDATION_FAILED=IWAB0272E %1 could not be found in the registry.

# Summaries
ALT_SUMMARY_QUERIES=Summary of Queries
ALT_SUMMARY_BUSINESSES=Summary of Businesses
ALT_SUMMARY_SERVICES=Summary of Services
ALT_SUMMARY_SERVICE_INTERFACES=Summary of Service Interfaces
FORM_LABEL_QUERIES=Queries

# SelectSubQueryItemAction
MSG_QUESTION_ITEM_VALIDATION_FAILED=%1 could not be found in the registry. Do you wish to remove it?

# Frame titles
FRAME_TITLE_NAVIGATOR_CONTAINER=Navigator Container
FRAME_TITLE_NAVIGATOR_TOOLBAR=Navigator Toolbar
FRAME_TITLE_NAVIGATOR_CONTENT=Navigator Content
FRAME_TITLE_ACTIONS_CONTAINER=Actions Container
FRAME_TITLE_PROPERTIES_CONTAINER=Properties Container
FRAME_TITLE_PROPERTIES_TOOLBAR=Properties Toolbar
FRAME_TITLE_PROPERTIES_CONTENT=Properties Content
FRAME_TITLE_STATUS_CONTAINER=Status Container
FRAME_TITLE_STATUS_TOOLBAR=Status Toolbar
FRAME_TITLE_STATUS_CONTENT=Status Content
FRAME_TITLE_UDDI_PERSPECTIVE_CONTENT=UDDI Page Content
FRAME_TITLE_CATEGORIES_WORKAREA=Categories Work Area
FRAME_TITLE_CATEGORIES_TOOLBAR=Categories Toolbar
FRAME_TITLE_CATEGORIES_CONTENT=Categories Content
FRAME_TITLE_WSDL_TOOLBAR=WSDL Browser Toolbar
FRAME_TITLE_WSDL_CONTENT=WSDL Browser Content

# Form titles
FORM_TITLE_BUSINESS_DETAILS=Business Details Form
FORM_TITLE_BUSINESS_PUBLISH_SERVICE=Business Publish Service Form
FORM_TITLE_GET_FORM=Select from Discovered and Published Objects Form
FORM_TITLE_ITEMS_SUMMARY=Summary of Items Form
FORM_TITLE_MANAGE_PUBLISHER_ASSERTIONS=Manage Publisher Assertions Form
FORM_TITLE_MANAGE_REFERENCED_SERVICES=Manage Referenced Services Form
FORM_TITLE_OPEN_REGISTRY=Open Registry Form
FORM_TITLE_REGISTRY_DETAILS=Registry Details Form
FORM_TITLE_REGISTRY_PUBLISH=Registry Publish Form
FORM_TITLE_REGISTRY_FIND=Registry Find Form
FORM_TITLE_RESULTS=Results Form
FORM_TITLE_SERVICE_DETAILS=Service Details Form
FORM_TITLE_SERVICE_INTERFACE_DETAILS=Service Interface Details Form
FORM_TITLE_UNPUBLISH=Unpublish Form
