apache / xmlbeans / fb7d8af795871f4ad8d406da5c1fb54d38ed5c9c / . / resources / xmlpublic / org / apache / xmlbeans / message.properties

## | |

## Copyright 2004 The Apache Software Foundation | |

## | |

## Licensed under the Apache License, Version 2.0 (the "License"); | |

## you may not use this file except in compliance with the License. | |

## You may obtain a copy of the License at | |

## | |

## http://www.apache.org/licenses/LICENSE-2.0 | |

## | |

## Unless required by applicable law or agreed to in writing, software | |

## distributed under the License is distributed on an "AS IS" BASIS, | |

## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |

## See the License for the specific language governing permissions and | |

## limitations under the License. | |

## | |

# XMLBeans message properties | |

# | |

# xmlbean messages | |

# | |

message.missing.resource = \ | |

Message property value not found: {0} | |

message.pattern.invalid = \ | |

Message property value invalid: {0} | |

invalid.document.type = \ | |

Document {0} is not a {1} file | |

cannot.load.file = \ | |

Cannot load {0} file {1}: {2} | |

exception.loading.url = \ | |

{0} exception while trying to load {1}: {2} | |

exception.value.not.supported.j2s = \ | |

Could not set Java {0} type to Schema {1} type | |

exception.value.not.supported.s2j = \ | |

Could not get a Java {1} type from a Schema {0} type | |

exception.xqrl.xpath.not.valid = \ | |

Path expression is not selective, it creates new nodes: {0} | |

exception.xqrl.exception = \ | |

XQuery engine exception: {0} for expresion: {1} | |

# | |

# xml messages | |

# | |

uniqattspec = \ | |

Duplicate attribute: {0} | |

# | |

# schema messages | |

# | |

cvc-assess-attr = \ | |

Schema-Validity Assessment (Attribute) | |

cvc-assess-attr.1.2 = \ | |

Attribute not allowed (strict wildcard, and no definition found): {0} | |

cvc-assess-elt = \ | |

Schema-Validity Assessment (Element) | |

cvc-assess-elt.1.1.1.3.2 = \ | |

Element not allowed (strict wildcard, and no definition found): {0} | |

cvc-attribute = \ | |

Attribute Locally Valid | |

cvc-attribute.1 = \ | |

Invalid type for attribute | |

cvc-attribute.4 = \ | |

The value ''{0}'' does not equal the fixed value ''{1}'' of attribute ''{2}'' | |

#The value ''{0}'' does not equal the fixed value ''{1}'' | |

cvc-au = \ | |

Attribute Locally Valid (Use) | |

cvc-complex-type = \ | |

Element Locally Valid (Complex Type) | |

cvc-complex-type.2.1 = \ | |

Element ''{0}'' with empty content type cannot have text or element content. | |

cvc-complex-type.2.2 = \ | |

Element ''{0}'' with a simple type definition cannot have element content. | |

cvc-complex-type.2.3 = \ | |

Element ''{0}'' with element-only content type cannot have text content. | |

cvc-complex-type.2.4a = \ | |

