###############################################################################
# Copyright (c) 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
###############################################################################

#
# Messages in plugin.xml.
#

PLUGIN_NEW_WIZARD_NAME_WS_CLIENT=Web Service Client
#
# Web services "Internet" preferences extension.
#

#
# Web Samples IDs
#

#
# Pop-up actions
#
ACTION_GENERATE_JAVA_PROXY=Generate Client

#
# Dialogs
#
CHECKBOX_SHOW_GENERATE_JAVA_PROXY_DIALOG=Show Generate Java bean Proxy Dialog
TOOLTIP_PPAD_CHECKBOX_WSDL2PROXY=Show the dialog for generating the Java bean proxy action.

#
#       Web Services Preferance Pages
#
# Categories
#

#
# Preferences Tooltips
#

#
#Server Runtime Preferences
#
TOOLTIP_SRPF_COMBO_SERVER=The preferred server type
TOOLTIP_SRPF_COMBO_RUNTIME=The preferred Web service runtime
TOOLTIP_SRPF_COMBO_J2EE=The preferred J2EE version

#
# Pop-up actions
#

#
# General messages.
#
MSG_ERROR_TASK_EXCEPTED=IWAB0234E An internal error occurred. Details: {0}
MSG_ERROR_NO_SERVER_RUNTIME=No suitable server can be found for the {0} Web service runtime. Go to Window > Preferences. Select Server > Installed Runtimes and configure one of the following: {1}




#
#Runtime labels
#


#
# Wizard page task labels and descriptions
# (used only for progress indication).
#

#
# Common wizard strings.
#
LABEL_FOLDER_NAME=Folder:
LABEL_JSP_FOLDER_NAME=JSP folder:
LABEL_WEB_PROJECT_NAME=Web project:
LABEL_WEBSERVICETYPE=Web service type:
LABEL_J2EE_VERSION=J2EE version:
LABEL_NA=N/A

BUTTON_BROWSE=Browse...
BUTTON_BROWSE_FILES=Browse files...
BUTTON_USE_ABSOLUTE_LOCATION=Use absolute location URI for WSDL input statements
BUTTON_USE_INLINE_SCHEMA=Use inline schema

BOTTOMUP_LABEL=Bottom up
TOPDOWN_LABEL=Top down
CLIENT_LABEL=Client
COMBINED_TYPE_AND_RUNTIME_LABEL={0} {1}



#
# Wizards.
#
WIZARD_TITLE_WSC=Web Service Client

#
# WebServiceClientSelectionPage
#

#
# WebServiceServerSelectionPage
#

#
# WebServiceProjectPage
#
PAGE_TITLE_WS_PROJECT=Web Services
PAGE_DESC_WS_PROJECT=Review your Web service options and make any necessary changes before proceeding to the next page.
BUTTON_START_WEB_PROJECT=Start Web service in Web project
GROUP_SCENARIO_SERVICE=Service
GROUP_SCENARIO_CLIENT=Client proxy
LABEL_WEBSERVICECLIENTTYPE=Client proxy type:



# Items common to WebServiceRuntimeSelectionPage and WebServiceClientRuntimeSelectionPage
# WebServiceRuntimeSelectionPage
PAGE_TITLE_WS_RUNTIME_SELECTION=Service Deployment Configuration
PAGE_DESC_WS_RUNTIME_SELECTION=Choose from the list of runtimes and deployment servers, or use the default settings.
LABEL_RUNTIMES_LIST=Web service runtime:
LABEL_SERVERS_LIST=Server:
LABEL_EDIT_BUTTON=Edit...
LABEL_SERVICE_EAR_MODULE=Service EAR module:
LABEL_CLIENT_EAR_MODULE=Client EAR module:
LABEL_CLIENT_MODULE=Client module:
LABEL_SERVICE_MODULE=Service module:
LABEL_CLIENT_PROJECT=Client project:
LABEL_SERVICE_PROJECT=Service project:
LABEL_CLIENT_EAR_PROJECT=Client EAR project:
LABEL_SERVICE_EAR_PROJECT=Service EAR project:

