]]></description>
  <defaults>
    <default>
      <key>package</key>
      <value>org.apache.maven.profiles</value>
    </default>
  </defaults>
  <classes>
    <class rootElement="true" xml.tagName="profilesXml">
      <name>ProfilesRoot</name>
      <version>1.0.0</version>
      <description>Root element of the profiles.xml file.</description>
      <fields>
        <field>

 *
 * It's assumed to always be present with known class names on Android devices, so we build
 * optimistically via [buildIfSupported]. But it also doesn't assume a compile time API.
 */
class StandardAndroidSocketAdapter(
  sslSocketClass: Class<in SSLSocket>,
  private val sslSocketFactoryClass: Class<in SSLSocketFactory>,
  private val paramClass: Class<*>,
) : AndroidSocketAdapter(sslSocketClass) {

    <artifactId>maven-impl-modules</artifactId>
    <version>4.1.0-SNAPSHOT</version>
  </parent>

  <artifactId>maven-core</artifactId>

  <name>Maven 4 Core</name>
  <description>Maven Core classes.</description>

  <dependencies>
    <!--  Maven4 API -->
    <dependency>
      <groupId>org.apache.maven</groupId>
      <artifactId>maven-api-annotations</artifactId>
    </dependency>
    <dependency>

// service.
type AuthNSuccessResponse struct {
	User               string         `json:"user"`
	MaxValiditySeconds int            `json:"maxValiditySeconds"`
	Claims             map[string]any `json:"claims"`
}

// AuthNErrorResponse - represents an error response from the authN plugin.
type AuthNErrorResponse struct {
	Reason string `json:"reason"`
}

/**
 * Tests the speed of iteration of different iteration methods for collections.
 *
 * @author David Richter
 */
@NullUnmarked
public class IteratorBenchmark {
  @Param({"0", "1", "16", "256", "4096", "65536"})
  int size;

  // use concrete classes to remove any possible polymorphic overhead?
  Object[] array;
  ArrayList<Object> arrayList;
  LinkedList<Object> linkedList;

  @BeforeExperiment

                        handler.getClassifier(),
                        handler.isIncludesDependencies(),
                        handler.isAddedToClasspath()
                                ? new JavaPathType[] {JavaPathType.CLASSES, JavaPathType.MODULES}
                                : new JavaPathType[] {});
            }
            return type;
        });
    }

///

## Importer le `BaseModel` de Pydantic { #import-pydantics-basemodel }

Commencez par importer la classe `BaseModel` du module `pydantic` :

{* ../../docs_src/body/tutorial001_py310.py hl[2] *}

## Créer votre modèle de données { #create-your-data-model }

Déclarez ensuite votre modèle de données en tant que classe qui hérite de `BaseModel`.

Utilisez les types Python standard pour tous les attributs :

     * {@return the type of the dependency}.
     * A dependency can be a <abbr>JAR</abbr> file,
     * a modular-<abbr>JAR</abbr> if it is intended to be placed on the module path,
     * a <abbr>JAR</abbr> containing test classes, <i>etc.</i>
     *
     * @see DependencyCoordinates#getType()
     */
    @Nonnull
    Type getType();

    /**
     * {@return the time at which the dependency will be used}.

                    null,
                    null,
                    type.isIncludesDependencies(),
                    type.getLanguage().id(),
                    type.getPathTypes().contains(JavaPathType.CLASSES));
            // TODO: watch out for module path
        });

        // Note: here, type decides is artifact added to "build path" (for example during resolution)

Contributor. If that Commercial Contributor then makes performance
claims, or offers warranties related to Product X, those performance
claims and warranties are such Commercial Contributor's responsibility
alone. Under this section, the Commercial Contributor would have to
defend claims against the other Contributors related to those performance
claims and warranties, and if a court requires any other Contributor to