Expected {0,choice,1#element|1<elements} ''{1}'' instead of ''{2}'' here | |

cvc-complex-type.2.4b = \ | |

Element not allowed: {0} | |

cvc-complex-type.2.4c = \ | |

Expected {0,choice,1#element|1<elements} ''{1}'' before the end of the content | |

cvc-complex-type.2.4d = \ | |

Expected element(s) | |

cvc-complex-type.3.1 = \ | |

The value ''{0}'' does not equal the fixed value ''{1}'' of attribute ''{2}'' | |

#The value ''{0}'' does not equal the fixed value ''{1}'' | |

cvc-complex-type.3.2.1 = \ | |

Attribute not allowed (no wildcards allowed): {0} | |

cvc-complex-type.3.2.2 = \ | |

Attribute not allowed: {0} | |

cvc-complex-type.4 = \ | |

Expected attribute: {0} | |

cvc-datatype-valid = \ | |

Datatype Valid | |

cvc-datatype-valid.1.1 = \ | |

{0} value ''{1}'' does not match pattern for {2} | |

cvc-datatype-valid.1.1b = \ | |

{0} value does not match pattern for {1} | |

cvc-datatype-valid.1.2.3 = \ | |

union value ''{0}'' does not match any members of ''{1}'' | |

cvc-elt = \ | |

Element Locally Valid (Element) | |

cvc-elt.1 = \ | |

Invalid type | |

cvc-elt.2 = \ | |

Element ''{0}'' is abstract and cannot be used in an instance | |

cvc-elt.3.1 = \ | |

Element has xsi:nil attribute but is not nillable | |

cvc-elt.3.2.1 = \ | |

Nil element cannot have element or text content | |

cvc-elt.3.2.2 = \ | |

Nil element cannot have a fixed value constraint | |

cvc-elt.4.1 = \ | |

Invalid xsi:type qname: ''{0}'' | |

cvc-elt.4.2 = \ | |

Invalid xsi:type qname: ''{0}'' | |

cvc-elt.4.3a = \ | |

Type ''{0}'' is not derived from ''{1}'' | |

cvc-elt.4.3b = \ | |

Extension type ''{0}'' may not be substituted for ''{1}'' | |

cvc-elt.4.3c = \ | |

Restriction type ''{0}'' may not be substituted for ''{1}'' | |

cvc-elt.4.3d = \ | |

Derived type ''{0}'' may not be substituted for element ''{1}'' | |

cvc-elt.5.2.2.1 = \ | |

Element ''{0}'' is fixed and not nil so is not allowed to have element children | |

cvc-elt.5.2.2.2.1 = \ | |

The value ''{0}'' does not equal the fixed value ''{1}'' | |

#The value ''{0}'' does not equal the fixed value ''{1}'' of ''{2}'' | |

cvc-elt.5.2.2.2.2 = \ | |

The value ''{0}'' does not equal the fixed value ''{1}'' | |

#The value ''{0}'' does not equal the fixed value ''{1}'' of ''{2}'' | |

cvc-enumeration-valid = \ | |

{0} value ''{1}'' is not a valid enumeration value for {2} | |

cvc-enumeration-valid.b = \ | |

{0} value is not a valid enumeration value for {1} | |

cvc-facet-valid = \ | |

Facet Valid | |

cvc-fractionDigits-valid = \ | |

Decimal fractional digits ({0}) of value ''{1}'' does not match fractionDigits facet ({2}) for {3} | |

cvc-id.2 = \ | |

Duplicate ID value ''{0}'' | |

cvc-identity-constraint = \ | |

Identity-constraint Satisfied | |

cvc-identity-constraint.4.1 = \ | |

Duplicate key ''{0}'' for unique constraint ''{1}'' | |

cvc-identity-constraint.4.2.2 = \ | |

Duplicate key ''{0}'' for key constraint ''{1}'' | |

cvc-identity-constraint.4.3 = \ | |

Key ''{0}'' not found for keyref constraint ''{1}'' | |

cvc-length-valid = \ | |

Length Valid | |

cvc-length-valid.1.1 = \ | |

{0} length ({1}) does not match length facet ({2}) for {3} | |

cvc-length-valid.1.2 = \ | |

{0} encoded data has {1} bytes but requires {2} bytes required by length facet for {3} | |

cvc-length-valid.2 = \ | |

List value ''{0}'' has {1} items but requires {2} items per length facet for {3} | |

cvc-maxExclusive-valid = \ | |

{0} value ({1}) is greater than or equal to maxExclusive facet ({2}) for {3} | |

cvc-maxInclusive-valid = \ | |

{0} value ({1}) is greater than maxInclusive facet ({2}) for {3} | |

cvc-maxLength-valid = \ | |

maxLength Valid | |

cvc-maxLength-valid.1.1 = \ | |

{0} length ({1}) is greater than maxLength facet ({2}) for {3} | |

cvc-maxLength-valid.1.2 = \ | |

{0} encoded data has only {1} bytes, more than maxLength facet ({2}) for {3} | |

cvc-maxLength-valid.2 = \ | |

List value ''{0}'' has {1} items, more than maxLength facet ({2}) for {3} | |

cvc-minExclusive-valid = \ | |

{0} value ({1}) is less than or equal to minExclusive facet ({2}) for {3} | |

cvc-minInclusive-valid = \ | |

{0} value ({1}) is less than minInclusive facet ({2}) for {3} | |

cvc-minLength-valid = \ | |

minLength Valid | |

cvc-minLength-valid.1.1 = \ | |

{0} length ({1}) is less than minLength facet ({2}) for {3} | |

cvc-minLength-valid.1.2 = \ | |

{0} encoded data has only {1} bytes, fewer than minLength facet ({2}) for {3} | |

cvc-minLength-valid.2 = \ | |

List value ''{0}'' has only {1} items, fewer than minLength facet ({2}) for {3} | |

cvc-model-group = \ | |

Element Sequence Valid | |

cvc-particle = \ | |

Element Sequence Locally Valid (Particle) | |

cvc-particle.1.3: \ | |

Element not allowed: {0} | |

cvc-particle.2.3.3a: \ | |

Element substitution not allowed when group head has block=''substitution'': {0} | |

cvc-pattern-valid = \ | |

pattern valid | |

cvc-resolve-instance = \ | |

QName resolution (Instance) | |

cvc-simple-type = \ | |

String Valid | |

cvc-totalDigits-valid = \ | |

The total digits ({0}) of value ''{1}'' is greater than the totalDigits facet ({2}) for {3} | |

cvc-type = \ | |

Element Locally Valid (Type) | |

cvc-type.2 = \ | |

Abstract type ''{0}'' cannot be used in an instance | |

cvc-wildcard = \ | |

Item Valid (Wildcard) | |

cvc-wildcard-namespace = \ | |

Wildcard allows Namespace Name | |

schema_reference = \ | |

Schema Document Location Strategy | |

src-annotation = \ | |

Annotation Definition Representation OK | |

src-attribute = \ | |

Attribute Declaration Representation OK | |

src-attribute.1 = \ | |

Either default or fixed may be present on attribute ''{0}'', but not both. | |

au-value_constraint = \ | |

The fixed value on attribute must match that of the referenced attribute. | |

src-attribute.2 = \ | |

The attribute ''{0}'' declaration must be optional in order to specify a default. | |

src-attribute.3.1a = \ | |

Either ref or name must be present on attribute ''{0}'', but not both. | |

src-attribute.3.1b = \ | |

Neither ref nor name found on the attribute declaration. | |

src-attribute.3.2 = \ | |

Attribute reference cannot also specify {0}. | |

src-attribute.4 = \ | |

Illegal to define a nested type when a type attribute is specified. | |

src-attribute_group = \ | |

Attribute Group Definition Representation OK | |

src-attribute_group.3 = \ | |

Attribute group ''{0}'' references itself. | |

src-ct = \ | |

Complex Type Definition Representation OK | |

src-ct.1 = \ | |

Type ''{0}'' is being used as the base type for a complexContent definition. To do this the base type must be a complex type. | |

src-ct.2 = \ | |

To extend the specified base type ''{0}'' it must be a simple type or be a complex type with simple content. | |

src-element = \ | |

Element Declaration Representation OK | |

src-element.1 = \ | |

Either default or fixed may be present on element but not both. | |

src-element.2.1a = \ | |

Either ref or name must be present on element ''{0}'', but not both. | |

src-element.2.1b = \ | |

Neither ref nor name found on the element declaration. | |

src-element.2.2 = \ | |

Element reference cannot also specify {0}. | |

src-element.3 = \ | |

Illegal to define a nested type when a type attribute is specified. | |

src-expredef = \ | |

Individual Component Redefinition | |

src-identity-constraint = \ | |

Identity-constraint Definition Representation OK | |

src-import = \ | |

Import Constraints and Semantics | |

src-include = \ | |

Inclusion Constraints and Semantics | |

src-list-itemType-or-simpleType = \ | |

itemType attribute or simpleType child | |

src-model_group = \ | |

Model Group Representation OK | |

src-model_group_defn = \ | |

M | |

src-multiple-enumerations = \ | |

Multiple enumerations | |

src-multiple-patterns = \ | |

Multiple patterns | |

src-notation = \ | |

Notation Definition Representation OK | |

src-qname = \ | |

QName Interpretation | |

src-redefine = \ | |

Redefinition Constraints and Semantics | |

src-redefine.5a = \ | |

A {0} type redefinition must extend or restrict the original definition of the type. Missing <restriction> or <extension> from type redefinition. | |

src-redefine.5b = \ | |

A {0} type redefinition must extend or restrict the original definition of the type. The attribute base=''{1}'' must match the attribute name=''{2}'' of the redefined {0}. | |

src-redefine.6.1.1 = \ | |

The group redefinition {0} must reference the originial definition at most once. | |

src-redefine.6.1.2 = \ | |

When referencing the original group definition in the redefinition {0}, maxOccurs and minOccurs must be 1. | |

src-redefine.7.1 = \ | |

The attribute group redefinition {0} must reference the original definition at most once. | |

src-resolve = \ | |

{0} ''{1}'' not found. | |

# e.g., "element 'foo' not found." | |

src-resolve.a = \ | |

Could not find {0} ''{1}''. Do you mean to refer to the {2} {3,choice,0#with that name|1#named {4}}{5,choice,0#|1# (in {6})}? | |

src-restriction-base-or-simpleType = \ | |

base attribute or simpleType child | |

src-simple-type = \ | |

Simple Type Definition Representation OK | |

src-simple-type.2a = \ | |

Simple type restrictions must name a base type or contain a nested simple type: both were found. | |

src-simple-type.2b = \ | |

Simple type restrictions must name a base type or contain a nested simple type: neither were found. | |

src-simple-type.3a = \ | |

List type definitions provide either an itemType attribute or contain a nested simpleType: both were found. | |

src-simple-type.3b = \ | |

List type definitions provide either an itemType attribute or contain a nested simpleType: neither were found. | |

src-simple-type.4 = \ | |

Member {0}has a cyclic dependency on the union. | |

src-single-facet-value = \ | |

Facet specified multiple times. | |

src-union-memberTypes-or-simpleTypes = \ | |

A union type must specify at least one member type. | |

src-wildcard = \ | |

Wildcard Representation OK | |

a-props-correct = \ | |

Attribute Declaration Properties Correct | |

a-props-correct.2 = \ | |

The {0} attribute {1} value ''{2}'' is not a valid value for {3}. | |

a-props-correct.3 = \ | |

An attribute of type xs:ID is not allowed to have a default or fixed constraint. | |

ag-props-correct = \ | |

Attribute Group Definition Properties Correct | |

ag-props-correct.2 = \ | |

KHK: TBD | |

ag-props-correct.3 = \ | |

Both {0} and {1} are xs:ID attributes; only one ID attribute is allowed on a type. | |

an-props-correct = \ | |

Annotation Correct | |

au-props-correct = \ | |

Attribute Use Correct | |

c-fields-xpaths = \ | |

Invalid xpath value in field: {0} | |

c-props-correct = \ | |

Identity-constraint Definition Properties Correct | |

c-props-correct.1 = \ | |

Keyref cannot refer to another keyref. | |

c-props-correct.2 = \ | |

Keyref does not have same number of fields as key | |

c-selector-xpath = \ | |

Invalid xpath value in selector: {0} | |

cos-all-limited = \ | |

All Group Limited | |

cos-all-limited.1.2a = \ | |

An all group must have maxOccurs <= 1. | |

cos-all-limited.1.2b = \ | |

An all group is only allowed at the top level of the content model. | |

cos-all-limited.2 = \ | |

An all group can contain only element particles with maxOccurs <= 1 | |

cos-applicable-facets = \ | |

The facet ''{0}'' does not apply to the base type {1}. | |

cos-aw-intersect = \ | |

Attribute Wildcard Intersection | |

cos-aw-union = \ | |

Attribute Wildcard Union | |

cos-choice-range = \ | |

Effective Total Range (choice) | |

cos-ct-derived-ok = \ | |

Type Derivation OK (Complex) | |

cos-ct-extends = \ | |

Derivation Valid (Extension) | |

cos-ct-extends.1.1 = \ | |

The base complex type {0} cannot be restricted by {1} when final=''extension''. | |

cos-ct-extends.1.4.1 = \ | |

This type extends a base type ''{0}'' which has simpleContent. In that case this type cannot add particles. | |

cos-ct-extends.1.4.2.2 = \ | |

Cannot extend an element-only type with a mixed type or vice-versa. | |

cos-element-consistent = \ | |

Type of ''{0}'' is inconsistent with another element with the same name in this content model. | |

cos-equiv-class = \ | |

Substitution Group | |

cos-equiv-derived-ok-rec = \ | |

Substitution Group OK (Transitive) | |

cos-group-emptiable = \ | |

Particle Emptiable | |

cos-list-of-atomic = \ | |

list of atomic | |

cos-no-circular-unions = \ | |

no circular unions | |

cos-nonambig = \ | |

Content model violates the unique particle attribution rule. | |

cos-ns-subset = \ | |

Wildcard Subset | |

cos-particle-extend = \ | |

Particle Valid (Extension) | |

cos-particle-restrict = \ | |

Particle Valid (Restriction) | |

cos-particle-restrict.2 = \ | |

Invalid Restriction. The derived content model {0} cannot restrict base content model {1}. | |

cos-seq-range = \ | |

Effective Total Range (all and sequence) | |

cos-st-derived-ok = \ | |

Type Derivation OK (Simple) | |

cos-st-restricts = \ | |

Derivation Valid (Restriction, Simple) | |

cos-st-restricts.1.1 = \ | |

Base type for this simple type restriction is not simple. | |

cos-st-restricts.2.1a = \ | |

Item type for this list type is not simple. | |

cos-st-restricts.2.1b = \ | |

This item type is another list type; lists of lists are not allowed. | |

cos-st-restricts.2.1c = \ | |

This item type is a union containing a list; lists of lists are not allowed. | |

cos-st-restricts.3.1 = \ | |

Member {0}is not simple. | |

cos-valid-default = \ | |

Element Default Valid (Immediate) | |

cos-valid-default.2.1 = \ | |

The {0} element cannot have a default value ''{1}'' because its type has {2} content only. | |

cos-valid-default.2.2.2 = \ | |

The {0} element cannot have a {1} value ''{2}'' because it's content is mixed but not emptiable. | |

id-idref-idrefs-entity-entities-notation = \ | |

For compatibility, type ''{1}'' should only be used for attributes (used for element ''{0}''). | |

ct-props-correct = \ | |

Complex Type Definition Properties Correct | |

ct-props-correct.2 = \ | |

The simple type ''{0}'' cannot be used as the base type of a simple content restriction. (Use extension instead.) | |

ct-props-correct.4 = \ | |

Attribute with the name ''{0}'' already defined for {1}. | |

derivation-ok-restriction = \ | |

Derivation Valid (Restriction, Complex) | |

derivation-ok-restriction.1 = \ | |

The base type {0} cannot be restricted by {1} when final=''restriction''. | |

derivation-ok-restriction.2.1.1 = \ | |

The attribute ''{0}'' cannot be modified by restriction to be prohibited or optional since it is required in the base type {1}. | |

derivation-ok-restriction.2.2 = \ | |

The attribute ''{0}'' cannot be introduced by restriction since it is not allowed in the base type {1}. | |

derivation-ok-restriction.4.1 = \ | |

A restriction cannot add anyAttribute when the base type does not have anyAttribute. | |

derivation-ok-restriction.4.2 = \ | |

The anyAttribute namespace=''{0}'' is not a subset of the base type anyAttribute. | |

derivation-ok-restriction.5.1 = \ | |

A complex type with a simple content model can only restrict a complex type with simple or mixed content model. | |

derivation-ok-restriction.5.1.2 = \ | |

A type with a simple content model can only restrict a mixed content model that has skippable elements. | |

derivation-ok-restriction.5.2.2.1 = \ | |

The simple content is not validly derived from the base simple content type. | |

derivation-ok-restriction.5.2 = \ | |

A type with an empty content model cannot restrict a type with a simple content model. | |

derivation-ok-restriction.5.2.2 = \ | |

A type with an empty content model can only restrict a content model that has skippable elements. | |

derivation-ok-restriction.5.3 = \ | |

Must be a valid restriction. | |

derivation-ok-restriction.5.3a = \ | |

A type with a mixed content model can only restrict another type with a mixed content model. | |

derivation-ok-restriction.5.3b = \ | |

A type with element or mixed content cannot restrict an empty type. | |

derivation-ok-restriction.5.3c = \ | |

A type with element or mixed content cannot restrict a simple type. | |

e-props-correct = \ | |

Element Declaration Properties Correct | |

e-props-correct.2 = \ | |

The ''{0}'' element {1} value ''{2}'' is not a valid value for ''{3}'' | |

e-props-correct.4 = \ | |

Element ''{0}'' is not a valid substitution for element ''{1}'': its type is not validly derived from element ''{1}''''s type | |

e-props-correct.4a = \ | |

Element ''{0}'' is not a valid substitution for element ''{1}'' with final=''{2}'' | |

notation-targetns-attr = \ | |

For compatibility, NOTATION should only be used in schemas with no target namespace (attribute ''{0}''). | |

notation-targetns-elem = \ | |

For compatibility, NOTATION should only be used in schemas with no target namespace (element ''{0}''). | |

enumeration-required-notation = \ | |

enumeration facet value required for NOTATION | |

notation-facets = \ | |

The use of {0} on datatypes derived from NOTATION (''{1}'') is deprecated. | |

enumeration-valid-restriction = \ | |

Enumerated value ''{0}'' invalid: {1} | |

fractionDigits-totalDigits = \ | |

fractionDigits must be less than or equal to totalDigits | |

fractionDigits-valid-restriction = \ | |

Larger than prior fractionDigits. | |

length-minLength-maxLength = \ | |

Cannot specify length in addition to minLength or maxLength. | |

length-valid-restriction = \ | |

length valid restriction | |

maxExclusive-valid-restriction = \ | |

Invalid maxExclusive restriction: {0} | |

maxInclusive-maxExclusive = \ | |

maxInclusive and maxExclusive | |

maxInclusive-valid-restriction = \ | |

Invalid maxInclusive restriction: {0} | |

maxLength-valid-restriction = \ | |

Larger than prior maxLength. | |

mg-props-correct = \ | |

Model Group Correct | |

mg-props-correct.2 = \ | |

Model group ''{0}'' references itself. | |

mgd-props-correct = \ | |

Model Group Definition Properties Correct | |

minExclusive-less-than-equal-to-maxExclusive = \ | |

minExclusive <= maxExclusive | |

minExclusive-less-than-maxInclusive = \ | |

minExclusive < maxInclusive | |

minExclusive-valid-restriction = \ | |

Invalid minExclusive restriction: {0} | |

minInclusive-less-than-equal-to-maxInclusive = \ | |

minInclusive <= maxInclusive | |

minInclusive-less-than-maxExclusive = \ | |

minInclusive < maxExclusive | |

minInclusive-minExclusive = \ | |

minInclusive and minExclusive | |

minInclusive-valid-restriction = \ | |

Invalid minInclusive restriction: {0} | |

minLength-less-than-equal-to-maxLength = \ | |

minLength <= maxLength | |

minLength-valid-restriction = \ | |

Smaller than prior minLength. | |

n-props-correct = \ | |

Notation Declaration Correct | |

no-xmlns = \ | |

The name of an attribute declaration must not match ''xmlns''. | |

no-xsi = \ | |

Illegal namespace for attribute declaration: {0} | |

enumeration-required-notation-attr = \ | |

It is an error for NOTATION to be used directly in a schema. Only datatypes that are derived from NOTATION by specifying a value for enumeration can be used in a schema (attribute ''{0}''). | |

enumeration-required-notation-elem = \ | |

It is an error for NOTATION to be used directly in a schema. Only datatypes that are derived from NOTATION by specifying a value for enumeration can be used in a schema (element ''{0}''). | |

p-props-correct = \ | |

Particle Correct | |

p-props-correct.2.1 = \ | |

maxOccurs must not be less than minOccurs. | |

p-props-correct.2.2 = \ | |

maxOccurs must be greater than or equal to 1. | |

range-ok = \ | |

Occurrence Range OK | |

range-ok.1 = \ | |

Invalid Restriction. The minOccurs ({1}) for the derived {0} is less than the minOccurs ({3}) of the base {2}. | |

range-ok.2 = \ | |

Invalid Restriction. The maxOccurs ({1}) for the derived {0} is greater than the maxOccurs ({3}) of the base {2}. | |

rcase-MapAndSum = \ | |

Particle Derivation OK (Sequence:Choice -- MapAndSum) | |

rcase-MapAndSum.1 = \ | |

Invalid Restriction. The {0} particle of the derived <sequence> cannot be mapped to any one of the base <choice>''s particles. | |

rcase-MapAndSum.2a = \ | |

Invalid Restriction. The total minOccurs for the derived <sequence>''s elements ({0}) must not be less than the base <choice>''s minOccurs ({1}). | |

rcase-MapAndSum.2b = \ | |

Invalid Restriction. The total maxOccurs for the derived <sequence>''s elements ({0}) must not be greater than the base <choice>''s maxOccurs ({1}). | |

rcase-NameAndTypeOK = \ | |

Particle Restriction OK (Elt:Elt -- NameAndTypeOK) | |

rcase-NameAndTypeOK.1 = \ | |

Invalid Restriction. The derived {0}''s name and namespace must match the base {1}''s name and namespace. | |

rcase-NameAndTypeOK.2 = \ | |

Invalid Restriction. The derived {0} must not be nillable=''true'' when the base {1} is nillable=''false''. | |

rcase-NameAndTypeOK.4 = \ | |

Invalid Restriction. The derived {0} has a fixed value of ''{1}'' which does not match the base {2}''s fixed value of ''{3}''. | |

rcase-NameAndTypeOK.5 = \ | |

Invalid Restriction. The derived {0}''s identity constraints must be a subset of the base {1}''s identity constraints. | |

rcase-NameAndTypeOK.6 = \ | |

Invalid Restriction. The derived {0} must block {1} when the base {1} does. | |

rcase-NameAndTypeOK.7a = \ | |

Invalid Restriction. The derived type {0} is not a sub-type of the base type {1}. | |

rcase-NameAndTypeOK.7b = \ | |

Invalid Restriction. The derived type {0} from base type {1} has an intermediate type {2} that is not derived by restriction. | |

rcase-NSCompat = \ | |

Particle Derivation OK (Elt:Any -- NSCompat) | |

rcase-NSCompat.1 = \ | |

Invalid Restriction. The namespace of the derived {0} is not valid with respect to the namespace(s) of the base {1}. | |

rcase-NSRecurseCheckCardinality = \ | |

Particle Derivation OK (All/Choice/Sequence:Any -- NSRecurseCheckCardinality) | |

rcase-NSSubset = \ | |

Particle Derivation OK (Any:Any -- NSSubset) | |

rcase-NSSubset.2 = \ | |

Invalid Restriction. The namespace(s) of the derived field {0} are not a subset of the namespace(s) of the base field {1}. | |

rcase-Recurse = \ | |

Particle Derivation OK (All:All,Sequence:Sequence -- Recurse) | |

rcase-Recurse.2 = \ | |

Invalid Restriction. The following particles of the derived {0} cannot be mapped to the base {1}''s particles: {2} | |

rcase-Recurse.2.1 = \ | |

Invalid Restriction. The particle {0} of the derived {1} is not a valid restriction of the non-optional particle {2} in the base {3} model. | |

rcase-Recurse.2.2 = \ | |

Invalid Restriction. The following non-optional particles of the base {0} were not mapped in the derived {1}: {2} | |

rcase-RecurseAsIfGroup = \ | |

Particle Derivation OK (Elt:All/Choice/Sequence -- RecurseAsIfGroup) | |

rcase-RecurseLax = \ | |

Particle Derivation OK (Choice:Choice -- RecurseLax) | |

rcase-RecurseLax.2 = \ | |

Invalid Restriction. The following particles of the derived <choice> cannot be mapped to the base <choice>''s particles: {0} | |

rcase-RecurseUnordered = \ | |

Particle Derivation OK (Sequence:All -- RecurseUnordered) | |

rcase-RecurseUnordered.2 = \ | |

Invalid Restriction. The particle {0} in the derived <sequence> cannot be mapped to an <element> in the base <all>. | |

rcase-RecurseUnordered.2.1 = \ | |

Invalid Restriction. The particle {0} in the derived <sequence> maps to more than one element in the base <all>. | |

rcase-RecurseUnordered.2.2 = \ | |

Particle Derivation OK (Sequence:All -- RecurseUnordered) | |

rcase-RecurseUnordered.2.2a = \ | |

Invalid Restriction. The particle {0} in the derived <sequence> has a maxOccurs greater than 1 ({1}). When restricting an <all> with a <sequence>, no <element> can have a maxOccurs > 1. | |

rcase-RecurseUnordered.2.3 = \ | |

Invalid Restriction. The particle {0} in the base <all> must be mapped by one of the members of the derived <sequence> unless it is optional (particle emptiable). | |

sch-props-correct = \ | |

Schema Properties Correct | |

sch-props-correct.2 = \ | |

Duplicate {0}: {1} (Original {0} found in file: {2}) | |

st-props-correct = \ | |

Simple Type Definition Properties Correct | |

st-props-correct.3 = \ | |

Cannot restrict a final type. | |

st-props-correct.4.2.1 = \ | |

Cannot derive by list a final type. | |

st-props-correct.4.2.2 = \ | |

Cannot derive by union a final type. | |

st-restrict-facets = \ | |

Simple Type Restriction (Facets) | |

totalDigits-valid-restriction = \ | |

Larger than prior totalDigits. | |

w-props-correct = \ | |

Wildcard Properties Correct | |

whiteSpace-valid-restriction = \ | |

Cannot apply this whitespace facet over the previous one. | |

# | |

# datatypes | |

# | |

anyURI = \ | |

Invalid value: {0} | |

base64Binary = \ | |

Invalid value: {0} | |

boolean = \ | |

Invalid boolean value ''{0}'' | |

date = \ | |

Invalid date value: {0} | |

decimal = \ | |

Invalid decimal value: {0} | |

double = \ | |

Invalid double value: {0} | |

duration = \ | |

Invalid duration value: {0} | |

float = \ | |

Invalid float value: {0} | |

hexBinary = \ | |

Invalid hexBinary value: {0} | |

int = \ | |

Invalid int value: {0} | |

integer = \ | |

Invalid integer value: {0} | |

list = \ | |

Invalid list value: {0} | |

long = \ | |

Invalid long value: {0} | |

NCName = \ | |

Invalid NCName value: {0} | |

NMTOKEN = \ | |

Invalid NMTOKEN value: {0} | |

QName = \ | |

Invalid QName value: {0} | |

union = \ | |

Invalid union value: {0} | |

# | |

# following error codes aren't defined by the XMLSchema spec | |

# | |

cvc-complex-type.prohibited-attribute = \ | |

Attribute is prohibited: {0} | |

soaparray = \ | |

Invalid SOAP Array reference: {0} (prefix declaration not found or incorrect format) | |

facet-fixed = \ | |

The facet ''{0}'' is fixed and cannot be overridden. | |

pattern-regex = \ | |

The regular expression ''{0}'' is malformed: {1} | |

missing-name = \ | |

The {0} must have a name. | |

reserved-type-name = \ | |

Skipping definition of built-in type {0}. | |

# {1} may be either an attribute name ('type', 'name') or a type name ('nonNegativeInteger') | |

invalid-value = \ | |

The value ''{0}'' is an invalid {1}. | |

# {1} may be either an attribute name ('type', 'name') or a type name ('nonNegativeInteger') | |

invalid-value-detail = \ | |

The value ''{0}'' is an invalid {1}: {2} | |

invalid-xpath = \ | |

Invalid xpath in identity constraint: {0} | |

exceeded-entity-bytes = \ | |

Exceeded Entity dereference bytes limit, limit is {0} bytes. |