#
# Client component type labels
#
LABEL_CLIENT_COMP_TYPE_WEB=Web
LABEL_CLIENT_COMP_TYPE_EJB=EJB
LABEL_CLIENT_COMP_TYPE_APP_CLIENT=Application Client
LABEL_CLIENT_COMP_TYPE_CONTAINERLESS=Java


TOOLTIP_PWRS_TEXT_RUNTIME=The runtime to be used.
TOOLTIP_PWRS_TEXT_SERVER=The server to be used.
TOOLTIP_PWRS_J2EE_VERSION=J2EE version to be used.

LABEL_SELECTION_VIEW_TITLE=Server-Side Deployment Selection:
LABEL_SELECTION_VIEW_RUNTIME=Choose Web service runtime first
LABEL_SELECTION_VIEW_SERVER=Choose server first
LABEL_SELECTION_VIEW_EXPLORE=Explore options

LABEL_TREE_EXISTING_SERVERS=Existing Servers
LABEL_TREE_SERVER_TYPES=Server Types

MSG_INVALID_SRT_SELECTIONS=This server and runtime combination is not supported.  Choose a different server or runtime to proceed through the Web services wizard.
MSG_NO_RUNTIME=No runtime specified for the {0} scenario.
MSG_NO_SERVER=No server specified for the {0} scenario.
MSG_ERROR_STUB_ONLY={0} has only stub runtimes associated with it. Choose a different server or configure a non-stub runtime in the server preferences.

MSG_SERVER_TARGET_MISMATCH=The project, {0}, has a server target which is not compatible with the selected server type
MSG_J2EE_MISMATCH=The project, {0}, has a different J2EE level from the selected J2EE level
MSG_SERVICE_PROJECT_EMPTY=The service project {0} cannot be empty. Select a service project {0}.
MSG_SERVICE_EAR_EMPTY=The service EAR {0} cannot be empty. Select a service EAR {0}.
MSG_CLIENT_PROJECT_EMPTY=The client project {0} cannot be empty. Select a client project {0}.
MSG_CLIENT_EAR_EMPTY=The client EAR {0} cannot be empty. Select a client EAR {0}.
MSG_INVALID_EJB_PROJECT={0} is not an EJB project. Choose an EJB project, or enter a new EJB project name.
MSG_INVALID_WEB_PROJECT={0} is not a Web project. Choose a Web project, or enter a new Web project name.
MSG_INVALID_PROJECT_TYPE={0} is not a {1} project. Choose a {1} project, or enter a new project name.
MSG_MODULE=module
MSG_MODULE_NAME_AND_PROJECT_NAME_NOT_THE_SAME=The flexible project preference is off. Therefore, project names and module names must be the same for new modules.

MSG_SAME_CLIENT_AND_SERVICE_EARS=Your selected service and client {0} modules have the same name.  Proceeding with this configuration may result in runtime errors.
MSG_SAME_CLIENT_AND_SERVICE_COMPONENTS=Your selected service and client {0} modules have the same name.  Proceeding with this configuration will result in runtime errors.
MSG_SAME_CLIENT_AND_SERVICE_PROJECTS=Your selected service and client projects are the same.  Proceeding with this configuration will result in errors.
MSG_WRONG_CLIENT_PROJECT_TYPE=The selected client project, {0}, is not a {1} project. Please select a {1} project or enter a new project name.
MSG_CLIENT_SUB=client
MSG_SERVICE_SUB=service
MSG_GENERAL_PROJECT_AND_EAR=Select the {0} project and the EAR project with which you want it to be associated.
MSG_EAR_PROJECT_WILL_BE_CREATED=If an EAR or project does not exist or is currently unassociated, it will be created and \nassociated as required when you click Next.

MSG_EAR_WILL_BE_ASSOCIATED=The selected {0} project will be associated with the EAR project.
MSG_PROJECT_WILL_BE_CREATED=The {0} project will be created and associated with the EAR project.
MSG_EAR_WILL_BE_CREATED=The {0} EAR project will be created and associated with the project.
MSG_PROJECT_AND_EAR_CREATED=The {0} project and EAR project will be created and associated with one another.

# WebServiceClientRuntimeSelectionPage
PAGE_TITLE_WS_CLIENT_RUNTIME_SELECTION=Client Environment Configuration
PAGE_DESC_WS_CLIENT_RUNTIME_SELECTION=Choose from the list of supported runtimes and servers for the client environment, or use the default settings.

LABEL_CLIENT_SELECTION_VIEW_TITLE=Client-Side Environment Selection:
LABEL_CLIENT_TYPE=Client type:
LABEL_WEB=Web
LABEL_EJB=EJB
LABEL_NO_LABEL=

#
# Items common to WebServiceMappingsPage, WebServiceMappingsPage (client), and WebServiceSOAPBindingPage
#
PAGE_MSG_VALIDATION_INTERNAL_ERROR=An internal error occurred during page validation. See logs for details.

#
# WebServiceMappingsPage
#
PAGE_TITLE_WS_XML2BEAN=Web Service Skeleton XML to Java Mappings
PAGE_DESC_N2P_MAPPINGS=Define custom mapping for namespace to package.
MSG_MAPPING_DUPLICATE_ENTRIES=Duplicate {0} mapped to the same {1}.


#
# The two ITEM_* strings are entries in a list box of mappings.
# There are two forms, one when the page is in Java-to-XML mode:
#   <java-bean-name>, <encoding-style>
# and one when the page is in XML-to-Java mode:
#   <xml-namespace-uri>:<xml-short-name>, <encoding-style>
# where:
#   <java-bean-name> is a fully-qualified Java class name
#   <xml-namespace-uri> is the namespace of an XML type
#   <xml-short-name> is the XML type name within the namespace
#   <encoding-style> is the encoding style (SOAP or Literal XML)
#

#
# WebServiceProxyPage
#
BUTTON_GENERATE_PROXY=Generate a proxy

#
# WebServiceSkeletonConfigPage
#
PAGE_DESC_WSSKEL_CONFIG=Define a skeleton Java bean as a Web service.
PAGE_TITLE_WSSKEL_CONFIG=Web Service Skeleton Java Bean Configuration
TOOLTIP_PBSC_TEXT_SKELETON_FOLDER=Folder for generated Java skeleton.
TOOLTIP_PBSC_BUTTON_SKELETON_FOLDER_BROWSE=Browse folders.
LABEL_SKELETON_ROOT_NAME=Skeleton folder:

#
# WebServiceBeanClassPage
#
LABEL_BEAN_CLASS_NAME=Bean:
PAGE_MSG_BEAN_CANNOT_BE_EMPTY=Please select a Java bean class.
BUTTON_BROWSE_CLASSES=Browse classes...


#
# WebServiceTestPage
#
PAGE_TITLE_WSTEST=Web Service Test Page
PAGE_DESC_WSTEST=Select a test facility
LABEL_TEST_TYPES=Test Facility
CHECKBOX_TEST_WEBSERVICE=Test the Web service
CHECKBOX_MONITOR_WEBSERVICE=Monitor the Web service
MSG_ERROR_UNABLE_TO_LAUNCH_WSDL_TEST=An error occurred. Unable to launch WSDL test facility.

#
# WebServiceExplorerPage
#
BUTTON_LAUNCH_SERVICE_TEST=Launch

#
# WebServiceClientTestPage
#
PAGE_TITLE_WS_SAMPLE=Web Service Client Test
PAGE_DESC_WS_SAMPLE=Do you want to test the generated proxy?
BUTTON_TEST=Test the generated proxy
LABEL_TEST_TYPES=Test facility
BUTTON_RUN_TEST=Run test on server
LABEL_METHODS=Methods
MSG_ERROR_JTS_JSP_GEN=IWAB0313E Error encountered while generating the sample.
LABEL_JSP_PROJECT_NAME=JSP project:
MSG_ERROR_JTS_PROXY_NOT_COMPILED=IWAB0357E The Generated proxy was not found. WebService sample jsps cannot be generated.
MSG_ERROR_MALFORMED_URL=IWAB0358E Test client URL is malformed.

#
# WebServiceISDPage
#

#
# WebServiceBeanConfigPage
#

#
# WebServiceBeanMethodsPage
#
BUTTON_SELECT_ALL=Select All
BUTTON_DESELECT_ALL=Deselect All
TOOLTIP_PBME_BUTTON_SELECT_ALL=Select all methods
TOOLTIP_PBME_BUTTON_DESELECT_ALL=Deselect all methods

#
# WebServiceEJBConfigPage
#

#
# WebServiceWSDLSelectionPage
#
PAGE_TITLE_WSDL_SELECTION=Web Service WSDL File Selection
PAGE_DESC_WSDL_SELECTION=Select a WSDL file.


#
# WebServicePublishPage
#
PAGE_TITLE_WS_PUBLISH=Web Service Publication
PAGE_DESC_WS_PUBLISH=Do you want to publish your Web service?
PAGE_TITLE_WS_FIND=Find a Web service
PAGE_DESC_WS_FIND=Do you want to find a Web service?
BUTTON_WS_PUBLISH=Launch the Web Services Explorer to publish this Web service to a UDDI Registry
BUTTON_WS_PUBLISH_PRIVATE_UDDI=Launch the Web Services Explorer to publish this Web service to the Unit Test UDDI Registry
BUTTON_WS_FIND=Launch the Web Services Explorer to find a Web service from a UDDI Registry
BUTTON_WS_FIND_PRIVATE_UDDI=Launch the Web Services Explorer to find a Web service from the Unit Test UDDI Registry
LABEL_PUBLIC_UDDI_REGISTRIES=Public UDDI Registry

#
# EJB UI strings
#
LABEL_EJB_BEAN_NAME=EJB bean
TABLE_TITLE_EJB_BEAN_NAMES=Stateless EJB beans
TABLE_TITLE_EJB_PROJECT_NAME=EJB project
LABEL_EAR_PROJECTS=EAR projects
TOOLTIP_EAR_PROJECTS=Enterprise application projects.
TOOLTIP_TABLE_BEAN_NAMES=Select an EJB.

#
# Tooltips for WebServiceWSDLSelectionPage
#
TOOLTIP_PWWS_PAGE=

#
# Tooltips for beans.WebServiceBeanClassPage
#
TOOLTIP_PBCL_PAGE=
TOOLTIP_PBCL_TEXT_BEAN_CLASS=Selected Java bean.
TOOLTIP_PBCL_BUTTON_BEAN_CLASS_BROWSE=Browse classes.
TOOLTIP_PBCL_BUTTON_BEAN_RESOURCE_BROWSE=Browse Java files.


#
# Tooltips for beans.WebServiceTestPage
#
TOOLTIP_PSTP_COMBOBOX_TEST=Test facilities available to test the service.
TOOLTIP_PSTP_LAUNCH_BUTTON=Launch the selected test facility.




#
# Tooltips for WebServiceRuntimeSelectionPage
#
TOOLTIP_PWRS_PAGE=
TOOLTIP_PWRS_LIST_RUNTIMES=Select from the following deployment runtime(s).
TOOLTIP_PWRS_LIST_SERVERS=Select from application server(s).
TOOLTIP_PWRS_RADIO_SERVER=Server oriented selection.
TOOLTIP_PWRS_RADIO_RUNTIME=Runtime oriented selection.
TOOLTIP_PWRS_RADIO_EXPLORE=Explore combinations.
TOOLTIP_PWRS_COMBO_PROJECT=Web project.

#
# Tooltips for WebServiceClientRuntimeSelectionPage
#
TOOLTIP_PWCR_COMBO_CLIENT_TYPE=Client type.


#
# Tooltips for WebServiceProjectPage
#
TOOLTIP_PWPR_COMBO_TYPE=Web service implementation type.
TOOLTIP_PWPR_GROUP_SCENARIO_SERVICE=Service defaults for this wizard scenario.
TOOLTIP_PWPR_CHECKBOX_GENERATE_PROXY=Enable/disable proxy generation for this scenario.
TOOLTIP_PWPR_CHECKBOX_START_WEB_PROJECT=Start Web service in Web project for this scenario.
TOOLTIP_PWPR_CHECKBOX_LAUNCH_WS=Launch the Web Services Explorer to publish the Web service in this scenario to a UDDI Registry.
TOOLTIP_PWPR_CHECKBOX_TEST_SERVICE=Select this to explore the Web service created.
TOOLTIP_PWPR_CHECKBOX_MONITOR_SERVICE=Select this to monitor the SOAP traffics of this Web service.
TOOLTIP_PWPR_GROUP_SCENARIO_CLIENT=Client proxy defaults for this wizard scenario.
TOOLTIP_PWPR_COMBO_CLIENTTYPE=Client proxy selection type.

#
# Tooltips for WebServicePublishPage
#
TOOLTIP_PWPB_PAGE=
TOOLTIP_PWPB_CHECKBOX_WS_LAUNCH=Publish the Web service.


#
# WSIL proxy
#

PAGE_WSIL_IMPORT=WSIL Import Page
TITLE_WSIL_IMPORT=WSIL Import
DESC_WSIL_IMPORT=Import WSDL references to a WSIL document
PAGE_TITLE_WS_SELECTION=Web Service Selection Page
PAGE_DESC_WS_SELECTION=Enter a web service URI.

PAGE_MSG_LOADING_WEB_SERVICE_URI=Loading Web service URI...
PAGE_MSG_INVALID_WEB_SERVICE_URI=Invalid Web service URI.  Enter an URI to a WSDL, WSIL or HTML document.
PAGE_MSG_NO_SUCH_FILE=File "{0}" does not exists.
PAGE_MSG_SELECTION_MUST_BE_WSDL=Selection must be WSDL.
PAGE_MSG_INVALID_WSIL_FILE_NAME=Invalid WSIL file name.  WSIL file name must end with .wsil



MSG_ERROR_URI_NOT_RESOLVABLE=IWAB0469E "{0}" is not resolvable.
MSG_ERROR_WSDL_HAS_NO_SERVICE_ELEMENT=IWAB0551E WSDL file at {0} has no service element.

LABEL_WSIL_URI=WSIL URI:
LABEL_BROWSE=Browse
LABEL_WSDL=WSDL:
LABEL_WSDL_URI=WSDL URI
LABEL_IMPORT=Import...
LABEL_ADD=Add
LABEL_REMOVE=Remove
LABEL_WS_SELECTION=Enter an URI to a WSDL, WSIL or HTML document:
LABEL_SELECT_WSDL=Select a WSDL
LABEL_VALIDATE_MESSAGES=WSDL validation messages:


TOOLTIP_WSIL_IMPORT_PAGE=This page allows you to add WSDL references to a WSIL document.
TOOLTIP_WSIL_TEXT_WSIL=Enter the location of a new or existing WSIL document.
TOOLTIP_WSIL_BUTTON_BROWSE_WSIL=Browse for a WSIL document.
TOOLTIP_WSIL_TABLE_WSDL=Enter the URIs of the WSDLs that are going to be added as service references.
TOOLTIP_PCON_PAGE=Select a web service for consumption.
TOOLTIP_PCON_TEXT_WS=Enter an URI to a WSDL, WSIL or HTML document.
TOOLTIP_PCON_BUTTON_BROWSE_WS=Browse for a web service resource.
TOOLTIP_VALIDATE_TEXT_MESSAGE=Messages from WSDL validation.
TOOLTIP_TABLE_VALIDATE_MESSAGE=Use the Web Service Profile Validation preference to enable or disable WSDL validation.

#
# Tooltips for client.WebServiceClienTestPage
#
TOOLTIP_PWSM_PAGE=
TOOLTIP_PWSM_CHECKBOX_TEST=Enable/disable Test.
TOOLTIP_PWSM_COMBOBOX_TEST=Select the test type.
TOOLTIP_PWSM_CHECKBOX_LAUNCH=Run test on a server.
TOOLTIP_PWSM_TEXT_JSP_FOLDER=Destination folder of generated sample files.
TOOLTIP_PWSM_BUTTON_JSP_FOLDER_BROWSE=Browse folders.
TOOLTIP_PWSM_BUTTON_SELECT_ALL=Select all methods.
TOOLTIP_PWSM_BUTTON_DESELECT_ALL=Deselect all methods.
TOOLTIP_PWSM_COMBO_PROJECT=Web project for generated sample.
TOOLTIP_PWSM_TEXT_SAMPLE_FOLDER=Destination folder of generated sample files.
TOOLTIP_PWSM_TREE_METHODS=Methods to generate into the sample.
TOOLTIP_PWSM_EAR_PROJECT=EAR project for the generated sample.

#
# HTTP Basic Auth
#
DIALOG_TITLE_HTTP_BASIC_AUTH=HTTP Basic Authentication
LABEL_URL=URL:
LABEL_HTTP_BASIC_AUTH_USERNAME=User name:
LABEL_HTTP_BASIC_AUTH_PASSWORD=Password:

TOOLTIP_HTTP_BASIC_AUTH_USERNAME=Enter your HTTP basic authentication user name.
TOOLTIP_HTTP_BASIC_AUTH_PASSWORD=Enter your HTTP basic authentication password.

#
# Web Service Server Runtime Type
#


#
# Client project type
#

#
# Generate Handler Skeleton
#
TASK_LABEL_GEN_HANDLER_SKELETON=Generate handler skeleton command
TASK_DESC_GEN_HANDLER_SKELETON=Generate handler skeleton command
MSG_ERROR_GENERATE_HANDLER_SKELETON=IWAB0359E Error in generating handler skeleton.
MSG_ERROR_WRITE_FILE=IWAB0360E Error in writing file {0}.

#
# Handlers Configuration wizard page
#
LABEL_HANDLERS_CONFIG=Handler Configuration
LABEL_BUTTON_ADD=Add
LABEL_BUTTON_REMOVE=Remove
LABEL_BUTTON_MOVE_UP=Move Up
LABEL_BUTTON_MOVE_DOWN=Move Down
LABEL_BUTTON_GEN_SKELETON=Generate skeleton classes for new handlers
LABEL_COMBO_SOURCE_LOC=Output folder:
LABEL_COMBO_WS_CLIENT_REF=Client Service Reference:
LABEL_COMBO_WS_SERVICE_DESC=Service Description:

LABEL_HANDLER_NAME=Name
LABLE_HANDLER_CLASS=Class Name
LABEL_HANDLER_PORT=Port Name

DIALOG_TITLE_WS_ADD_HANDLER=Add New Handler
LABEL_TEXT_HANDLER_NAME=Name:
LABEL_TEXT_HANDLER_CLASS=Class name:
LABEL_TEXT_HANDLER_PORT=Port name:

PAGE_TITLE_SERVICE_HDLR_CONFIG=Service Handlers Configuration
PAGE_DESC_SERVICE_HDLR_CONFIG=Configure service-side handlers
PAGE_TITLE_CLIENT_HDLR_CONFIG=Client Handlers Configuration
PAGE_DESC_CLIENT_HDLR_CONFIG=Configure client-side handlers

TOOLTIP_EDIT_WS_HANDLERS=Configure Web Service Handlers
TOOLTIP_BUTTON_GEN_SKELETON=Select to generate skeleton classes for new handlers.
TOOLTIP_COMBO_SOURCE_LOC=Select the output location for file generation.
TOOLTIP_TEXT_HANDLER_NAME=Handler name
TOOLTIP_TEXT_HANDLER_CLASS=Handler class name
TOOLTIP_TEXT_HANDLER_PORT=Handler port component name
TOOLTIP_WS_CLIENT_REF=Select a client service-reference to show its handlers.
TOOLTIP_WS_SERVICE_DESC=Select a service description to show its handlers.

#
# OpenJavaEditorCommand
#
MSG_ERROR_UNABLE_TO_OPEN_JAVA_EDITOR=IWAB0029E Unable to open class {0} from project {1} in the Java editor.

#
# CheckIfServiceProject
# 
MSG_WARN_IS_SERVICE_PROJECT=The selected client project, {0}, contains the Web service. Proceeding with this configuration may result in runtime errors when invoking the Web service. Would you like to proceed?
MSG_USER_ABORTED=User pressed cancel in warning dialog which warned about the selected client project being the service project.


#
# Missing third party file error message
#
MSG_MISSING_THIRD_PARTY_FILES=Missing third party files.  Refer to http://www.eclipse.org/webtools/wst/components/ws/download_instructions_for_jars.html

#
# WSDLSelectionOutputCommand
#
MSG_WARNING_NO_SERVICE_ELEMENT=The WSDL file does not contain a Service element.  Therefore a service interface and Java proxy will not be generated and as a result, a Java test client will not be launched.  Click OK to proceed, or click Cancel to select another WSDL file.  Alternately, exit the wizard and use the WSDL editor to create a Service WSDL document.

#
# CheckWSDLValidationCommand
#
STILL_VALIDATING_WSDL=Still performing WSDL validation.  \nClick Ignore to ignore WSDL validation and continue. \nClick IgnoreAll to always ignore WSDL validation and continue.  \nClick Cancel to wait for WSDL validation to complete.
IGNORE_LABEL=Ignore
IGNORE_DESCRIPTION=Ignore the WSDL validation and continue
IGNORE_ALL_LABEL=Ignore All
IGNORE_ALL_DESCRIPTION=Always ignore WSDL validation and continue
CANCEL_LABEL=Cancel
TASK_LABEL_CHECK_WSDL_VALIDATION=Check for WSDL validation
TASK_DESC_CHECK_WSDL_VALIDATION=Check if WSDL validation has completed
CANCEL_DESCRIPTION=Cancel
WAIT_FOR_WSDL=Do not continue with wizard.  Wait for WSDL validation to complete.

#
# Start server page
#
PAGE_TITLE_WS_START_SERVER=Server startup page
PAGE_DESC_WS_START_SERVER=Start the server from this page.
LABEL_START_SERVER_TEXT1=In order to proceed the server "{0}" must be started.
LABEL_START_SERVER_TEXT2=Once the server is started the "next" button will be enabled.
LABEL_START_SERVER_TEXT3=The "back" button can be used while the server is starting to
LABEL_START_SERVER_TEXT4=change any previous settings in this wizard.
LABEL_START_SERVER_BUTTON=Start server
TOOLTIP_START_SERVER_BUTTON=Start the server
TEXT_SERVER_STATUS=Currently the server is {0}.
TEXT_SERVER_MSG=Server {0}
TEXT_SERVER_STARTED=started
TEXT_SERVER_STARTING=starting
TEXT_SERVER_STOPPED=stopped


