diff --git a/.claude/conventions/backend.md b/.claude/conventions/backend.md new file mode 100644 index 00000000..60ae2b36 --- /dev/null +++ b/.claude/conventions/backend.md @@ -0,0 +1,54 @@ +# Backend Conventions for Claude Code + +## Overview + +Our backends are written in Java. This document covers conventions specific to backend applications. For general Java conventions, see [java.md](java.md). + +## Frameworks + +We use two frameworks for building backend applications: + +- **[Spring Boot](https://spring.io/projects/spring-boot)** — The full-featured option. Use Spring Boot when the application needs a broad ecosystem (security, data access, messaging, etc.) and development speed matters more than minimal footprint. +- **[Helidon SE](https://helidon.io/)** — The lightweight option. Use Helidon SE for performant, lean backends where a small footprint and low startup time are important. + +Both are valid choices depending on the project requirements. We aim to provide Open Elements base libraries (as dependencies) for both frameworks in the future. + +### Libraries for Backend Frameworks + +When building libraries that target backend applications, provide support for Spring Boot and Helidon SE as primary targets. Additionally, offer support for [Eclipse MicroProfile](https://microprofile.io/) and [Eclipse Jakarta EE](https://jakarta.ee/) where feasible, to broaden compatibility. For concrete backend applications, we typically do not use MicroProfile or Jakarta EE directly. + +## REST APIs and OpenAPI + +- Every backend that exposes REST endpoints must include a Swagger UI for interactive API exploration. +- Use [SpringDoc OpenAPI](https://springdoc.org/) (for Spring Boot) or an equivalent library to generate the OpenAPI specification automatically from code. +- Document every endpoint completely with OpenAPI annotations: summary, description, request/response schemas, status codes, and error responses. +- Use meaningful operation IDs and group endpoints with tags. +- Configure authentication information in the OpenAPI specification so that users can authorize directly in the Swagger UI to test protected endpoints. Include the supported security schemes (e.g., Bearer token, OAuth2) and their configuration. +- Ensure the OpenAPI spec stays in sync with the actual implementation — generate it from code rather than maintaining a separate spec file. +- **IMPORTANT**: Never expose JPA entities directly in REST endpoints (neither as request nor as response objects). Always use dedicated **DTOs** (Data Transfer Objects) for the API layer. Map between entities and DTOs explicitly in the service or controller layer. This avoids leaking internal data model details, prevents lazy-loading and serialization issues, and decouples the API contract from the database schema. + +## Data Access and Database + +- **IMPORTANT**: Use **JPA** (Jakarta Persistence API) for data access. Do not use implementation-specific APIs (e.g., Hibernate session or criteria API directly) — always program against the JPA interfaces. +- Use **[Flyway](https://flywaydb.org/)** for database schema management and migrations in all projects with a database. +- **PostgreSQL** is the preferred database for test environments and production. +- **H2** (in-memory) is the preferred database for fast, automated unit/integration tests. In the future, we plan to replace H2 with [Testcontainers](https://www.testcontainers.org/)-based PostgreSQL to test against the same database in all environments. +- **IMPORTANT**: Database connection URLs, credentials, and other settings must be configurable via environment variables (see [fullstack-architecture.md](fullstack-architecture.md#configuration)). + +## Data Privacy and GDPR + +- **IMPORTANT**: All backend applications must be designed with GDPR (DSGVO) compliance in mind. +- Collect only personal data that is strictly necessary for the application's purpose (data minimization). +- Every piece of personal data must have a clear, documented legal basis for processing (e.g., consent, contract fulfillment, legitimate interest). +- Provide API endpoints for data subject rights: access (Art. 15), rectification (Art. 16), erasure (Art. 17), and data portability (Art. 20) where applicable. +- Personal data must be deletable — design database schemas so that user data can be fully removed without breaking referential integrity. +- Log access to personal data for audit purposes, but do not log the personal data itself. +- Do not store personal data in log files, error messages, or stack traces. +- Use encryption at rest and in transit for personal data. +- When integrating third-party services, verify that they are GDPR-compliant and document data processing agreements. + +## Observability + +- Every backend should expose **metrics** in Prometheus format for monitoring and alerting. +- Every backend should stream **logs** to Loki for centralized log aggregation and querying. +- Concrete implementation details for Spring Boot and Helidon SE are still being defined. diff --git a/.claude/conventions/documentation.md b/.claude/conventions/documentation.md new file mode 100644 index 00000000..e44a6ddc --- /dev/null +++ b/.claude/conventions/documentation.md @@ -0,0 +1,75 @@ +# Project Documentation Conventions for Claude Code + +## Overview + +We use [MkDocs](https://www.mkdocs.org/) with the [Material for MkDocs](https://squidfunnel.github.io/mkdocs-material/) theme to create and host technical documentation for projects. Documentation is stored in the repository alongside the code and published as GitHub Pages. + +A reference implementation is the [maven-initializer docs](https://github.com/support-and-care/maven-initializer/tree/main/docs). + +## Repository Structure + +``` +project-root/ +├── docs/ +│ ├── index.md # Landing page +│ ├── architecture.md # Architecture overview +│ ├── contributing.md # How to contribute to the docs +│ └── stylesheets/ # Custom CSS (optional) +└── mkdocs.yml # MkDocs configuration at repository root +``` + +## MkDocs Configuration + +The `mkdocs.yml` lives at the repository root and configures: + +- **Theme**: Material for MkDocs with light/dark mode toggle. +- **Navigation**: Explicit `nav` section defining the page hierarchy. +- **Extensions**: Markdown extensions for features like Mermaid diagrams (`pymdownx.superfences`). +- **Plugins**: At minimum the `search` plugin. + +## Markdown + +- Use GitHub Flavored Markdown (GFM) as the default syntax for all documentation — `README.md`, docs, ADRs, and any other prose in the repository. + +## Content Guidelines + +- Write documentation in plain Markdown inside the `docs/` folder. +- The `index.md` serves as the landing page with links to the main sections. +- Keep documentation close to the code — update docs when the related code changes. +- Use Mermaid diagrams for architecture and flow visualizations instead of external image files where possible. + +## Local Development + +To preview documentation locally: + +```bash +pip install mkdocs-material "pymdown-extensions" +mkdocs serve +``` + +The site is then available at `http://127.0.0.1:8000`. + +## GitHub Pages Deployment + +Documentation is deployed automatically via a GitHub Actions workflow (`.github/workflows/docs.yml`): + +- **Pushes to main**: Deploy to the production site root using `mkdocs gh-deploy --force`. +- **Pull requests**: Build a preview and deploy it to a `/pr//` subdirectory. The workflow comments on the PR with a link to the preview. + +### Requirements + +- GitHub Pages must be enabled on the repository with the source set to the `gh-pages` branch. +- The workflow needs `contents: write` and `pull-requests: write` permissions. + +## What to Document + +- Architecture overview (components, their responsibilities, how they interact). +- Architecture Decision Records for significant technical choices. +- Setup and contribution instructions. +- API documentation if the project exposes a public API. + +## What NOT to Document in MkDocs + +- User-facing README content — that stays in `README.md` at the repository root. +- Auto-generated API docs (Javadoc, TypeDoc) — those have their own tooling. +- Temporary notes or work-in-progress — use issues or discussions instead. diff --git a/.claude/conventions/editorconfig.md b/.claude/conventions/editorconfig.md new file mode 100644 index 00000000..45d0f170 --- /dev/null +++ b/.claude/conventions/editorconfig.md @@ -0,0 +1,67 @@ +# EditorConfig Conventions for Claude Code + +## Overview + +Every repository should include a `.editorconfig` file at the root to enforce consistent formatting across all editors and IDEs. EditorConfig is supported natively by IntelliJ IDEA, VS Code, and most other editors. + +See [editorconfig.org](https://editorconfig.org/) for the specification. + +## Standard `.editorconfig` + +The following configuration is the Open Elements standard. It is based on conventions from Google, JetBrains, Angular, and the broader Java/TypeScript community. + +```ini +root = true + +[*] +charset = utf-8 +end_of_line = lf +indent_style = space +indent_size = 4 +trim_trailing_whitespace = true +insert_final_newline = true + +[*.java] +max_line_length = 120 +ij_java_class_count_to_use_import_on_demand = 9999 +ij_java_names_count_to_use_import_on_demand = 9999 +ij_java_use_single_class_imports = true +ij_java_layout_static_imports_separately = true +ij_java_block_brace_style = end_of_line +ij_java_class_brace_style = end_of_line +ij_java_method_brace_style = end_of_line +ij_java_lambda_brace_style = end_of_line +ij_java_if_brace_force = always +ij_java_for_brace_force = always +ij_java_while_brace_force = always +ij_java_do_while_brace_force = always + +[*.{ts,tsx,js,jsx,json,css,scss,html}] +indent_size = 2 + +[*.{yml,yaml}] +indent_size = 2 + +[*.md] +trim_trailing_whitespace = false + +[*.xml] +indent_size = 4 + +[{Dockerfile,Dockerfile.*}] +indent_style = space +indent_size = 4 +``` + +## Key Decisions + +- **4 spaces for Java and XML** — industry standard for Maven-based projects. +- **2 spaces for TypeScript/JavaScript, YAML, and JSON** — matches the React/Next.js/Angular ecosystem. +- **LF line endings** — consistent across macOS, Linux, and CI environments. +- **No wildcard imports in Java** — enforced via IntelliJ `ij_java_` properties (threshold set to 9999). +- **Braces always required** for `if`, `for`, `while`, `do-while` in Java — prevents single-line body bugs. +- **Markdown exempt from trailing whitespace trimming** — trailing spaces are significant in Markdown (line breaks). + +## Usage + +Copy the `.editorconfig` content above into the root of your repository. It will be picked up automatically by supported editors. diff --git a/.claude/conventions/fullstack-architecture.md b/.claude/conventions/fullstack-architecture.md new file mode 100644 index 00000000..118f2933 --- /dev/null +++ b/.claude/conventions/fullstack-architecture.md @@ -0,0 +1,179 @@ +# Fullstack Architecture Conventions for Claude Code + +## Overview + +In Open Elements projects that have both a frontend and a backend, +both parts are treated as fully independent applications within a single repository. +They share no code, no build process, and no runtime. +The only coupling is at the network level through APIs. + +A reference implementation of this architecture is [maven-initializer](https://github.com/support-and-care/maven-initializer). + +## Repository Structure + +``` +project-root/ +├── backend/ # Independent backend application +│ ├── Dockerfile # Standalone container build +│ ├── src/ # Backend source code +│ └── ... # Backend build files (pom.xml, build.gradle, etc.) +├── frontend/ # Independent frontend application +│ ├── Dockerfile # Standalone container build +│ ├── src/ # Frontend source code +│ └── ... # Frontend build files (package.json, etc.) +├── docker-compose.yml # Orchestration for local development and deployment +└── README.md +``` + +## Core Principles + +- **IMPORTANT — Full independence**: Backend and frontend are separate applications. Each has its own source code, dependencies, build process, and configuration. There are no shared modules, monorepo tooling, or cross-references between them. +- **Separate containers**: Each application has its own `Dockerfile` in its directory. Each container can be built and run independently. +- **Docker Compose for orchestration**: A `docker-compose.yml` at the repository root wires the containers together. It handles port mapping, environment variables (like `BACKEND_URL` for the frontend), and startup ordering. +- **Independent local development**: Each application can be started on its own for development without Docker. The backend and frontend each have their own dev server and can be run in separate terminals. + +## Docker + +### Dockerfiles + +Each application has a multi-stage `Dockerfile` in its own directory: + +- **Backend (Java/Spring Boot)**: Build stage compiles with Maven/Gradle, runtime stage uses a minimal JRE image. +- **Frontend (TypeScript/Next.js)**: Build stage installs dependencies and compiles, runtime stage serves the built application with a minimal Node.js image. **IMPORTANT**: The backend is not available during `next build` in the Docker build stage. Pages that fetch data from the backend must not be statically pre-rendered at build time, or they will cache an error state. Use `dynamic = 'force-dynamic'` or equivalent mechanisms to ensure these pages are rendered at request time. + +Both Dockerfiles should: + +- Use multi-stage builds to keep the final image small. +- Pin base image versions (e.g., `eclipse-temurin:21-alpine`, `node:22-alpine`). **IMPORTANT**: The Java version in the Docker base image must match the Java version in the project's `pom.xml` (`` / ``) and must be supported by the framework in use (e.g., Spring Boot). Check the framework's documentation for supported Java versions before choosing a version. Use the same Java version consistently across `.sdkmanrc`, `pom.xml`, and Dockerfile. +- Run the application as a non-root user in the final stage. +- Expose only the application port. +- **IMPORTANT**: Every `COPY` instruction in a Dockerfile must reference files or directories that are guaranteed to exist. Do not use shell-style workarounds like `2>/dev/null || true` — these do not work in Dockerfile `COPY` instructions and will cause build failures. For the Next.js frontend, ensure a `public/` directory exists in the project (at minimum with a `favicon.ico` or an empty `.gitkeep` file). +- **IMPORTANT**: Every application directory that has a `Dockerfile` must also have a `.dockerignore` file to exclude build artifacts and dependencies from the Docker context. Without it, the Docker context can be hundreds of MB and builds will be slow. + + **Backend `.dockerignore`:** + ``` + target/ + .idea/ + *.iml + .git + ``` + + **Frontend `.dockerignore`:** + ``` + node_modules/ + .next/ + .idea/ + .git + ``` + +### Docker Compose + +The `docker-compose.yml` at the repository root: + +- Defines one service per application (`backend`, `frontend`). +- Uses `build` with the application directory as context. +- Maps internal ports to configurable external ports via environment variables with defaults. +- Sets environment variables to connect services (e.g., `BACKEND_URL` on the frontend). +- Uses `depends_on` to define startup order where needed. + +Example structure: + +```yaml +services: + db: + image: postgres:17-alpine + environment: + POSTGRES_DB: ${DB_NAME} + POSTGRES_USER: ${DB_USER} + POSTGRES_PASSWORD: ${DB_PASSWORD} + ports: + - "${DB_PORT:-5432}:5432" + + backend: + build: ./backend + environment: + SPRING_DATASOURCE_URL: jdbc:postgresql://db:5432/${DB_NAME} + SPRING_DATASOURCE_USERNAME: ${DB_USER} + SPRING_DATASOURCE_PASSWORD: ${DB_PASSWORD} + ports: + - "${BACKEND_PORT:-9081}:8080" + depends_on: + - db + + frontend: + build: ./frontend + environment: + - BACKEND_URL=http://backend:8080 + ports: + - "${FRONTEND_PORT:-4001}:3000" + depends_on: + - backend +``` + +The corresponding `.env.example` should contain: + +```env +DB_NAME=appdb +DB_USER=appuser +DB_PASSWORD=changeme +BACKEND_PORT=9081 +FRONTEND_PORT=4001 +``` + +### Common Docker Compose Commands + +Document the following commands in the project README: + +- **Start with rebuild**: `docker-compose up --build` — Always use `--build` to ensure code changes are reflected in the containers. Without this flag, Docker Compose reuses cached images and changes are not visible. +- **Stop**: `docker-compose down` — Stops and removes containers. +- **Stop and remove volumes**: `docker-compose down -v` — Also removes persistent data (databases, etc.). + +## Communication Between Frontend and Backend + +- The frontend communicates with the backend exclusively through HTTP APIs. +- **IMPORTANT**: The frontend application must never call the backend directly from the browser. Instead, route all API calls through the frontend's server-side layer. This avoids CORS issues and prevents exposing internal backend URLs to the client. Note: the backend's Swagger UI is accessed directly by developers for API exploration — this rule applies to the frontend application's API communication only. +- **For Next.js**: Use [Next.js Rewrites](https://nextjs.org/docs/app/api-reference/config/next-config-js/rewrites) in `next.config.ts` to proxy API requests to the backend. **IMPORTANT**: The rewrite destination must use the `BACKEND_URL` environment variable — never hardcode `localhost`. In Docker Compose, `BACKEND_URL` is `http://backend:8080` (the Docker service name). In local development, it is `http://localhost:8080` (or whatever port the backend runs on). + + Example `next.config.ts` rewrite: + ```typescript + async rewrites() { + return [ + { + source: '/api/:path*', + destination: `${process.env.BACKEND_URL}/api/:path*`, + }, + ]; + } + ``` + + With this setup, frontend code fetches from its own origin (e.g., `fetch('/api/status')`) and Next.js proxies the request server-side to the backend. +- In Docker Compose, the frontend server-side proxy reaches the backend via the Docker service name (e.g., `http://backend:8080`). The browser only communicates with the frontend container. +- In local development, the frontend proxy connects to the backend via `localhost` and the backend's dev port. Set `BACKEND_URL=http://localhost:8080` in the frontend's `.env` or start script. +- Do not configure CORS on the backend to allow frontend origins as a workaround — use the proxy approach instead. +- API contracts should be clearly defined. Changes to the API should be coordinated between frontend and backend. + +## Pinned Tool Versions + +Pin exact versions of runtimes and build tools in the repository so that every developer and CI environment uses the same versions. + +- **Java**: Use a `.sdkmanrc` file in the backend directory to pin the Java version (e.g., `java=21`). Developers activate it with `sdk env install`. The pinned version must be compatible with the framework in use — check the framework's supported Java versions. +- **Node.js**: Use a `.nvmrc` file in the frontend directory to pin the Node.js version (e.g., `v22.19.0`). Developers activate it with `nvm install`. +- **Build tool wrappers**: Use the Maven Wrapper (`mvnw`) or Gradle Wrapper (`gradlew`) so the build tool version is committed to the repository and does not need to be installed separately. +- Do not rely on globally installed tool versions. The repository must define everything needed to build and run. + +## Configuration + +- **IMPORTANT**: Both frontend and backend must be configurable via environment variables. All environment-specific values (database URLs, API keys, feature flags, external service URLs) must be read from environment variables — never hardcoded. +- For local development, use a `.env` file at the repository root (or per application directory) to define environment variables. Docker Compose loads `.env` files automatically. +- Add `.env` to `.gitignore`. Provide a `.env.example` file with all required variables and sensible defaults or placeholder values as documentation. +- When setting up a project, copy `.env.example` to `.env` if no `.env` file exists yet. This ensures the project is immediately runnable. Document this step in the README. +- In hosted environments (Coolify, cloud platforms, CI/CD), set environment variables directly in the platform configuration instead of using `.env` files. +- Design configuration so that the same container image can run in any environment (local, test, production) — only the environment variables change. + +## What to Avoid + +- **IMPORTANT**: Do not share code between frontend and backend (no shared `lib/` or common modules). +- Do not create a single Dockerfile that builds both applications. +- Do not use monorepo tools (Nx, Turborepo) to couple the build processes. +- **IMPORTANT**: Do not hardcode ports or URLs — use environment variables with sensible defaults. +- **IMPORTANT**: Never hardcode credentials (passwords, usernames, API keys) directly in `docker-compose.yml` or any other checked-in file. Use environment variable references (`${DB_PASSWORD}`) and define the values in `.env` (which is gitignored). The `.env.example` file should contain only placeholder values (e.g., `DB_PASSWORD=changeme`). diff --git a/.claude/conventions/github-actions.md b/.claude/conventions/github-actions.md new file mode 100644 index 00000000..643be1a0 --- /dev/null +++ b/.claude/conventions/github-actions.md @@ -0,0 +1,275 @@ +# GitHub Actions CI/CD + +This document defines GitHub Actions workflow conventions for Open Elements projects. Every project must have CI that builds and tests on every push and pull request to `main`. + +## General Rules + +- Workflows live in `.github/workflows/` +- Trigger on `push` and `pull_request` to `main` +- Fail fast: run formatting/linting checks before compilation and tests +- Pin action versions (e.g., `actions/checkout@v6`, not `actions/checkout@latest`) +- Use caching where available (Maven, pnpm, pip) to speed up builds + +## Build Workflow (`build.yml`) + +The build workflow is the core CI pipeline. Its structure depends on the project type. + +### Java Library / Backend + +```yaml +name: CI/CD Pipeline + +on: + push: + branches: [main] + pull_request: + branches: [main] + +jobs: + backend: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v6 + - uses: actions/setup-java@v5 + with: + java-version: "25" + distribution: "temurin" + - run: | + ./mvnw spotless:check + ./mvnw clean verify +``` + +Key points: +- Use the Maven Wrapper (`./mvnw`), not a globally installed Maven +- Run formatting check (`spotless:check`) before `clean verify` +- `verify` includes compilation, tests, and any configured plugins (SBOM, etc.) +- Adapt `java-version` to match the project's `.sdkmanrc` + +### TypeScript Frontend / Library + +```yaml +name: CI/CD Pipeline + +on: + push: + branches: [main] + pull_request: + branches: [main] + +jobs: + frontend: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v6 + - uses: pnpm/action-setup@v4 + with: + version: 10 + - uses: actions/setup-node@v6 + with: + node-version: "24" + cache: "pnpm" + - run: | + pnpm install --frozen-lockfile + pnpm run format:check + pnpm run test + pnpm run build +``` + +Key points: +- Use `pnpm/action-setup` for pnpm projects +- Cache pnpm store via `actions/setup-node` cache option +- Use `--frozen-lockfile` in CI to ensure reproducible builds +- Run format check and tests before build +- Adapt `node-version` to match the project's `.nvmrc` + +### Fullstack Application + +For fullstack projects with separate `backend/` and `frontend/` directories, run both in parallel and add a Docker verification step: + +```yaml +name: CI/CD Pipeline + +on: + push: + branches: [main] + pull_request: + branches: [main] + +jobs: + backend: + runs-on: ubuntu-latest + defaults: + run: + working-directory: backend + steps: + - uses: actions/checkout@v6 + - uses: actions/setup-java@v5 + with: + java-version: "25" + distribution: "temurin" + - run: | + ./mvnw spotless:check + ./mvnw clean verify + + frontend: + runs-on: ubuntu-latest + defaults: + run: + working-directory: frontend + steps: + - uses: actions/checkout@v6 + - uses: pnpm/action-setup@v4 + with: + version: 10 + - uses: actions/setup-node@v6 + with: + node-version: "24" + cache: "pnpm" + cache-dependency-path: "frontend/pnpm-lock.yaml" + - run: | + pnpm install --frozen-lockfile + pnpm run format:check + pnpm run test + pnpm run build + + docker: + runs-on: ubuntu-latest + needs: [backend, frontend] + steps: + - uses: actions/checkout@v6 + - name: Build backend Docker image + run: docker build -t app-backend ./backend + - name: Build frontend Docker image + run: docker build -t app-frontend ./frontend + - name: Test Docker Compose + run: docker compose build +``` + +Key points: +- Use `defaults.run.working-directory` for monorepo sub-directories +- Backend and frontend jobs run in parallel +- Docker job runs after both succeed (`needs: [backend, frontend]`) +- Set `cache-dependency-path` when the lockfile is not in the repo root + +## Documentation Workflow (`docs.yml`) + +For projects using MkDocs with Material theme (see [documentation.md](documentation.md)): + +```yaml +name: Docs + +on: + push: + branches: [main] + paths: + - "docs/**" + - "mkdocs.yml" + - ".github/workflows/docs.yml" + pull_request: + branches: [main] + paths: + - "docs/**" + - "mkdocs.yml" + - ".github/workflows/docs.yml" + +permissions: + contents: write + pull-requests: write + +concurrency: + group: "pages-${{ github.ref }}" + cancel-in-progress: true + +jobs: + deploy-production: + if: github.event_name == 'push' && github.ref == 'refs/heads/main' + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v6 + - name: Configure Git Credentials + run: | + git config user.name github-actions[bot] + git config user.email 41898282+github-actions[bot]@users.noreply.github.com + - uses: actions/setup-python@v6 + with: + python-version: "3.x" + - uses: actions/cache@v5 + with: + key: mkdocs-material-${{ hashFiles('mkdocs.yml') }} + path: ~/.cache + restore-keys: mkdocs-material- + - run: pip install mkdocs-material "pymdown-extensions" + - run: mkdocs gh-deploy --force + + deploy-preview: + if: github.event_name == 'pull_request' + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v6 + - name: Configure Git Credentials + run: | + git config user.name github-actions[bot] + git config user.email 41898282+github-actions[bot]@users.noreply.github.com + - uses: actions/setup-python@v6 + with: + python-version: "3.x" + - uses: actions/cache@v5 + with: + key: mkdocs-material-${{ hashFiles('mkdocs.yml') }} + path: ~/.cache + restore-keys: mkdocs-material- + - run: pip install mkdocs-material "pymdown-extensions" + - run: mkdocs build --strict + - uses: peaceiris/actions-gh-pages@v4 + with: + github_token: ${{ secrets.GITHUB_TOKEN }} + publish_dir: ./site + destination_dir: "pr/${{ github.event.pull_request.number }}" + keep_files: true + - name: Comment PR with preview URL + uses: actions/github-script@v8 + with: + script: | + const owner = context.repo.owner; + const repo = context.repo.repo; + const prNumber = context.issue.number; + const url = `https://${owner}.github.io/${repo}/pr/${prNumber}/`; + github.rest.issues.createComment({ + issue_number: prNumber, owner, repo, + body: `Docs preview for this PR: ${url}` + }); +``` + +Key points: +- Only trigger on changes to `docs/`, `mkdocs.yml`, or the workflow itself (`paths` filter) +- Use `concurrency` to cancel outdated deployments +- Production deploys on push to main, PR previews on pull requests +- PR previews go to `/pr//` subdirectory and post a comment with the URL + +## Release Drafter (`release-drafter.yml`) + +Automatically maintains a draft release based on merged PRs: + +```yaml +name: Release Drafter + +on: + push: + branches: [main] + pull_request: + types: [closed] + +jobs: + update_release_draft: + if: github.event_name != 'pull_request' || github.event.pull_request.merged == true + runs-on: ubuntu-latest + permissions: + contents: write + pull-requests: read + steps: + - uses: release-drafter/release-drafter@v6 + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} +``` + +This requires a `.github/release-drafter.yml` configuration file in the repository. See the [release-drafter documentation](https://github.com/release-drafter/release-drafter) for template configuration. diff --git a/.claude/conventions/java.md b/.claude/conventions/java.md new file mode 100644 index 00000000..20deb7fc --- /dev/null +++ b/.claude/conventions/java.md @@ -0,0 +1,141 @@ +# Java Conventions for Claude Code + +## Common Commands + +These are the typical commands for Maven-based Java projects. Always use the Maven Wrapper (`./mvnw`) when available. + +- **Build**: `./mvnw clean verify` +- **Run tests**: `./mvnw test` +- **Run a single test class**: `./mvnw test -Dtest=com.example.MyTestClass` +- **Run a single test method**: `./mvnw test -Dtest=com.example.MyTestClass#myTestMethod` +- **Skip tests during build**: `./mvnw clean package -DskipTests` +- **Check for dependency updates**: `./mvnw versions:display-dependency-updates` +- **Generate Javadoc**: `./mvnw javadoc:javadoc` + +## Code Style + +Formatting rules (indentation, charset, line endings) are defined in `.editorconfig` — see [editorconfig.md](editorconfig.md). + +- **IMPORTANT**: Do not use wildcard imports (`import java.util.*`). Always use explicit imports. +- **IMPORTANT**:Prefer `final` fields and local variables where possible. +- Use `final` on method parameters when the method body does not reassign them. +- Prefer records for immutable data carriers. Use classes with `final` fields and getters for types that mix mutable and + immutable state. +- Do not use `var` +- Follow standard Java naming: `PascalCase` for classes, `camelCase` for methods/fields, `UPPER_SNAKE_CASE` for + constants. +- **IMPORTANT**: Do not use Lombok. Use modern Java features (records, pattern matching) instead. +- Always override `equals`, `hashCode`, and `toString` together for non-record classes. Use `Objects.equals()` and + `Objects.hash()` as helpers. +- Format `toString` as `ClassName[field1=value1, field2=value2]`. **IMPORTANT**: Never expose sensitive data (passwords, tokens) in `toString`. +- **IMPORTANT**: All public API (public classes, interfaces, methods, constructors, and fields) must have Javadoc comments. + +## Build Tools + +- Respect the existing build tool (Maven or Gradle) — do not switch without explicit instruction. +- We always prefer Maven over Gradle. +- **IMPORTANT**: Before choosing a Java version for a new project, verify that the framework (Spring Boot, Helidon, etc.) and all major dependencies support that version. Use the latest Java LTS version that is fully supported by the framework. The Java version must be consistent across `pom.xml` (`` / ``), `.sdkmanrc`, and Docker base images. +- When adding dependencies, use the dependency management section (Maven `` or Gradle version + catalog) if one exists. +- Do not add dependencies that duplicate functionality already available in the project. +- **IMPORTANT**: Every new Maven project or module must include the [CycloneDX Maven Plugin](https://github.com/CycloneDX/cyclonedx-maven-plugin) (`org.cyclonedx:cyclonedx-maven-plugin`) in its `` section for SBOM generation. +- Always use meaningful dependency scopes. + Use `compile`, `provided`, `runtime` or `test` whenever it makes sense. + +### Pinning Default Maven Plugin Versions + +- **IMPORTANT**: Every new Maven project must explicitly define versions for all default lifecycle plugins in `` to ensure reproducible builds across all systems. +- Pin at least the following plugins (always use the latest stable version of each): + - `maven-clean-plugin` + - `maven-compiler-plugin` + - `maven-resources-plugin` + - `maven-surefire-plugin` + - `maven-jar-plugin` + - `maven-install-plugin` + - `maven-deploy-plugin` +- When reviewing or setting up an existing project, check that these plugins have explicit versions and update them to the latest stable release if they are outdated. + +## Testing + +- Use JUnit 5 (`org.junit.jupiter`) for tests. +- Use AssertJ for assertions (`org.assertj.core.api.Assertions`). +- Name test methods descriptively: `shouldReturnEmptyListWhenNoItemsExist()` or use `@DisplayName`. +- Use `@Nested` classes to group related tests within a test class. +- Use `@ParameterizedTest` for testing multiple inputs with the same logic. +- Use `//GIVEN //WHEN //THEN` comments to structure test methods. +- Test one behavior per test method. Provide meaningful assertion messages. +- Test edge cases: null values, empty collections, boundary values, and expected exceptions. +- Keep tests independent and fast — each test should run in milliseconds without depending on other tests. +- **IMPORTANT**: Avoid excessive mocking. Excessive mocking is often a sign that APIs have too many dependencies or are poorly designed. Prefer simple dummy/stub implementations of interfaces for test dependencies instead if possible. Use mocking when the dependency is a concrete or final class that cannot be substituted otherwise or the complexity becomes too big. + +## Logging + +- Use SLF4J as the logging API (`org.slf4j.Logger`). +- For libraries and low-level code, prefer `java.lang.System.Logger` to avoid external logging dependencies and let consumers choose their own logging backend. +- Use parameterized logging — never string concatenation. For SLF4J: `log.info("Processing item {}", itemId)`. For System.Logger: `logger.log(Level.INFO, "Processing item {0}", itemId)`. +- For expensive log message construction, use `Supplier` or guard with `logger.isLoggable(level)` to avoid unnecessary computation. +- Log at appropriate levels: `ERROR` for failures that need attention, `WARN` for recoverable issues, `INFO` for significant events, `DEBUG` for development details. + +## Null Handling + +- Prefer `Optional` for return types that may have no value. Do not use `Optional` as a method parameter, constructor parameter, or field type — use `@Nullable` annotations instead. +- Prefer `Optional.ofNullable(value)` when nullability is uncertain. Use `Optional.of(value)` only when the value is guaranteed non-null. +- Annotate parameters and fields with `@Nullable` or `@NonNull` (using `org.jspecify` when available) to make intent explicit. +- Use `Objects.requireNonNull(param, "paramName must not be null")` for early validation of non-null parameters — always include the parameter name in the message. +- **IMPORTANT**: Never return `null` from a method that returns a collection — return an empty collection instead. + +## Collections + +- Always copy incoming collections before storing them to avoid external mutation (`List.copyOf()`, `Set.copyOf()`, + `Map.copyOf()`). +- Return unmodifiable collections from public API methods. +- Use thread-safe backing types (`CopyOnWriteArrayList`, `ConcurrentHashMap`) when collections may be accessed from + multiple threads. + +## Immutability and Validation + +- **IMPORTANT**: Prefer immutable objects. Use records for fully immutable types. +- Validate constructor and setter arguments early. Throw `IllegalArgumentException` for constraint violations (min/max + values, string length, patterns). +- Use `java.time` types (`Instant`, `LocalDate`, `Duration`, etc.) for all date and time handling — never + `java.util.Date` or `java.util.Calendar`. +- Use `BigDecimal` for precise decimal values (financial calculations, etc.) — never `float` or `double`. + +## Factory Methods + +- Prefer static factory methods on the type itself over separate factory classes (e.g., `Money.of(amount, currency)` + instead of `MoneyFactory.create()`). +- Name factory methods descriptively: `of`, `from`, `create`, `valueOf`. + +## Builder Pattern + +- Use the builder pattern for classes with more than 4–5 constructor parameters, multiple optional parameters, or confusing parameter ordering. +- Provide a static `builder()` factory method. All builder setter methods return `this` for a fluent interface. +- Make the builder a `static final` nested class within the product class. +- Set default values in builder field declarations, not in the `build()` method. +- Perform validation in the main class constructor, not in builder setter methods. Perform null checks on required parameters in builder setters. +- Always provide a public all-args constructor alongside the builder for direct instantiation. +- Builders are not thread-safe — each thread needs its own builder instance. + +## Java Module System + +- Use the Java Platform Module System (JPMS) for standalone libraries whenever possible. Define a `module-info.java` that exports only the public API packages and keeps implementation packages hidden. +- **IMPORTANT**: Only export packages that contain the public API. Internal and implementation packages should not be exported. +- Use `requires` to declare module dependencies explicitly rather than relying on the classpath. +- Use `requires static` for compile-time only dependencies (annotation libraries, code generators). +- Structure packages to separate API from implementation (e.g., `com.example.mylib/` for public API, `com.example.mylib.impl/` for internals), even in projects that do not use JPMS. +- Some frameworks (e.g., Spring Boot) have limited JPMS support. In those projects, skip module-info if it causes friction — but still follow the package structure convention above. + +## Service Provider Interface (SPI) + +- Use the Java SPI (`java.util.ServiceLoader`) for extensibility points where implementations should be discovered at runtime. +- In modular projects, declare providers in `module-info.java` with `provides ... with ...`. +- In classpath-based projects, use `@com.google.auto.service.AutoService` to generate `META-INF/services` files automatically via annotation processor. + Dependency for the annotation is `com.google.auto.service:auto-service`. + Annotation processor to support it must be configured in the build tool. +- When a library must support both modular and classpath consumers, provide both the `module-info.java` declaration and the AutoService annotation. + +## Asynchronous Code + +- Use `CompletionStage` or `CompletableFuture` for asynchronous return types. +- When providing async methods, consider offering synchronous alternatives that accept a timeout with `TimeUnit`. diff --git a/.claude/conventions/project-specific/README.md b/.claude/conventions/project-specific/README.md new file mode 100644 index 00000000..0cda6148 --- /dev/null +++ b/.claude/conventions/project-specific/README.md @@ -0,0 +1,21 @@ +# Project-Specific Documentation + +This directory contains project-specific documentation that gives Claude Code persistent context about the project. The files here are maintained per project and are not overwritten by `update-claude-base`. + +## Standard Project Files + +These files describe the project so that Claude Code understands the context when working on any change. Use `/project-analyze` to generate or update them automatically. + +- [Project Features](project-features.md) — What the product does, its core features and user-facing capabilities +- [Project Tech Stack](project-tech.md) — Languages, frameworks, libraries, databases, and external services used +- [Project Structure](project-structure.md) — Repository layout, directory structure, and where to find what +- [Project Architecture](project-architecture.md) — Technical architecture, component interactions, and data flow + +## Additional Project Docs + +Add further project-specific documentation here as needed, for example: + +- Authentication and authorization setup +- Deployment process and environments +- Third-party integrations +- Domain-specific conventions diff --git a/.claude/conventions/project-specific/project-architecture.md b/.claude/conventions/project-specific/project-architecture.md new file mode 100644 index 00000000..ccb2a6b4 --- /dev/null +++ b/.claude/conventions/project-specific/project-architecture.md @@ -0,0 +1,84 @@ +# Project Architecture + + + +## Overview + +The Open Elements website is a bilingual (EN/DE) static site built with Hugo, styled with Tailwind CSS, and enhanced with a React component for interactive content. It is deployed on Netlify as two separate sites. + +## Components + +- **Hugo (Static Site Generator)** — Renders Markdown content and HTML templates into a static website. Handles i18n, navigation, and page routing. +- **Tailwind CSS** — Utility-first CSS framework with custom theme (brand colors, shadows, typography). Compiled from `input.css`. +- **React (Interactive UI)** — Single React component (`react-src/maven-prs.tsx`) for the Maven PR dashboard. Bundled with esbuild to an IIFE in `static/js/`. +- **Netlify (Hosting/CD)** — Builds and serves the site. Two deployments: `open-elements-en` (open-elements.com) and `open-elements-de` (open-elements.de). + +## Content & Data Flow + +``` +content/*.md (Markdown) ─┐ +data/*.json (Structured) ─┼─→ Hugo ─→ public/ (Static HTML) ─→ Netlify CDN +layouts/*.html (Templates) ─┤ +i18n/*.toml (Translations) ─┘ +``` + +- **Markdown content** (`content/`) provides page bodies (blog posts, articles, service pages). +- **JSON data** (`data/`) provides structured information (team members, navigation, partners, engagements). +- **Translation strings** (`i18n/`) provide UI labels in English and German. +- **Templates** (`layouts/`) combine content, data, and translations into HTML pages. + +## Build Pipeline + +``` +input.css ─→ Tailwind CLI ─→ assets/css/style.css +react-src/ ─→ esbuild ─→ static/js/maven-prs.js +content/ + layouts/ + data/ ─→ Hugo ─→ public/ +``` + +All three steps run in parallel during development (`npm run dev`) and sequentially for production builds (`npm run netlify:build`). + +## Architecture Diagram + +```mermaid +graph TD + subgraph Content Layer + MD[Markdown Files] + JSON[JSON Data Files] + I18N[i18n TOML] + end + + subgraph Build Layer + Hugo[Hugo SSG] + Tailwind[Tailwind CSS] + ESBuild[esbuild] + end + + subgraph Output + Public[public/ Static Site] + end + + subgraph Hosting + Netlify[Netlify CDN] + end + + subgraph External + API[open-elements-open-data API] + end + + MD --> Hugo + JSON --> Hugo + I18N --> Hugo + Tailwind --> Hugo + ESBuild --> Hugo + Hugo --> Public + Public --> Netlify + API -.->|fetched client-side| Netlify +``` + +## Key Architectural Decisions + +- **Hugo over JS-based SSGs** — Chosen for fast build times and simplicity for a content-heavy site. +- **React only where needed** — A single React component is used for the interactive Maven PR dashboard; the rest is server-rendered HTML. +- **File-based content** — No CMS. Content is managed as Markdown files and JSON data in the repository. +- **Bilingual via Hugo i18n** — English and German are handled through Hugo's native language support with separate data directories and translation files. +- **Netlify dual-site deployment** — Separate builds for `.com` (EN) and `.de` (DE) with different base URLs. \ No newline at end of file diff --git a/.claude/conventions/project-specific/project-features.md b/.claude/conventions/project-specific/project-features.md new file mode 100644 index 00000000..a6afe1bf --- /dev/null +++ b/.claude/conventions/project-specific/project-features.md @@ -0,0 +1,12 @@ +# Project Features + + + + + + + + + + + diff --git a/.claude/conventions/project-specific/project-structure.md b/.claude/conventions/project-specific/project-structure.md new file mode 100644 index 00000000..7c3c2de9 --- /dev/null +++ b/.claude/conventions/project-specific/project-structure.md @@ -0,0 +1,25 @@ +# Project Structure + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/.claude/conventions/project-specific/project-tech.md b/.claude/conventions/project-specific/project-tech.md new file mode 100644 index 00000000..45a109bc --- /dev/null +++ b/.claude/conventions/project-specific/project-tech.md @@ -0,0 +1,25 @@ +# Project Tech Stack + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/.claude/conventions/repo-setup.md b/.claude/conventions/repo-setup.md new file mode 100644 index 00000000..e91a4d1b --- /dev/null +++ b/.claude/conventions/repo-setup.md @@ -0,0 +1,80 @@ +# Repository Setup Conventions for Claude Code + +## Overview + +Every Open Elements repository must contain a set of standard files that provide project information, legal clarity, and community guidelines. Most of our work is open source, and these files ensure a consistent and professional appearance across all repositories. + +## Required Root Files + +### `README.md` + +Every repository must have a `README.md` at the root. Its content depends on the type of project: + +**All projects must include:** + +- What the repository contains and what the project does. +- The current status of the project (e.g., stable, beta, experimental). +- **Prerequisites** — List all required tools with minimum versions (e.g., Java 21, Node.js 20, pnpm 9). Also list recommended tools for managing versions (e.g., [SDKMAN!](https://sdkman.io/) for Java, [nvm](https://github.com/nvm-sh/nvm) for Node.js). Reference `.sdkmanrc` or `.nvmrc` files if the project provides them. +- How to build the project from source. + +**Libraries must additionally include:** + +- How to add the library as a dependency (Maven coordinates, npm package name, etc.) for the latest version. +- A basic usage example or link to API documentation. + +**Applications (backend, frontend, or fullstack) must additionally include:** + +- How to install, deploy, and start the application. +- Required services (e.g., PostgreSQL, Redis) and how to set them up locally. +- How to run with Docker / Docker Compose if applicable, including the `--build` flag for rebuilding after code changes. + +### `LICENSE` + +Every repository must contain a `LICENSE` file. The preferred license for Open Elements projects is **Apache License 2.0**. + +A reference file is available at [hiero-enterprise-java/LICENSE](https://github.com/OpenElements/hiero-enterprise-java/blob/main/LICENSE). + +### `CODE_OF_CONDUCT.md` + +Every repository must include the Open Elements Code of Conduct, based on the [Contributor Covenant 2.0](https://www.contributor-covenant.org/). The file is available at [OpenElements/.github/CODE_OF_CONDUCT.md](https://github.com/OpenElements/.github/blob/main/CODE_OF_CONDUCT.md). + +The Code of Conduct is released under the **CC BY 4.0** license. + +### `CONTRIBUTING.md` (planned) + +A contributing guide will be added as a standard file in every repository. This is not yet finalized. + +### `.gitignore` + +Every repository must have a `.gitignore` that excludes at minimum: + +- `.env` — local environment configuration with secrets +- `.idea/` — IntelliJ IDEA project files +- `target/` — Maven build output +- `node_modules/` — npm/pnpm/yarn downloaded dependencies +- `.next/` — Next.js build output +- `*.log` — log files + +Add further entries as needed for the project's tooling. Do not commit IDE settings, build artifacts, or downloaded dependencies. + +### `.editorconfig` + +Every repository must include an `.editorconfig` file at the root to enforce consistent formatting (indentation, charset, line endings) across all editors. See [editorconfig.md](editorconfig.md) for the standard configuration. + +## Organization-Level Defaults via `.github` Repository + +GitHub supports a special `.github` repository within an organization. Community health files placed there (e.g., `CODE_OF_CONDUCT.md`, `CONTRIBUTING.md`) automatically apply to all repositories in the organization that do not have their own version of that file. Open Elements uses this mechanism at [OpenElements/.github](https://github.com/OpenElements/.github). + +If a file is already provided by the `.github` repository, it does not need to be duplicated in individual repositories. Only add a repo-level override if the project needs to deviate from the organization default. + +## Summary + +``` +project-root/ +├── .editorconfig # Formatting rules (indentation, charset, line endings) +├── .gitignore # Excludes .env, .idea/, target/, node_modules/, etc. +├── CODE_OF_CONDUCT.md # Open Elements CoC (Contributor Covenant 2.0, CC BY 4.0) +├── CONTRIBUTING.md # Contributing guide (planned) +├── LICENSE # Apache License 2.0 +└── README.md # Project description, status, build & usage instructions +``` diff --git a/.claude/conventions/security.md b/.claude/conventions/security.md new file mode 100644 index 00000000..4f548a6e --- /dev/null +++ b/.claude/conventions/security.md @@ -0,0 +1,160 @@ +# Security Configuration for Claude Code + +This document defines security rules and configurations for using Claude Code in Open Elements projects. The goal is to ensure Claude Code operates safely within the project boundary and never accesses or modifies sensitive data without explicit developer consent. + +## Core Principles + +- **Project boundary is sacred** — Claude Code must never modify files outside the project directory without explicit user confirmation. +- **No silent reads outside the project** — Files outside the project directory must not be read unless the developer explicitly asks for it or grants access. +- **Deny by default for sensitive paths** — Access to credentials, keys, and personal configuration is blocked by deny rules. +- **Layered defense** — Combine permission rules, sandbox mode, and hooks for defense in depth. + +## Permission Configuration + +Add these rules to `.claude/settings.json` (shared, committed to the repository) or `.claude/settings.local.json` (personal, gitignored). + +### Recommended Deny Rules + +Block access to credentials and sensitive configuration. These rules apply to all developers on the project: + +```json +{ + "permissions": { + "deny": [ + "Read(~/.ssh/**)", + "Read(~/.gnupg/**)", + "Read(~/.aws/**)", + "Read(~/.azure/**)", + "Read(~/.kube/**)", + "Read(~/.docker/config.json)", + "Read(~/.npmrc)", + "Read(~/.pypirc)", + "Read(~/.gem/credentials)", + "Read(~/.git-credentials)", + "Read(~/.config/gh/**)", + "Read(~/.bashrc)", + "Read(~/.zshrc)", + "Read(~/.bash_profile)", + "Read(~/.zprofile)", + "Read(./.env)", + "Read(./.env.local)", + "Edit(~/.ssh/**)", + "Edit(~/.gnupg/**)", + "Edit(~/.aws/**)", + "Edit(~/.azure/**)", + "Edit(~/.kube/**)", + "Edit(~/.docker/config.json)", + "Edit(~/.npmrc)", + "Edit(~/.bashrc)", + "Edit(~/.zshrc)", + "Edit(~/.bash_profile)", + "Edit(~/.zprofile)", + "Edit(./.env)", + "Edit(./.env.local)", + "Bash(rm -rf *)" + ] + } +} +``` + +What this blocks: +- **SSH/GPG keys** — `~/.ssh`, `~/.gnupg` +- **Cloud credentials** — `~/.aws`, `~/.azure`, `~/.kube`, `~/.docker/config.json` +- **Package registry tokens** — `~/.npmrc`, `~/.pypirc`, `~/.gem/credentials` +- **Git credentials** — `~/.git-credentials`, `~/.config/gh` +- **Shell configuration** — Prevents backdoor injection into `.bashrc`, `.zshrc`, etc. +- **Environment files** — `.env` and `.env.local` which may contain secrets. Note: `.env.example` is intentionally not blocked because it contains only placeholder values and is committed to the repository. +- **Destructive commands** — `rm -rf` requires manual alternatives + +### What is NOT blocked + +- Reading project files within the working directory — this is normal operation +- Reading files the developer explicitly asks Claude to look at (e.g., "read my ~/.gitconfig") +- Git operations within the project + +## Sandbox Mode + +For additional OS-level isolation, enable sandbox mode. This restricts file system access and network at the operating system level, not just at the tool level. + +Add to `.claude/settings.json`: + +```json +{ + "sandbox": { + "enabled": true, + "filesystem": { + "denyRead": [ + "~/.aws/credentials", + "~/.ssh/**" + ], + "denyWrite": [ + "//etc", + "//usr/local/bin" + ] + } + } +} +``` + +Sandbox uses Seatbelt on macOS and bubblewrap on Linux for enforcement at the OS level. This catches cases where Bash commands might bypass tool-level permission rules. + +## Hooks for Safety + +Hooks can block dangerous operations before they execute and log actions for audit trails. + +**Important**: Hook commands receive JSON input via **stdin**, not via environment variables. Use `jq` to extract fields like `tool_name` and `tool_input` from the JSON payload. For complex hooks, use separate script files in `.claude/hooks/` instead of inline commands to avoid shell escaping issues. + +### Hook Scripts + +The hook scripts are provided as ready-to-use files in the `hooks/` directory of this template: + +- **`hooks/block-destructive-git.sh`** — Blocks force-pushes and `git reset --hard` (PreToolUse) +- **`hooks/log-activity.sh`** — Logs all tool calls with timestamp, tool name, and input to `claude.log` (PostToolUse) + +When setting up a project, copy the `hooks/` directory to `.claude/hooks/` and add the following to `.claude/settings.json`: + +```json +{ + "hooks": { + "PreToolUse": [ + { + "matcher": "Bash", + "hooks": [ + { + "type": "command", + "command": "bash .claude/hooks/block-destructive-git.sh" + } + ] + } + ], + "PostToolUse": [ + { + "hooks": [ + { + "type": "command", + "command": "bash .claude/hooks/log-activity.sh" + } + ] + } + ] + } +} +``` + +The log file `claude.log` is temporary and must be added to `.gitignore`. Requires `jq` to be installed. + +**Important considerations for hook scripts:** +- Hook scripts must **never write to stdout** — stdout output is sent back to the API and can trigger content filters. Write only to files, and redirect errors to `/dev/null`. +- Truncate `tool_input` before logging — it can contain full file contents which are large and may contain patterns that trigger content filters. +- Always `exit 0` — a failing hook blocks Claude Code. + +## Setup Checklist + +When adding `claude-project-base` to a new project: + +- [ ] Copy the deny rules into `.claude/settings.json` +- [ ] Copy `hooks/` directory from the template to `.claude/hooks/` (scripts are already executable) +- [ ] Add `.claude/settings.local.json` and `claude.log` to `.gitignore` +- [ ] Ensure `jq` is installed (required by hook scripts) +- [ ] Consider enabling sandbox mode for stricter isolation +- [ ] Review whether additional project-specific paths need to be denied (e.g., `./secrets/`, `./certs/`) diff --git a/.claude/conventions/software-quality.md b/.claude/conventions/software-quality.md new file mode 100644 index 00000000..1fe3b953 --- /dev/null +++ b/.claude/conventions/software-quality.md @@ -0,0 +1,36 @@ +# Software Quality and Architecture Conventions for Claude Code + +## API Design + +- **IMPORTANT**: Define clean, minimal public APIs. Expose only what consumers need and hide all implementation details behind private or package-private access. +- Use language features to enforce encapsulation (Java modules, package-private classes, internal packages). The goal is that implementation details are not just undocumented but truly inaccessible. +- API design, modularization, meaningful abstractions, and configurability have the highest priority. Software from Open Elements stands out through quality in these areas. +- Follow the principle of convention over configuration — provide sensible defaults, but allow overriding where needed. +- **IMPORTANT**: Never expose API solely for testing purposes. Tests should exercise the public API as a consumer would. Prefer more complex tests over polluting the API with test-only entry points. + +## Technical Integrity + +- **IMPORTANT**: Do not implement features that cannot be done correctly. Open Elements does not ship solutions that only work in 60% of cases or that are known to cause problems in the future. +- If a requirement cannot be met with a clean technical solution, raise the concern rather than building a workaround. + +## Namespace + +- The base namespace for all Open Elements projects is `com.openelements` (Java packages) / `com.open-elements` (other contexts). + +## Build Metadata + +- Build tool configurations (Maven `pom.xml`, `package.json`, etc.) must include meaningful project metadata: name, description, URL, license, and developer information. +- **IMPORTANT**: For the project URL (e.g., `` in Maven `pom.xml`), try to read it from the Git remote (`git remote get-url origin`) and convert it to the corresponding GitHub web URL. If no Git remote is configured, **ask the user** for the correct URL. Never guess or assume a repository URL. +- This metadata is used for generated artifacts, SBOM generation, and repository listings. + +## Software Bill of Materials (SBOM) + +- All products must produce an SBOM in CycloneDX format as part of the build process. +- For Maven projects, use the [CycloneDX Maven Plugin](https://github.com/CycloneDX/cyclonedx-maven-plugin) (`org.cyclonedx:cyclonedx-maven-plugin`). Include it in the `` section of the POM so that the SBOM is generated automatically during every build. +- SBOMs should be uploaded to the Open Elements Dependency-Track instance for vulnerability tracking and compliance. + +## Continuous Integration + +- Use GitHub Actions to build and test code automatically. +- Pull requests must be built and tested before merging. At minimum, run the full test suite and verify the build succeeds. +- Keep CI pipelines fast. Fail early on compilation or lint errors before running the full test suite. diff --git a/.claude/conventions/spec-driven-development.md b/.claude/conventions/spec-driven-development.md new file mode 100644 index 00000000..1f679910 --- /dev/null +++ b/.claude/conventions/spec-driven-development.md @@ -0,0 +1,156 @@ +# Spec-Driven Development + +This document defines the structure and conventions for the `specs/` directory used in spec-driven development. Features and bug fixes are planned as specifications before implementation begins. + +## Overview + +Every non-trivial change goes through a specification phase: +1. A GitHub issue describes the **what** and **why** +2. A spec folder contains the **how** — technical design, behavioral scenarios, and optionally implementation steps +3. Implementation follows the spec, and is verified against it + +## Directory Structure + +Specs live in a `specs/` directory in the project root. Each spec gets its own sub-folder: + +``` +specs/ +├── 42-user-auth-flow/ +│ ├── design.md +│ ├── behaviors.md +│ └── steps.md (optional) +├── 87-csv-export-api/ +│ ├── design.md +│ └── behaviors.md +└── ... +``` + +### Folder Naming + +- **Based on a GitHub issue:** `-short-description` (e.g., `42-user-auth-flow`) +- **Without an issue:** `short-description` (e.g., `csv-export-api`) +- Keep the description to 3–4 words in kebab-case + +## Files + +### `design.md` — Technical Design + +Describes the technical approach for the change. Sections (include only what is relevant): + +- **GitHub Issue** — Link to the source issue +- **Summary** — What is being built and why (1–2 paragraphs) +- **Goals** — What this change aims to achieve +- **Non-goals** — What is explicitly out of scope +- **Technical approach** — High-level implementation strategy +- **API design** — Endpoints, request/response shapes, status codes +- **Data model** — Entities, relationships, migrations +- **Key flows** — Step-by-step execution paths +- **Dependencies** — External services, libraries, internal modules +- **Security considerations** — Auth, validation, data exposure +- **Open questions** — Unresolved items + +Key design decisions include a brief **rationale** explaining why the approach was chosen over alternatives. + +**For bug fixes**, the design focuses on different sections: +- **Summary** — What is broken and what is the user-visible impact +- **Reproduction** — Steps to reproduce the bug, preconditions, environment details +- **Root cause analysis** — Why the bug occurs, which component is responsible +- **Fix approach** — How the bug will be fixed, which files/components change +- **Regression risk** — What could break as a side effect + +Use **Mermaid diagrams** where they help clarify the design — for example sequence diagrams for key flows, entity-relationship diagrams for data models, or component diagrams for architecture. Embed them directly in the Markdown using fenced code blocks: + +````markdown +```mermaid +sequenceDiagram + Client->>API: POST /users + API->>DB: INSERT user + DB-->>API: user record + API-->>Client: 201 Created +``` +```` + +Diagrams are optional — only add them when they communicate structure or flow more clearly than text alone. + +### `behaviors.md` — Behavioral Scenarios + +Defines the expected behavior using given-when-then scenarios (Behavior-Driven Design). These scenarios serve as the basis for unit and integration tests. + +Format: + +```markdown +# Behaviors: + +## + +### + +- **Given** +- **When** +- **Then** +``` + +Coverage should include: +- **Happy paths** — Main success scenarios +- **Edge cases** — Boundary values, empty inputs, concurrent access +- **Error cases** — Invalid input, missing permissions, downstream failures +- **State transitions** — Before/after states where relevant + +Each scenario should be specific enough to translate directly into a test case. + +### `steps.md` — Implementation Steps (optional) + +An ordered, actionable checklist for implementing the spec. Uses GitHub-flavored Markdown checkboxes for tracking progress: + +```markdown +# Implementation Steps: + +## Step 1: + +- [ ] Create `src/models/user.ts` with fields: id, email, name, createdAt +- [ ] Create migration `migrations/001_create_users.sql` + +**Acceptance criteria:** +- [ ] Migration runs successfully +- [ ] Entity can be instantiated in a test +- [ ] Unit tests for new code exist and pass +- [ ] Project builds successfully + +**Related behaviors:** User creation happy path + +--- + +## Step 2: <Title> +... +``` + +Each step is: +- **Atomic** — One focused change +- **Independently verifiable** — Can be confirmed after completion +- **Sequenced by dependency** — Earlier steps are foundations for later ones + +## Workflow + +The spec-driven workflow uses three skills: + +| Skill | Purpose | +|-------|---------| +| `/spec-create` | Create `design.md` and `behaviors.md` through interactive discussion | +| `/spec-implement` | Generate `steps.md` from a completed spec | +| `/spec-review` | Verify implementation completeness against design and behaviors | + +A typical flow: +1. Start with a GitHub issue (or create one first) +2. `/spec-create` — Plan the change collaboratively +3. `/spec-implement` — Break it down into steps (optional) +4. Implement (manually, guided, or automated) +5. `/spec-review` — Verify completeness + +## Principles + +- **Issue first** — Every PR should have a corresponding GitHub issue +- **Discuss before writing** — Specs are created through dialogue, not generated silently +- **Right-size the spec** — A bug fix needs less documentation than a new feature. Skip sections that are not relevant. +- **Living documents** — Specs can be updated during implementation if decisions change. Keep them in sync. +- **Specs are not throwaway** — They remain in the repository as documentation of design decisions and expected behavior +- **Commits and PRs are human work** — Developers create commits and pull requests themselves. The spec folder and its design decisions should be referenced in the PR description, but the PR itself is authored by the developer, not generated by AI. diff --git a/.claude/conventions/typescript.md b/.claude/conventions/typescript.md new file mode 100644 index 00000000..465c6f4b --- /dev/null +++ b/.claude/conventions/typescript.md @@ -0,0 +1,109 @@ +# TypeScript Conventions for Claude Code + +## Technology Stack + +- **Language**: TypeScript is the default for all frontends. Only use plain JavaScript where enabling TypeScript would be disproportionate overhead. +- **Framework**: [React](https://react.dev) is the base UI framework. **IMPORTANT**: Do not use alternatives like Vue or Angular. +- **Application Framework**: [Next.js](https://nextjs.org) on top of React for concrete frontend applications. +- **IMPORTANT**: Configure `output: 'standalone'` in `next.config.js` / `next.config.ts` for all Next.js applications. This is required for Docker deployments and produces a self-contained build output. +- **IMPORTANT**: Pages that fetch data from a backend API must not be statically pre-rendered at build time. Use `export const dynamic = 'force-dynamic'` or other appropriate mechanisms to ensure they are rendered at request time. Static pre-rendering will cache stale or error states because the backend is not available during `next build`. +- **Styling**: [Tailwind CSS](https://tailwindcss.com) for all styling. Do not introduce other CSS frameworks. +- **Component Library**: [shadcn/ui](https://ui.shadcn.com) as the component library. +- **shadcn/ui MCP Server**: Projects using shadcn/ui should configure the [shadcn MCP server](https://ui.shadcn.com/docs/mcp) so that Claude Code can browse, search, and install components directly. Add the following to the project's `.mcp.json`: + ```json + { + "mcpServers": { + "shadcn": { + "command": "npx", + "args": ["shadcn@latest", "mcp"] + } + } + } + ``` + +## Project Structure + +- Every Next.js project must have a `public/` directory with at minimum a `favicon.ico`. This directory is required for the Docker build to succeed and for serving static assets. + +## UI Layout and Design Quality + +- **IMPORTANT**: Every page and component must have a polished, professional appearance — even for early-stage or PoC projects. Unstyled or minimally styled UIs are not acceptable. +- Use a consistent page layout with a clear structure: header/navigation, main content area, and footer where appropriate. Prefer [shadcn/ui Blocks](https://ui.shadcn.com/blocks) as a starting point for app layouts (e.g., sidebar or dashboard shells) instead of building layout structures from scratch. +- Apply generous and consistent spacing (padding and margin) throughout. Use Tailwind's spacing scale consistently (e.g., `p-4`, `p-6`, `p-8` for content areas, `gap-4`, `gap-6` for flex/grid layouts). Never leave elements without spacing. +- Constrain content width for readability (e.g., `max-w-screen-xl mx-auto`) — do not let content stretch edge-to-edge on wide screens. +- Use shadcn/ui components (Card, Table, Button, Input, Dialog, etc.) instead of bare HTML elements. Bare `<table>`, `<button>`, or `<input>` elements without component library styling are not acceptable. +- Ensure responsive design: layouts must work on mobile, tablet, and desktop. Use Tailwind's responsive prefixes (`sm:`, `md:`, `lg:`). +- Apply the Open Elements brand colors and typography as defined in the Brand Guidelines skill. Configure them in `tailwind.config` so they are available as utility classes. + +## Common Commands + +These are the typical commands for TypeScript/Next.js projects. Adjust the package manager prefix (`pnpm`, `npm run`, `yarn`) to match the project. + +- **Install dependencies**: `pnpm install` +- **Dev server**: `pnpm dev` +- **Build**: `pnpm build` +- **Run tests**: `pnpm test` +- **Run a single test file**: `pnpm test -- path/to/test.ts` +- **Lint**: `pnpm lint` +- **Format**: `pnpm format` +- **Type check**: `pnpm tsc --noEmit` + +## Code Style + +Formatting rules (indentation, charset, line endings) are defined in `.editorconfig` — see [editorconfig.md](editorconfig.md). + +- **IMPORTANT**: Enable `strict` mode in `tsconfig.json`. Do not weaken strict checks without explicit justification. +- Use explicit type annotations for function parameters and return types. Rely on inference for local variables. +- Prefer `interface` over `type` for object shapes unless you need union types or mapped types. +- Use `const` by default. Use `let` only when reassignment is needed. **IMPORTANT**: Never use `var`. +- Prefer `readonly` for properties that should not be reassigned after initialization. +- Follow standard naming: `PascalCase` for types/interfaces/classes, `camelCase` for variables/functions, `UPPER_SNAKE_CASE` for constants. + +## Package Manager + +- Respect the existing package manager in the project (`npm`, `yarn`, or `pnpm`) — do not switch without explicit instruction. +- We prefer `pnpm`. +- Use the lockfile that matches the package manager (`package-lock.json`, `yarn.lock`, `pnpm-lock.yaml`). +- Do not add dependencies that duplicate functionality already available in the project. + +## Testing + +- Use the testing framework already present in the project (e.g., Jest, Vitest, or Node test runner). +- Name test cases descriptively: `it('should return empty array when no items exist')`. +- Group related tests with `describe` blocks. +- Prefer `toEqual` for deep equality and `toBe` for reference/primitive equality. +- **IMPORTANT**: Avoid excessive mocking. Prefer simple stub/dummy implementations for test dependencies if possible and not too complexe. Excessive mocking often indicates poorly designed APIs with too many dependencies. Only mock when the dependency cannot be substituted otherwise (e.g., browser APIs, third-party services) or complexity will become too big. + +## Linting and Formatting + +- Respect existing ESLint and Prettier configurations. Do not change rules without explicit instruction. +- Fix linting errors in code you write or modify. Do not add `eslint-disable` comments unless there is a clear justification. +- Run formatting before committing to keep diffs clean. + +## Internationalization (I18n) + +- **IMPORTANT**: All user-facing text must be i18n-ready from the start. Never hardcode display strings directly in components. +- Extract all user-facing strings (labels, messages, errors, placeholders, tooltips) into a central location (e.g., a constants file or translation file) so that adding translations later requires no component changes. +- Use a consistent key-naming convention for text keys (e.g., `page.section.element` like `dashboard.header.title`). +- Full multi-language support does not need to be implemented immediately, but the architecture must make it straightforward to add later (e.g., by swapping in a library like [next-intl](https://next-intl-docs.vercel.app/) or [react-i18next](https://react.i18next.com/)). +- Do not concatenate translated strings to build sentences — use parameterized messages with placeholders instead (e.g., `"Welcome, {name}"` not `"Welcome, " + name`). +- Keep date, number, and currency formatting locale-aware from the start (use `Intl.DateTimeFormat`, `Intl.NumberFormat`). + +## Logging + +- Use `console.error` for errors, `console.warn` for warnings, and `console.info` for informational messages. Do not use `console.log` in production code. +- Log meaningful context: what operation failed, which endpoint was called, and the HTTP status code or error message received. +- **IMPORTANT**: Never log sensitive data (tokens, passwords, personal data) to the browser console. + +## Error Handling + +- Use typed errors or custom error classes where appropriate. +- Avoid catching errors without handling them. At minimum, log the error. +- Prefer `unknown` over `any` in catch blocks: `catch (error: unknown)`. + +### Backend Communication Errors + +- Log detailed error information to the browser console (HTTP status, endpoint URL, error body) for debugging purposes. +- **IMPORTANT**: Never show raw backend error messages, stack traces, or technical details to the user. Display a simplified, user-friendly error message instead (e.g., "The data could not be loaded. Please try again later."). +- Distinguish between error types for the user where helpful: network errors ("No connection to the server"), authorization errors ("Please log in again"), and general server errors ("An unexpected error occurred"). +- Centralize backend error handling in a shared utility or API client layer to ensure consistent logging and user-facing messages across the application. diff --git a/.claude/hooks/block-destructive-git.sh b/.claude/hooks/block-destructive-git.sh new file mode 100755 index 00000000..0f425059 --- /dev/null +++ b/.claude/hooks/block-destructive-git.sh @@ -0,0 +1,8 @@ +#!/bin/bash +INPUT=$(cat) +CMD=$(echo "$INPUT" | jq -r '.tool_input.command // empty') +if echo "$CMD" | grep -qE 'git\s+push.*--force|git\s+push.*-f|git\s+reset\s+--hard'; then + echo 'Blocked: destructive git operation. Use the Git CLI directly if intended.' >&2 + exit 2 +fi +exit 0 diff --git a/.claude/hooks/log-activity.sh b/.claude/hooks/log-activity.sh new file mode 100755 index 00000000..f8d5982e --- /dev/null +++ b/.claude/hooks/log-activity.sh @@ -0,0 +1,11 @@ +#!/bin/bash +# Log Claude Code tool calls to claude.log +# Truncates tool_input to avoid large file contents in the log +INPUT=$(cat) +TOOL=$(echo "$INPUT" | jq -r '.tool_name // empty' 2>/dev/null) +# Log only a short summary of the input (first 200 chars), not full file contents +TOOL_INPUT=$(echo "$INPUT" | jq -c '.tool_input // empty' 2>/dev/null | cut -c1-200) +TIMESTAMP=$(date -u '+%Y-%m-%dT%H:%M:%SZ') +# Write to log file only, no stdout output (stdout goes back to the API) +echo "$TIMESTAMP [$TOOL] $TOOL_INPUT" >> claude.log 2>/dev/null +exit 0 diff --git a/.claude/skills/code-connect-components/SKILL.md b/.claude/skills/code-connect-components/SKILL.md new file mode 100644 index 00000000..ea9fe134 --- /dev/null +++ b/.claude/skills/code-connect-components/SKILL.md @@ -0,0 +1,335 @@ +--- +name: code-connect-components +description: Connects Figma design components to code components using Code Connect. Use when user says "code connect", "connect this component to code", "connect Figma to code", "map this component", "link component to code", "create code connect mapping", "add code connect", "connect design to code", or wants to establish mappings between Figma designs and code implementations. Requires Figma MCP server connection. +metadata: + mcp-server: figma + source: https://github.com/figma/mcp-server-guide + author: Figma + modifications: None +--- + +# Code Connect Components + +## Overview + +This skill helps you connect Figma design components to their corresponding code implementations using Figma's Code Connect feature. It analyzes the Figma design structure, searches your codebase for matching components, and establishes mappings that maintain design-code consistency. + +## Prerequisites + +- Figma MCP server must be connected and accessible + - Before proceeding, verify the Figma MCP server is connected by checking if Figma MCP tools (e.g., `get_code_connect_suggestions`) are available. + - If the tools are not available, the Figma MCP server may not be enabled. Guide the user to enable the Figma MCP server that is included with the plugin. They may need to restart their MCP client afterward. +- User must provide a Figma URL with node ID: `https://figma.com/design/:fileKey/:fileName?node-id=1-2` + - **IMPORTANT:** The Figma URL must include the `node-id` parameter. Code Connect mapping will fail without it. +- **IMPORTANT:** The Figma component must be published to a team library. Code Connect only works with published components or component sets. +- **IMPORTANT:** Code Connect is only available on Organization and Enterprise plans. +- Access to the project codebase for component scanning + +## Required Workflow + +**Follow these steps in order. Do not skip steps.** + +### Step 1: Get Code Connect Suggestions + +Call `get_code_connect_suggestions` to identify all unmapped components in a single operation. This tool automatically: + +- Fetches component info from the Figma scenegraph +- Identifies published components in the selection +- Checks existing Code Connect mappings and filters out already-connected components +- Returns component names, properties, and thumbnail images for each unmapped component + +Parse the URL to extract `fileKey` and `nodeId`, then call `get_code_connect_suggestions`. + +**IMPORTANT:** When extracting the node ID from a Figma URL, convert the format: + +- URL format uses hyphens: `node-id=1-2` +- Tool expects colons: `nodeId=1:2` + +**Parse the Figma URL:** + +- URL format: `https://figma.com/design/:fileKey/:fileName?node-id=1-2` +- Extract file key: `:fileKey` (segment after `/design/`) +- Extract node ID: `1-2` from URL, then convert to `1:2` for the tool + +``` +get_code_connect_suggestions(fileKey=":fileKey", nodeId="1:2") +``` + +**Handle the response:** + +- If the tool returns **"No published components found in this selection"** → inform the user and stop. The components may need to be published to a team library first. +- If the tool returns **"All component instances in this selection are already connected to code via Code Connect"** → inform the user that everything is already mapped. +- Otherwise, the response contains a list of unmapped components, each with: + - Component name + - Node ID + - Component properties (JSON with prop names and values) + - A thumbnail image of the component (for visual inspection) + +### Step 2: Scan Codebase for Matching Components + +For each unmapped component returned by `get_code_connect_suggestions`, search the codebase for a matching code component. + +**What to look for:** + +- Component names that match or are similar to the Figma component name +- Component structure that aligns with the Figma hierarchy +- Props that correspond to Figma properties (variants, text, styles) +- Files in typical component directories (`src/components/`, `components/`, `ui/`, etc.) + +**Search strategy:** + +1. Search for component files with matching names +2. Read candidate files to check structure and props +3. Compare the code component's props with the Figma component properties returned in Step 1 +4. Detect the programming language (TypeScript, JavaScript) and framework (React, Vue, etc.) +5. Identify the best match based on structural similarity, weighing: + - Prop names and their correspondence to Figma properties + - Default values that match Figma defaults + - CSS classes or style objects + - Descriptive comments that clarify intent +6. If multiple candidates are equally good, pick the one with the closest prop-interface match and document your reasoning in a 1-2 sentence comment before your tool call + +**Example search patterns:** + +- If Figma component is "PrimaryButton", search for `Button.tsx`, `PrimaryButton.tsx`, `Button.jsx` +- Check common component paths: `src/components/`, `app/components/`, `lib/ui/` +- Look for variant props like `variant`, `size`, `color` that match Figma variants + +### Step 3: Present Matches to User + +Present your findings and let the user choose which mappings to create. The user can accept all, some, or none of the suggested mappings. + +**Present matches in this format:** + +``` +The following components match the design: +- [ComponentName](path/to/component): DesignComponentName at nodeId [nodeId](figmaUrl?node-id=X-Y) +- [AnotherComponent](path/to/another): AnotherDesign at nodeId [nodeId2](figmaUrl?node-id=X-Y) + +Would you like to connect these components? You can accept all, select specific ones, or skip. +``` + +**If no exact match is found for a component:** + +- Show the 2 closest candidates +- Explain the differences +- Ask the user to confirm which component to use or provide the correct path + +**If the user declines all mappings**, inform them and stop. No further tool calls are needed. + +### Step 4: Create Code Connect Mappings + +Once the user confirms their selections, call `send_code_connect_mappings` with only the accepted mappings. This tool handles batch creation of all mappings in a single call. + +**Example:** + +``` +send_code_connect_mappings( + fileKey=":fileKey", + nodeId="1:2", + mappings=[ + { nodeId: "1:2", componentName: "Button", source: "src/components/Button.tsx", label: "React" }, + { nodeId: "1:5", componentName: "Card", source: "src/components/Card.tsx", label: "React" } + ] +) +``` + +**Key parameters for each mapping:** + +- `nodeId`: The Figma node ID (with colon format: `1:2`) +- `componentName`: Name of the component to connect (e.g., "Button", "Card") +- `source`: Path to the code component file (relative to project root) +- `label`: The framework or language label for this Code Connect mapping. Valid values include: + - Web: 'React', 'Web Components', 'Vue', 'Svelte', 'Storybook', 'Javascript' + - iOS: 'Swift UIKit', 'Objective-C UIKit', 'SwiftUI' + - Android: 'Compose', 'Java', 'Kotlin', 'Android XML Layout' + - Cross-platform: 'Flutter' + - Docs: 'Markdown' + +**After the call:** + +- On success: the tool confirms the mappings were created +- On error: the tool reports which specific mappings failed and why (e.g., "Component is already mapped to code", "Published component not found", "Insufficient permissions") + +**Provide a summary** after processing: + +``` +Code Connect Summary: +- Successfully connected: 3 + - Button (1:2) → src/components/Button.tsx + - Card (1:5) → src/components/Card.tsx + - Input (1:8) → src/components/Input.tsx +- Could not connect: 1 + - CustomWidget (1:10) - No matching component found in codebase +``` + +## Examples + +### Example 1: Connecting a Button Component + +User says: "Connect this Figma button to my code: https://figma.com/design/kL9xQn2VwM8pYrTb4ZcHjF/DesignSystem?node-id=42-15" + +**Actions:** + +1. Parse URL: fileKey=`kL9xQn2VwM8pYrTb4ZcHjF`, nodeId=`42-15` → convert to `42:15` +2. Run `get_code_connect_suggestions(fileKey="kL9xQn2VwM8pYrTb4ZcHjF", nodeId="42:15")` +3. Response shows: Button component (unmapped) with `variant` (primary/secondary) and `size` (sm/md/lg) properties, plus a thumbnail image +4. Search codebase for Button components: Find `src/components/Button.tsx` +5. Read `Button.tsx` and confirm it has `variant` and `size` props +6. Present to user: "I found a match: + - [Button](src/components/Button.tsx): Button at nodeId [42:15](https://figma.com/design/kL9xQn2VwM8pYrTb4ZcHjF/DesignSystem?node-id=42-15) + + Would you like to connect this component?" + +7. User confirms: "Yes" +8. Detect that it's a TypeScript React component +9. Run `send_code_connect_mappings(fileKey="kL9xQn2VwM8pYrTb4ZcHjF", nodeId="42:15", mappings=[{ nodeId: "42:15", componentName: "Button", source: "src/components/Button.tsx", label: "React" }])` + +**Result:** Figma button component is now connected to the code Button component. + +### Example 2: Multiple Components with Partial Selection + +User says: "Connect components in this frame: https://figma.com/design/pR8mNv5KqXzGwY2JtCfL4D/Components?node-id=10-50" + +**Actions:** + +1. Parse URL: fileKey=`pR8mNv5KqXzGwY2JtCfL4D`, nodeId=`10-50` → convert to `10:50` +2. Run `get_code_connect_suggestions(fileKey="pR8mNv5KqXzGwY2JtCfL4D", nodeId="10:50")` +3. Response shows 3 unmapped components: ProductCard, Badge, and CustomWidget +4. Search codebase: + - ProductCard: Found `src/components/ProductCard.tsx` (props match) + - Badge: Found `src/components/Badge.tsx` (props match) + - CustomWidget: No matching component found +5. Present to user: + "The following components match the design: + - [ProductCard](src/components/ProductCard.tsx): ProductCard at nodeId [10:51](https://figma.com/design/pR8mNv5KqXzGwY2JtCfL4D/Components?node-id=10-51) + - [Badge](src/components/Badge.tsx): Badge at nodeId [10:52](https://figma.com/design/pR8mNv5KqXzGwY2JtCfL4D/Components?node-id=10-52) + + I couldn't find a match for CustomWidget (10:53). + + Would you like to connect these components? You can accept all, select specific ones, or skip." + +6. User: "Just connect ProductCard, skip Badge for now" +7. Run `send_code_connect_mappings(fileKey="pR8mNv5KqXzGwY2JtCfL4D", nodeId="10:50", mappings=[{ nodeId: "10:51", componentName: "ProductCard", source: "src/components/ProductCard.tsx", label: "React" }])` + +**Result:** Only ProductCard is connected, per the user's selection. + +### Example 3: Component Needs Creation + +User says: "Connect this icon: https://figma.com/design/8yJDMeWDyBz71EnMOSuUiw/Icons?node-id=5-20" + +**Actions:** + +1. Parse URL: fileKey=`8yJDMeWDyBz71EnMOSuUiw`, nodeId=`5-20` → convert to `5:20` +2. Run `get_code_connect_suggestions(fileKey="8yJDMeWDyBz71EnMOSuUiw", nodeId="5:20")` +3. Response shows: CheckIcon component (unmapped) with color and size properties +4. Search codebase for CheckIcon: No matches found +5. Search for generic Icon components: Find `src/icons/` directory with other icons +6. Report to user: "I couldn't find a CheckIcon component, but I found an icons directory at src/icons/. Would you like to: + - Create a new CheckIcon.tsx component first, then connect it + - Connect to a different existing icon + - Provide the path to the CheckIcon if it exists elsewhere" +7. User provides path: "src/icons/CheckIcon.tsx" +8. Detect language and framework from the file +9. Run `send_code_connect_mappings(fileKey="8yJDMeWDyBz71EnMOSuUiw", nodeId="5:20", mappings=[{ nodeId: "5:20", componentName: "CheckIcon", source: "src/icons/CheckIcon.tsx", label: "React" }])` + +**Result:** CheckIcon component is successfully connected to the Figma design. + +## Best Practices + +### Proactive Component Discovery + +Don't just ask the user for the file path — actively search their codebase to find matching components. This provides a better experience and catches potential mapping opportunities. + +### Accurate Structure Matching + +When comparing Figma components to code components, look beyond just names. Check that: + +- Props align (variant types, size options, etc.) +- Component hierarchy matches (nested elements) +- The component serves the same purpose + +### Clear Communication + +When offering to create a mapping, clearly explain: + +- What you found +- Why it's a good match +- What the mapping will do +- How props will be connected + +### Handle Ambiguity + +If multiple components could match, present options rather than guessing. Let the user make the final decision about which component to connect. + +### Graceful Degradation + +If you can't find an exact match, provide helpful next steps: + +- Show close candidates +- Suggest component creation +- Ask for user guidance + +## Common Issues and Solutions + +### Issue: "No published components found in this selection" + +**Cause:** The Figma component is not published to a team library. Code Connect only works with published components. +**Solution:** The user needs to publish the component to a team library in Figma: + +1. In Figma, select the component or component set +2. Right-click and choose "Publish to library" or use the Team Library publish modal +3. Publish the component +4. Once published, retry the Code Connect mapping with the same node ID + +### Issue: "Code Connect is only available on Organization and Enterprise plans" + +**Cause:** The user's Figma plan does not include Code Connect access. +**Solution:** The user needs to upgrade to an Organization or Enterprise plan, or contact their administrator. + +### Issue: No matching component found in codebase + +**Cause:** The codebase search did not find a component with a matching name or structure. +**Solution:** Ask the user if the component exists under a different name or in a different location. They may need to create the component first, or it might be located in an unexpected directory. + +### Issue: "Published component not found" (CODE_CONNECT_ASSET_NOT_FOUND) + +**Cause:** The source file path is incorrect, the component doesn't exist at that location, or the componentName doesn't match the actual export. +**Solution:** Verify the source path is correct and relative to the project root. Check that the component is properly exported from the file with the exact componentName specified. + +### Issue: "Component is already mapped to code" (CODE_CONNECT_MAPPING_ALREADY_EXISTS) + +**Cause:** A Code Connect mapping already exists for this component. +**Solution:** The component is already connected. If the user wants to update the mapping, they may need to remove the existing one first in Figma. + +### Issue: "Insufficient permissions to create mapping" (CODE_CONNECT_INSUFFICIENT_PERMISSIONS) + +**Cause:** The user does not have edit permissions on the Figma file or library. +**Solution:** The user needs edit access to the file containing the component. Contact the file owner or team admin. + +### Issue: Code Connect mapping fails with URL errors + +**Cause:** The Figma URL format is incorrect or missing the `node-id` parameter. +**Solution:** Verify the URL follows the required format: `https://figma.com/design/:fileKey/:fileName?node-id=1-2`. The `node-id` parameter is required. Also ensure you convert `1-2` to `1:2` when calling tools. + +### Issue: Multiple similar components found + +**Cause:** The codebase contains multiple components that could match the Figma component. +**Solution:** Present all candidates to the user with their file paths and let them choose which one to connect. Different components might be used in different contexts (e.g., `Button.tsx` vs `LinkButton.tsx`). + +## Understanding Code Connect + +Code Connect establishes a bidirectional link between design and code: + +**For designers:** See which code component implements a Figma component +**For developers:** Navigate from Figma designs directly to the code that implements them +**For teams:** Maintain a single source of truth for component mappings + +The mapping you create helps keep design and code in sync by making these connections explicit and discoverable. + +## Additional Resources + +For more information about Code Connect: + +- [Code Connect Documentation](https://help.figma.com/hc/en-us/articles/23920389749655-Code-Connect) +- [Figma MCP Server Tools and Prompts](https://developers.figma.com/docs/figma-mcp-server/tools-and-prompts/) diff --git a/.claude/skills/create-design-system-rules/SKILL.md b/.claude/skills/create-design-system-rules/SKILL.md new file mode 100644 index 00000000..4468cdfd --- /dev/null +++ b/.claude/skills/create-design-system-rules/SKILL.md @@ -0,0 +1,544 @@ +--- +name: create-design-system-rules +description: Generates custom design system rules for the user's codebase. Use when user says "create design system rules", "generate rules for my project", "set up design rules", "customize design system guidelines", or wants to establish project-specific conventions for Figma-to-code workflows. Requires Figma MCP server connection. +metadata: + mcp-server: figma + source: https://github.com/figma/mcp-server-guide + author: Figma + modifications: None +--- + +# Create Design System Rules + +## Overview + +This skill helps you generate custom design system rules tailored to your project's specific needs. These rules guide AI coding agents to produce consistent, high-quality code when implementing Figma designs, ensuring that your team's conventions, component patterns, and architectural decisions are followed automatically. + +### Supported Rule Files + +| Agent | Rule File | +|-------|-----------| +| Claude Code | `CLAUDE.md` | +| Codex CLI | `AGENTS.md` | +| Cursor | `.cursor/rules/figma-design-system.mdc` | + +## What Are Design System Rules? + +Design system rules are project-level instructions that encode the "unwritten knowledge" of your codebase - the kind of expertise that experienced developers know and would pass on to new team members: + +- Which layout primitives and components to use +- Where component files should be located +- How components should be named and structured +- What should never be hardcoded +- How to handle design tokens and styling +- Project-specific architectural patterns + +Once defined, these rules dramatically reduce repetitive prompting and ensure consistent output across all Figma implementation tasks. + +## Prerequisites + +- Figma MCP server must be connected and accessible + - Before proceeding, verify the Figma MCP server is connected by checking if Figma MCP tools (e.g., `create_design_system_rules`) are available. + - If the tools are not available, the Figma MCP server may not be enabled. Guide the user to enable the Figma MCP server that is included with the plugin. They may need to restart their MCP client afterward. +- Access to the project codebase for analysis +- Understanding of your team's component conventions (or willingness to establish them) + +## When to Use This Skill + +Use this skill when: + +- Starting a new project that will use Figma designs +- Onboarding an AI coding agent to an existing project with established patterns +- Standardizing Figma-to-code workflows across your team +- Updating or refining existing design system conventions +- Users explicitly request: "create design system rules", "set up Figma guidelines", "customize rules for my project" + +## Required Workflow + +**Follow these steps in order. Do not skip steps.** + +### Step 1: Run the Create Design System Rules Tool + +Call the Figma MCP server's `create_design_system_rules` tool to get the foundational prompt and template. + +**Parameters:** + +- `clientLanguages`: Comma-separated list of languages used in the project (e.g., "typescript,javascript", "python", "javascript") +- `clientFrameworks`: Framework being used (e.g., "react", "vue", "svelte", "angular", "unknown") + +This tool returns guidance and a template for creating design system rules. + +Structure your design system rules following the template format provided in the tool's response. + +### Step 2: Analyze the Codebase + +Before finalizing rules, analyze the project to understand existing patterns: + +**Component Organization:** + +- Where are UI components located? (e.g., `src/components/`, `app/ui/`, `lib/components/`) +- Is there a dedicated design system directory? +- How are components organized? (by feature, by type, flat structure) + +**Styling Approach:** + +- What CSS framework or approach is used? (Tailwind, CSS Modules, styled-components, etc.) +- Where are design tokens defined? (CSS variables, theme files, config files) +- Are there existing color, typography, or spacing tokens? + +**Component Patterns:** + +- What naming conventions are used? (PascalCase, kebab-case, prefixes) +- How are component props typically structured? +- Are there common composition patterns? + +**Architecture Decisions:** + +- How is state management handled? +- What routing system is used? +- Are there specific import patterns or path aliases? + +### Step 3: Generate Project-Specific Rules + +Based on your codebase analysis, create a comprehensive set of rules. Include: + +#### General Component Rules + +```markdown +- IMPORTANT: Always use components from `[YOUR_PATH]` when possible +- Place new UI components in `[COMPONENT_DIRECTORY]` +- Follow `[NAMING_CONVENTION]` for component names +- Components must export as `[EXPORT_PATTERN]` +``` + +#### Styling Rules + +```markdown +- Use `[CSS_FRAMEWORK/APPROACH]` for styling +- Design tokens are defined in `[TOKEN_LOCATION]` +- IMPORTANT: Never hardcode colors - always use tokens from `[TOKEN_FILE]` +- Spacing values must use the `[SPACING_SYSTEM]` scale +- Typography follows the scale defined in `[TYPOGRAPHY_LOCATION]` +``` + +#### Figma MCP Integration Rules + +```markdown +## Figma MCP Integration Rules + +These rules define how to translate Figma inputs into code for this project and must be followed for every Figma-driven change. + +### Required Flow (do not skip) + +1. Run get_design_context first to fetch the structured representation for the exact node(s) +2. If the response is too large or truncated, run get_metadata to get the high-level node map, then re-fetch only the required node(s) with get_design_context +3. Run get_screenshot for a visual reference of the node variant being implemented +4. Only after you have both get_design_context and get_screenshot, download any assets needed and start implementation +5. Translate the output (usually React + Tailwind) into this project's conventions, styles, and framework +6. Validate against Figma for 1:1 look and behavior before marking complete + +### Implementation Rules + +- Treat the Figma MCP output (React + Tailwind) as a representation of design and behavior, not as final code style +- Replace Tailwind utility classes with `[YOUR_STYLING_APPROACH]` when applicable +- Reuse existing components from `[COMPONENT_PATH]` instead of duplicating functionality +- Use the project's color system, typography scale, and spacing tokens consistently +- Respect existing routing, state management, and data-fetch patterns +- Strive for 1:1 visual parity with the Figma design +- Validate the final UI against the Figma screenshot for both look and behavior +``` + +#### Asset Handling Rules + +```markdown +## Asset Handling + +- The Figma MCP server provides an assets endpoint which can serve image and SVG assets +- IMPORTANT: If the Figma MCP server returns a localhost source for an image or SVG, use that source directly +- IMPORTANT: DO NOT import/add new icon packages - all assets should be in the Figma payload +- IMPORTANT: DO NOT use or create placeholders if a localhost source is provided +- Store downloaded assets in `[ASSET_DIRECTORY]` +``` + +#### Project-Specific Conventions + +```markdown +## Project-Specific Conventions + +- [Add any unique architectural patterns] +- [Add any special import requirements] +- [Add any testing requirements] +- [Add any accessibility standards] +- [Add any performance considerations] +``` + +### Step 4: Save Rules to the Appropriate Rule File + +Detect which AI coding agent the user is working with and save the generated rules to the corresponding file: + +| Agent | Rule File | Notes | +|-------|-----------|-------| +| Claude Code | `CLAUDE.md` in project root | Markdown format. Can also use `.claude/rules/figma-design-system.md` for modular organization. | +| Codex CLI | `AGENTS.md` in project root | Markdown format. Append as a new section if file already exists. 32 KiB combined size limit. | +| Cursor | `.cursor/rules/figma-design-system.mdc` | Markdown with YAML frontmatter (`description`, `globs`, `alwaysApply`). | + +If unsure which agent the user is working with, check for existing rule files in the project or ask the user. + +For Cursor, wrap the rules with YAML frontmatter: + +```markdown +--- +description: Rules for implementing Figma designs using the Figma MCP server. Covers component organization, styling conventions, design tokens, asset handling, and the required Figma-to-code workflow. +globs: "src/components/**" +alwaysApply: false +--- + +[Generated rules here] +``` + +Customize the `globs` pattern to match the directories where Figma-derived code will live in the project (e.g., `"src/**/*.tsx"` or `["src/components/**", "src/pages/**"]`). + +After saving, the rules will be automatically loaded by the agent and applied to all Figma implementation tasks. + +### Step 5: Validate and Iterate + +After creating rules: + +1. Test with a simple Figma component implementation +2. Verify the agent follows the rules correctly +3. Refine any rules that aren't working as expected +4. Share with team members for feedback +5. Update rules as the project evolves + +## Rule Categories and Examples + +### Essential Rules (Always Include) + +**Component Discovery:** + +```markdown +- UI components are located in `src/components/ui/` +- Feature components are in `src/components/features/` +- Layout primitives are in `src/components/layout/` +``` + +**Design Token Usage:** + +```markdown +- Colors are defined as CSS variables in `src/styles/tokens.css` +- Never hardcode hex colors - use `var(--color-*)` tokens +- Spacing uses the 4px base scale: `--space-1` (4px), `--space-2` (8px), etc. +``` + +**Styling Approach:** + +```markdown +- Use Tailwind utility classes for styling +- Custom styles go in component-level CSS modules +- Theme customization is in `tailwind.config.js` +``` + +### Recommended Rules (Highly Valuable) + +**Component Patterns:** + +```markdown +- All components must accept a `className` prop for composition +- Variant props should use union types: `variant: 'primary' | 'secondary'` +- Icon components should accept `size` and `color` props +``` + +**Import Conventions:** + +```markdown +- Use path aliases: `@/components`, `@/styles`, `@/utils` +- Group imports: React, third-party, internal, types +- No relative imports beyond parent directory +``` + +**Code Quality:** + +```markdown +- Add JSDoc comments for exported components +- Include PropTypes or TypeScript types for all props +- Extract magic numbers to named constants +``` + +### Optional Rules (Project-Specific) + +**Accessibility:** + +```markdown +- All interactive elements must have aria-labels +- Color contrast must meet WCAG AA standards +- Keyboard navigation required for all interactions +``` + +**Performance:** + +```markdown +- Lazy load images with the `Image` component from `@/components/Image` +- Use React.memo for components that receive complex props +- Icons should be SVG components, not icon fonts +``` + +**Testing:** + +```markdown +- Include unit tests for new components in `__tests__/` directory +- Use Testing Library queries (getByRole, getByLabelText) +- Test all interactive states and variants +``` + +## Examples + +### Example 1: React + Tailwind Project + +User says: "Create design system rules for my React project" + +**Actions:** + +1. Run `create_design_system_rules(clientLanguages="typescript,javascript", clientFrameworks="react")` +2. Analyze codebase structure +3. Generate rules: + +```markdown +# Figma MCP Integration Rules + +## Component Organization + +- UI components are in `src/components/ui/` +- Page components are in `src/app/` +- Use Tailwind for styling + +## Figma Implementation Flow + +1. Run get_design_context for the node +2. Run get_screenshot for visual reference +3. Map Figma colors to Tailwind colors defined in `tailwind.config.js` +4. Reuse components from `src/components/ui/` when possible +5. Validate against screenshot before completing + +## Styling Rules + +- IMPORTANT: Use Tailwind utility classes, not inline styles +- Colors are defined in `tailwind.config.js` theme.colors +- Spacing uses Tailwind's default scale +- Custom components go in `src/components/ui/` + +## Asset Rules + +- IMPORTANT: Use localhost sources from Figma MCP server directly +- Store static assets in `public/assets/` +- DO NOT install new icon libraries +``` + +4. Save to the appropriate rule file for the user's agent +5. Test with a simple button implementation + +**Result:** The agent now consistently follows the project's conventions when implementing Figma designs. + +### Example 2: Vue + Custom CSS Project + +User says: "Set up Figma rules for my Vue app" + +**Actions:** + +1. Run `create_design_system_rules(clientLanguages="typescript,javascript", clientFrameworks="vue")` +2. Discover that project uses CSS modules and a custom design token system +3. Generate rules: + +```markdown +# Figma MCP Integration Rules + +## Component Organization + +- Components are in `src/components/` +- Composables are in `src/composables/` +- Vue SFC structure: <script setup>, <template>, <style scoped> + +## Design Tokens + +- IMPORTANT: All colors defined in `src/styles/tokens.css` as CSS variables +- Use `var(--color-primary)`, `var(--color-secondary)`, etc. +- Spacing: `var(--space-xs)` through `var(--space-xl)` +- Typography: `var(--text-sm)` through `var(--text-2xl)` + +## Figma Implementation Flow + +1. Run get_design_context and get_screenshot +2. Translate React output to Vue 3 Composition API +3. Map Figma colors to CSS variables in `src/styles/tokens.css` +4. Use CSS Modules for component styles +5. Check for existing components in `src/components/` before creating new ones + +## Styling Rules + +- Use CSS Modules (`.module.css` files) +- IMPORTANT: Reference design tokens, never hardcode values +- Scoped styles with CSS modules +``` + +4. Save to the appropriate rule file for the user's agent +5. Validate with a card component + +**Result:** The agent now correctly translates Figma designs to Vue components using the project's design token system. + +### Example 3: Design System Team + +User says: "Generate rules for our design system library" + +**Actions:** + +1. Run `create_design_system_rules(clientLanguages="typescript", clientFrameworks="react")` +2. Analyze the monorepo structure with design system package +3. Generate comprehensive rules: + +```markdown +# Design System Rules + +## Repository Structure + +- Design system components: `packages/design-system/src/components/` +- Documentation: `packages/docs/` +- Design tokens: `packages/tokens/src/` + +## Component Development + +- IMPORTANT: All components must be in `packages/design-system/src/components/` +- Component file structure: `ComponentName/index.tsx`, `ComponentName.stories.tsx`, `ComponentName.test.tsx` +- Export all components from `packages/design-system/src/index.ts` + +## Design Tokens + +- Colors: `packages/tokens/src/colors.ts` +- Typography: `packages/tokens/src/typography.ts` +- Spacing: `packages/tokens/src/spacing.ts` +- IMPORTANT: Never hardcode values - import from tokens package + +## Documentation Requirements + +- Add Storybook story for every component +- Include JSDoc with @example +- Document all props with descriptions +- Add accessibility notes + +## Figma Integration + +1. Get design context and screenshot from Figma +2. Map Figma tokens to design system tokens +3. Create or extend component in design system package +4. Add Storybook stories showing all variants +5. Validate against Figma screenshot +6. Update documentation +``` + +4. Save to the appropriate rule file and share with team +5. Add to team documentation + +**Result:** Entire team follows consistent patterns when adding components from Figma to the design system. + +## Best Practices + +### Start Simple, Iterate + +Don't try to capture every rule upfront. Start with the most important conventions and add rules as you encounter inconsistencies. + +### Be Specific + +Instead of: "Use the design system" +Write: "Always use Button components from `src/components/ui/Button.tsx` with variant prop ('primary' | 'secondary' | 'ghost')" + +### Make Rules Actionable + +Each rule should tell the agent exactly what to do, not just what to avoid. + +Good: "Colors are defined in `src/theme/colors.ts` - import and use these constants" +Bad: "Don't hardcode colors" + +### Use IMPORTANT for Critical Rules + +Prefix rules that must never be violated with "IMPORTANT:" to ensure the agent prioritizes them. + +```markdown +- IMPORTANT: Never expose API keys in client-side code +- IMPORTANT: Always sanitize user input before rendering +``` + +### Document the Why + +When rules seem arbitrary, explain the reasoning: + +```markdown +- Place all data-fetching in server components (reduces client bundle size and improves performance) +- Use absolute imports with `@/` alias (makes refactoring easier and prevents broken relative paths) +``` + +## Common Issues and Solutions + +### Issue: The agent isn't following the rules + +**Cause:** Rules may be too vague or not properly loaded by the agent. +**Solution:** + +- Make rules more specific and actionable +- Verify rules are saved in the correct configuration file +- Restart your agent or IDE to reload rules +- Add "IMPORTANT:" prefix to critical rules + +### Issue: Rules conflict with each other + +**Cause:** Contradictory or overlapping rules. +**Solution:** + +- Review all rules for conflicts +- Establish a clear priority hierarchy +- Remove redundant rules +- Consolidate related rules into single, clear statements + +### Issue: Too many rules increase latency + +**Cause:** Excessive rules increase context size and processing time. +**Solution:** + +- Focus on the 20% of rules that solve 80% of consistency issues +- Remove overly specific rules that rarely apply +- Combine related rules +- Use progressive disclosure (basic rules first, advanced rules in linked files) + +### Issue: Rules become outdated as project evolves + +**Cause:** Codebase changes but rules don't. +**Solution:** + +- Schedule periodic rule reviews (monthly or quarterly) +- Update rules when architectural decisions change +- Version control your rule files +- Document rule changes in commit messages + +## Understanding Design System Rules + +Design system rules transform how AI coding agents work with your Figma designs: + +**Before rules:** + +- The agent makes assumptions about component structure +- Inconsistent styling approaches across implementations +- Hardcoded values that don't match design tokens +- Components created in random locations +- Repetitive explanations of project conventions + +**After rules:** + +- The agent automatically follows your conventions +- Consistent component structure and styling +- Proper use of design tokens from the start +- Components organized correctly +- Zero repetitive prompting + +The time invested in creating good rules pays off exponentially across every Figma implementation task. + +## Additional Resources + +- [Figma MCP Server Documentation](https://developers.figma.com/docs/figma-mcp-server/) +- [Figma Variables and Design Tokens](https://help.figma.com/hc/en-us/articles/15339657135383-Guide-to-variables-in-Figma) diff --git a/.claude/skills/doc-coauthoring/SKILL.md b/.claude/skills/doc-coauthoring/SKILL.md new file mode 100644 index 00000000..4d65362a --- /dev/null +++ b/.claude/skills/doc-coauthoring/SKILL.md @@ -0,0 +1,287 @@ +--- +name: doc-coauthoring +description: Guide users through a structured workflow for co-authoring documents such as proposals, tenders, technical specs, decision docs, or similar structured content. Helps users efficiently transfer context, refine content through iteration, and verify the document works for readers. Trigger when user mentions writing docs, creating proposals, drafting specs, preparing tenders, or similar documentation tasks. +license: Apache-2.0 +metadata: + source: https://github.com/anthropics/skills + author: Anthropic + modifications: Adapted for Open Elements projects with business communication rules +--- + +# Doc Co-Authoring Workflow + +This skill provides a structured workflow for guiding users through collaborative document creation. Act as an active guide, walking users through three stages: Context Gathering, Refinement & Structure, and Reader Testing. + +## When to Offer This Workflow + +**Trigger conditions:** +- User mentions writing documentation: "write a doc", "draft a proposal", "create a spec", "write up" +- User mentions specific doc types: "PRD", "design doc", "decision doc", "RFC", "tender", "Angebot", "Ausschreibung" +- User seems to be starting a substantial writing task + +**Initial offer:** +Offer the user a structured workflow for co-authoring the document. Explain the three stages: + +1. **Context Gathering**: User provides all relevant context while Claude asks clarifying questions +2. **Refinement & Structure**: Iteratively build each section through brainstorming and editing +3. **Reader Testing**: Test the doc with a fresh Claude (no context) to catch blind spots before others read it + +Explain that this approach helps ensure the doc works well when others read it. Ask if they want to try this workflow or prefer to work freeform. + +If user declines, work freeform. If user accepts, proceed to Stage 1. + +## Business Communication Rules + +**IMPORTANT:** For any document that represents Open Elements externally (proposals, tenders, presentations, cover letters), load and apply the rules from `business-communication.md` throughout all stages. These rules govern truthfulness, confidentiality, transparency, attribution, tone, and language. + +Key rules to keep in mind at all times: +- Every factual claim must be verifiable. Do not invent achievements, partnerships, certifications, or capabilities. +- Cross-check facts against the `open-elements-info` skill as the primary source of truth. +- Never include customer names or confidential details without explicit approval. +- Use the full legal name "Open Elements GmbH" in formal documents. +- Document language follows the target audience (German or English). +- Avoid marketing buzzwords. Let concrete facts speak for themselves. + +## Stage 1: Context Gathering + +**Goal:** Close the gap between what the user knows and what Claude knows, enabling smart guidance later. + +### Initial Questions + +Start by asking the user for meta-context about the document: + +1. What type of document is this? (e.g., technical spec, decision doc, proposal, tender response) +2. Who is the primary audience? +3. What is the desired impact when someone reads this? +4. Is there a template or specific format to follow? +5. What language should the document be in? (German for German-speaking recipients, English for international contexts) +6. Any other constraints or context to know? + +Inform them they can answer in shorthand or dump information however works best for them. + +**If user provides a template or reference document:** +- Read the provided file +- If it is a tender document with evaluation criteria, extract and list all criteria explicitly — these will guide the entire drafting process + +**If the document is a tender response or formal submission:** +- Identify all evaluation criteria and scoring levels from the tender document +- Create a tracking list of criteria to ensure each one is explicitly addressed +- Use the same terminology as the evaluation criteria where possible + +### Info Dumping + +Once initial questions are answered, encourage the user to dump all the context they have. Request information such as: +- Background on the project or problem +- Related discussions or documents +- Why alternative approaches are not being used +- Organizational context (stakeholder concerns, timeline pressures) +- Technical architecture or dependencies +- For tenders: the complete tender document, evaluation matrix, and any Q&A responses + +Advise them not to worry about organizing it — just get it all out. + +**During context gathering:** + +- If user mentions entities, projects, or facts about Open Elements: cross-check against the `open-elements-info` skill before proceeding +- As user provides context, track what has been learned and what is still unclear +- Flag any claims that cannot be verified and ask the user for confirmation + +**Asking clarifying questions:** + +When user signals they have done their initial dump, ask clarifying questions to ensure understanding: + +Generate 5-10 numbered questions based on gaps in the context. + +Inform them they can use shorthand to answer (e.g., "1: yes, 2: no because backwards compat, 3: see attached doc"). + +**Exit condition:** +Sufficient context has been gathered when questions show understanding — when edge cases and trade-offs can be asked about without needing basics explained. + +**Transition:** +Ask if there is any more context they want to provide at this stage, or if it is time to move on to drafting the document. + +## Stage 2: Refinement & Structure + +**Goal:** Build the document section by section through brainstorming, curation, and iterative refinement. + +**Instructions to user:** +Explain that the document will be built section by section. For each section: +1. Clarifying questions will be asked about what to include +2. 5-20 options will be brainstormed +3. User will indicate what to keep, remove, or combine +4. The section will be drafted +5. It will be refined through surgical edits + +Start with whichever section has the most unknowns, then work through the rest. + +**Section ordering:** + +If the document structure is clear (e.g., from a template or tender requirements): +Ask which section they would like to start with. Suggest starting with whichever section has the most unknowns. + +If user does not know what sections they need: +Based on the type of document, suggest 3-5 sections appropriate for the doc type. Ask if this structure works or if they want to adjust it. + +**Once structure is agreed:** + +Create the document as a markdown file in the working directory. Name it appropriately (e.g., `decision-doc.md`, `technical-spec.md`, `tender-response.md`). + +Create the file with all section headers and brief placeholder text like "[To be written]". + +Confirm the file has been created and indicate it is time to fill in each section. + +**For each section:** + +### Step 1: Clarifying Questions + +Announce work will begin on the section. Ask 5-10 clarifying questions about what should be included. + +### Step 2: Brainstorming + +Brainstorm 5-20 things that might be included, depending on the section's complexity. Look for: +- Context shared that might have been forgotten +- Angles or considerations not yet mentioned +- For business documents: concrete, verifiable examples from past work that demonstrate claimed capabilities + +### Step 3: Curation + +Ask which points should be kept, removed, or combined. Request brief justifications to help learn priorities for the next sections. + +**If user gives freeform feedback** instead of numbered selections, extract their preferences and proceed. + +### Step 4: Gap Check + +Based on what they have selected, ask if there is anything important missing for this section. + +**For tender responses:** Check the selected content against the evaluation criteria. Flag any criteria that are not yet addressed and ask the user how to handle them. + +### Step 5: Drafting + +Use `str_replace` to replace the placeholder text with the actual drafted content. + +After drafting, confirm completion and ask the user to read through it and indicate what to change. + +**Key instruction for user (include when drafting the first section):** +Instead of editing the doc directly, ask them to indicate what to change. This helps learning of their style for future sections. + +### Step 6: Iterative Refinement + +As user provides feedback: +- Use `str_replace` to make edits (never reprint the whole doc) +- Confirm edits are complete after each change + +**Continue iterating** until user is satisfied with the section. + +### Quality Checking + +After 3 consecutive iterations with no substantial changes, ask if anything can be removed without losing important information. + +When section is done, confirm it is complete and ask if ready to move to the next section. + +**Repeat for all sections.** + +### Near Completion + +As approaching completion (80%+ of sections done), re-read the entire document and check for: +- Flow and consistency across sections +- Redundancy or contradictions +- Generic filler that does not carry weight +- Whether every sentence adds value + +**For business documents, additionally check against the review checklist from `business-communication.md`:** +- All stated facts match information from the `open-elements-info` skill or other confirmed sources +- No claims are exaggerated or misleading +- The tone is consistent — professional, honest, and confident +- Foundation roles and memberships are stated with correct titles +- Team members are referenced with their correct names and roles +- Customer names or confidential details are not disclosed without approval +- The full legal name "Open Elements GmbH" is used in formal contexts +- The document language is appropriate for the target audience and consistent throughout +- Facts are current — not copied from outdated sources without verification + +**For tender responses, additionally verify:** +- Each evaluation criterion is explicitly addressed in the response +- The text uses the same terminology as the evaluation criteria +- For each claimed capability or process, at least one concrete, verifiable example is included + +Provide any findings and suggestions. + +When all sections are drafted and refined, ask if ready to move to Reader Testing, or if they want to refine anything else. + +## Stage 3: Reader Testing + +**Goal:** Test the document with a fresh Claude (no context bleed) to verify it works for readers. + +Explain that testing will now occur to see if the document actually works for readers. This catches blind spots — things that make sense to the authors but might confuse others. + +### Step 1: Predict Reader Questions + +Predict what questions readers might ask when reading this document. + +Generate 5-10 questions that readers would realistically ask. For tender responses, include questions an evaluator would ask when scoring against the criteria. + +### Step 2: Test with Sub-Agent + +Test these questions with a fresh Claude instance (no context from this conversation). + +For each question, invoke a sub-agent with just the document content and the question. + +Summarize what the reader agent got right and wrong for each question. + +### Step 3: Run Additional Checks + +Invoke a sub-agent to check for: +- Ambiguity or unclear passages +- False assumptions about reader knowledge +- Internal contradictions or inconsistencies + +**For business documents, also check:** +- Whether any claims could be perceived as exaggerated or unverifiable +- Whether the tone is consistent and appropriate for the audience +- Whether Open Elements' role is clearly distinguished from broader community contributions + +### Step 4: Report and Fix + +If issues are found: +- Report the specific issues +- Loop back to refinement for problematic sections + +### Exit Condition + +When the reader agent consistently answers questions correctly and does not surface new gaps or ambiguities, the doc is ready. + +## Final Review + +When Reader Testing passes: + +1. Recommend they do a final read-through themselves — they own this document and are responsible for its quality +2. Suggest double-checking any facts, links, or technical details +3. For business documents: remind them to verify that no confidential information has been included without approval +4. Ask them to verify it achieves the impact they wanted + +**If user wants a final review, provide it. Otherwise:** + +Announce document completion. Provide a few final tips: +- Update the document as feedback is received from real readers +- For tender responses: consider having a colleague review before submission + +## Tips for Effective Guidance + +**Tone:** +- Be direct and procedural +- Explain rationale briefly when it affects user behavior +- Do not try to "sell" the approach — just execute it + +**Handling Deviations:** +- If user wants to skip a stage: ask if they want to skip and write freeform +- If user seems frustrated: acknowledge this is taking longer than expected and suggest ways to move faster +- Always give user agency to adjust the process + +**Context Management:** +- Throughout, if context is missing on something mentioned, proactively ask +- Do not let gaps accumulate — address them as they come up + +**Quality over Speed:** +- Do not rush through stages +- Each iteration should make meaningful improvements +- The goal is a document that actually works for readers diff --git a/.claude/skills/doc-coauthoring/business-communication.md b/.claude/skills/doc-coauthoring/business-communication.md new file mode 100644 index 00000000..66f2720d --- /dev/null +++ b/.claude/skills/doc-coauthoring/business-communication.md @@ -0,0 +1,87 @@ +# Business Communication + +Rules for creating and reviewing business documents such as proposals, tenders, company presentations, cover letters, and other external communication representing Open Elements. + +## Truthfulness + +- Every factual claim must be verifiable. Do not invent achievements, partnerships, certifications, or capabilities that are not documented. +- Do not exaggerate team size, project scope, or the company's role in a project. State contributions accurately. +- If specific numbers (revenue, users, projects) are not confirmed, do not include them. Ask the user for confirmation instead of guessing. +- When in doubt, ask. It is always better to ask one question too many than to publish an incorrect or unverifiable statement. +- Quotes and testimonials must be real. Never fabricate or paraphrase quotes in a way that changes their meaning. +- Proactively include verifiable evidence (links to pull requests, project boards, public reports, repositories) to back claims. Do not just avoid falsehoods — actively prove what you state. +- When describing capabilities, name the specific people, roles, or project experiences that demonstrate them. "One of our team members is a JUnit maintainer" is stronger and more honest than "we have testing expertise." +- Support abstract methodology descriptions with concrete examples from past work. "We do X" should be followed by "as demonstrated in project Y (link)." + +## Confidentiality + +- Never include customer names, project details, or financial figures without explicit approval from the user. +- Assume all client relationships are confidential unless stated otherwise. +- Do not reference NDA-covered information. When in doubt whether something is confidential, ask before including it. + +## Transparency + +- Be open about what Open Elements is: a small, specialized company — not a large corporation. This is a strength, not a weakness. +- Clearly distinguish between what Open Elements does directly and what is done by the broader open-source communities we contribute to. +- Do not obscure or hide limitations. If something is outside our expertise, do not imply otherwise. +- When referencing foundation memberships or board seats, state the actual role accurately (e.g., "participant member" vs. "board member"). + +## Attribution + +- When referencing contributions to open-source projects or foundations, accurately credit who did what. +- Do not claim credit for community achievements. Clearly separate Open Elements' contributions from the work of the broader community. +- When mentioning partnerships or collaborations, name all relevant parties. + +## Positive Representation + +- Emphasize the company's genuine strengths: deep Java and OSS expertise, foundation involvement, sustainable reinvestment in open source, and direct contributions to critical infrastructure. +- Frame the company's size and focus as advantages: specialized knowledge, direct access to decision-makers, personal commitment. +- Highlight the values behind the work — sustainability, open collaboration, community building — not just technical deliverables. +- Use confident, professional language. Avoid self-deprecating or overly cautious phrasing that undermines credibility. + +## Tone and Style + +- Professional but approachable. Open Elements is not a faceless enterprise — the tone should reflect real people with genuine passion for open source. +- Avoid marketing buzzwords and empty superlatives ("industry-leading", "world-class", "cutting-edge"). Let concrete facts speak for themselves. +- Write clearly and concisely. Prefer short sentences over complex constructions. +- When writing in German, use clear, modern business German. Avoid unnecessary Anglicisms but keep established technical terms in English (e.g., "Open Source", "Java", "CI/CD"). + +## Language + +- The document language follows the target audience. German for German-speaking recipients, English for international contexts. +- If the target audience is unclear, ask before writing. +- Stay consistent within a single document — do not mix languages. +- In formal documents always use the full legal name "Open Elements GmbH", not just "Open Elements". + +## Audience + +- Always consider who will read the document. A tender response for a government agency requires a different tone and structure than a pitch to a startup. +- If the target audience is not clear from context, ask before drafting. +- Adapt level of technical detail to the audience — do not assume deep Java or OSS knowledge unless the audience clearly has it. + +## Accuracy and Currency + +- Before reusing content from previous documents, verify that the facts are still current. Team composition, foundation roles, and project status change over time. +- Always cross-check facts against the `open-elements-info` skill as the primary source of truth. +- If information might be outdated, flag it and ask the user to confirm before including it. + +## Tenders and Formal Submissions + +- When a document defines evaluation criteria or scoring levels, systematically verify that each criterion is explicitly addressed in the response. Do not assume implicit coverage — if a criterion asks for "multi-level validation," the text must name and describe those levels. +- After drafting, compare each section against the highest evaluation level (e.g., "Exceptional") point by point. Identify gaps and flag them before finalization. +- Structure responses so that evaluators can easily map the text to the criteria. Use the same terminology as the evaluation criteria where possible. +- For each claimed capability or process, include at least one concrete, verifiable example from past work. + +## Review Checklist + +When reviewing business documents, verify: + +- All stated facts match information from the `open-elements-info` skill or other confirmed sources. +- No claims are exaggerated or misleading. +- The tone is consistent — professional, honest, and confident. +- Foundation roles and memberships are stated with correct titles. +- Team members are referenced with their correct names and roles. +- Customer names or confidential details are not disclosed without approval. +- The full legal name "Open Elements GmbH" is used in formal contexts. +- The document language is appropriate for the target audience and consistent throughout. +- Facts are current — not copied from outdated sources without verification. diff --git a/.claude/skills/docx/LICENSE.txt b/.claude/skills/docx/LICENSE.txt new file mode 100644 index 00000000..c55ab422 --- /dev/null +++ b/.claude/skills/docx/LICENSE.txt @@ -0,0 +1,30 @@ +© 2025 Anthropic, PBC. All rights reserved. + +LICENSE: Use of these materials (including all code, prompts, assets, files, +and other components of this Skill) is governed by your agreement with +Anthropic regarding use of Anthropic's services. If no separate agreement +exists, use is governed by Anthropic's Consumer Terms of Service or +Commercial Terms of Service, as applicable: +https://www.anthropic.com/legal/consumer-terms +https://www.anthropic.com/legal/commercial-terms +Your applicable agreement is referred to as the "Agreement." "Services" are +as defined in the Agreement. + +ADDITIONAL RESTRICTIONS: Notwithstanding anything in the Agreement to the +contrary, users may not: + +- Extract these materials from the Services or retain copies of these + materials outside the Services +- Reproduce or copy these materials, except for temporary copies created + automatically during authorized use of the Services +- Create derivative works based on these materials +- Distribute, sublicense, or transfer these materials to any third party +- Make, offer to sell, sell, or import any inventions embodied in these + materials +- Reverse engineer, decompile, or disassemble these materials + +The receipt, viewing, or possession of these materials does not convey or +imply any license or right beyond those expressly granted above. + +Anthropic retains all right, title, and interest in these materials, +including all copyrights, patents, and other intellectual property rights. diff --git a/.claude/skills/docx/SKILL.md b/.claude/skills/docx/SKILL.md new file mode 100644 index 00000000..47ef31d1 --- /dev/null +++ b/.claude/skills/docx/SKILL.md @@ -0,0 +1,594 @@ +--- +name: docx +description: "Use this skill whenever the user wants to create, read, edit, or manipulate Word documents (.docx files). Triggers include: any mention of 'Word doc', 'word document', '.docx', or requests to produce professional documents with formatting like tables of contents, headings, page numbers, or letterheads. Also use when extracting or reorganizing content from .docx files, inserting or replacing images in documents, performing find-and-replace in Word files, working with tracked changes or comments, or converting content into a polished Word document. If the user asks for a 'report', 'memo', 'letter', 'template', or similar deliverable as a Word or .docx file, use this skill. Do NOT use for PDFs, spreadsheets, Google Docs, or general coding tasks unrelated to document generation." +license: Proprietary. LICENSE.txt has complete terms +metadata: + source: https://github.com/anthropics/skills + author: Anthropic + modifications: None +--- + +# DOCX creation, editing, and analysis + +## Overview + +A .docx file is a ZIP archive containing XML files. + +## Quick Reference + +| Task | Approach | +|------|----------| +| Read/analyze content | `pandoc` or unpack for raw XML | +| Create new document | Use `docx-js` - see Creating New Documents below | +| Edit existing document | Unpack → edit XML → repack - see Editing Existing Documents below | + +### Converting .doc to .docx + +Legacy `.doc` files must be converted before editing: + +```bash +python scripts/office/soffice.py --headless --convert-to docx document.doc +``` + +### Reading Content + +```bash +# Text extraction with tracked changes +pandoc --track-changes=all document.docx -o output.md + +# Raw XML access +python scripts/office/unpack.py document.docx unpacked/ +``` + +### Converting to Images + +```bash +python scripts/office/soffice.py --headless --convert-to pdf document.docx +pdftoppm -jpeg -r 150 document.pdf page +``` + +### Accepting Tracked Changes + +To produce a clean document with all tracked changes accepted (requires LibreOffice): + +```bash +python scripts/accept_changes.py input.docx output.docx +``` + +--- + +## Creating New Documents + +Generate .docx files with JavaScript, then validate. Install: `npm install -g docx` + +### Setup +```javascript +const { Document, Packer, Paragraph, TextRun, Table, TableRow, TableCell, ImageRun, + Header, Footer, AlignmentType, PageOrientation, LevelFormat, ExternalHyperlink, + InternalHyperlink, Bookmark, FootnoteReferenceRun, PositionalTab, + PositionalTabAlignment, PositionalTabRelativeTo, PositionalTabLeader, + TabStopType, TabStopPosition, Column, SectionType, + TableOfContents, HeadingLevel, BorderStyle, WidthType, ShadingType, + VerticalAlign, PageNumber, PageBreak } = require('docx'); + +const doc = new Document({ sections: [{ children: [/* content */] }] }); +Packer.toBuffer(doc).then(buffer => fs.writeFileSync("doc.docx", buffer)); +``` + +### Validation +After creating the file, validate it. If validation fails, unpack, fix the XML, and repack. +```bash +python scripts/office/validate.py doc.docx +``` + +### Page Size + +```javascript +// CRITICAL: docx-js defaults to A4, not US Letter +// Always set page size explicitly for consistent results +sections: [{ + properties: { + page: { + size: { + width: 12240, // 8.5 inches in DXA + height: 15840 // 11 inches in DXA + }, + margin: { top: 1440, right: 1440, bottom: 1440, left: 1440 } // 1 inch margins + } + }, + children: [/* content */] +}] +``` + +**Common page sizes (DXA units, 1440 DXA = 1 inch):** + +| Paper | Width | Height | Content Width (1" margins) | +|-------|-------|--------|---------------------------| +| US Letter | 12,240 | 15,840 | 9,360 | +| A4 (default) | 11,906 | 16,838 | 9,026 | + +**Landscape orientation:** docx-js swaps width/height internally, so pass portrait dimensions and let it handle the swap: +```javascript +size: { + width: 12240, // Pass SHORT edge as width + height: 15840, // Pass LONG edge as height + orientation: PageOrientation.LANDSCAPE // docx-js swaps them in the XML +}, +// Content width = 15840 - left margin - right margin (uses the long edge) +``` + +### Styles (Override Built-in Headings) + +Use Arial as the default font (universally supported). Keep titles black for readability. + +```javascript +const doc = new Document({ + styles: { + default: { document: { run: { font: "Arial", size: 24 } } }, // 12pt default + paragraphStyles: [ + // IMPORTANT: Use exact IDs to override built-in styles + { id: "Heading1", name: "Heading 1", basedOn: "Normal", next: "Normal", quickFormat: true, + run: { size: 32, bold: true, font: "Arial" }, + paragraph: { spacing: { before: 240, after: 240 }, outlineLevel: 0 } }, // outlineLevel required for TOC + { id: "Heading2", name: "Heading 2", basedOn: "Normal", next: "Normal", quickFormat: true, + run: { size: 28, bold: true, font: "Arial" }, + paragraph: { spacing: { before: 180, after: 180 }, outlineLevel: 1 } }, + ] + }, + sections: [{ + children: [ + new Paragraph({ heading: HeadingLevel.HEADING_1, children: [new TextRun("Title")] }), + ] + }] +}); +``` + +### Lists (NEVER use unicode bullets) + +```javascript +// ❌ WRONG - never manually insert bullet characters +new Paragraph({ children: [new TextRun("• Item")] }) // BAD +new Paragraph({ children: [new TextRun("\u2022 Item")] }) // BAD + +// ✅ CORRECT - use numbering config with LevelFormat.BULLET +const doc = new Document({ + numbering: { + config: [ + { reference: "bullets", + levels: [{ level: 0, format: LevelFormat.BULLET, text: "•", alignment: AlignmentType.LEFT, + style: { paragraph: { indent: { left: 720, hanging: 360 } } } }] }, + { reference: "numbers", + levels: [{ level: 0, format: LevelFormat.DECIMAL, text: "%1.", alignment: AlignmentType.LEFT, + style: { paragraph: { indent: { left: 720, hanging: 360 } } } }] }, + ] + }, + sections: [{ + children: [ + new Paragraph({ numbering: { reference: "bullets", level: 0 }, + children: [new TextRun("Bullet item")] }), + new Paragraph({ numbering: { reference: "numbers", level: 0 }, + children: [new TextRun("Numbered item")] }), + ] + }] +}); + +// ⚠️ Each reference creates INDEPENDENT numbering +// Same reference = continues (1,2,3 then 4,5,6) +// Different reference = restarts (1,2,3 then 1,2,3) +``` + +### Tables + +**CRITICAL: Tables need dual widths** - set both `columnWidths` on the table AND `width` on each cell. Without both, tables render incorrectly on some platforms. + +```javascript +// CRITICAL: Always set table width for consistent rendering +// CRITICAL: Use ShadingType.CLEAR (not SOLID) to prevent black backgrounds +const border = { style: BorderStyle.SINGLE, size: 1, color: "CCCCCC" }; +const borders = { top: border, bottom: border, left: border, right: border }; + +new Table({ + width: { size: 9360, type: WidthType.DXA }, // Always use DXA (percentages break in Google Docs) + columnWidths: [4680, 4680], // Must sum to table width (DXA: 1440 = 1 inch) + rows: [ + new TableRow({ + children: [ + new TableCell({ + borders, + width: { size: 4680, type: WidthType.DXA }, // Also set on each cell + shading: { fill: "D5E8F0", type: ShadingType.CLEAR }, // CLEAR not SOLID + margins: { top: 80, bottom: 80, left: 120, right: 120 }, // Cell padding (internal, not added to width) + children: [new Paragraph({ children: [new TextRun("Cell")] })] + }) + ] + }) + ] +}) +``` + +**Table width calculation:** + +Always use `WidthType.DXA` — `WidthType.PERCENTAGE` breaks in Google Docs. + +```javascript +// Table width = sum of columnWidths = content width +// US Letter with 1" margins: 12240 - 2880 = 9360 DXA +width: { size: 9360, type: WidthType.DXA }, +columnWidths: [7000, 2360] // Must sum to table width +``` + +**Width rules:** +- **Always use `WidthType.DXA`** — never `WidthType.PERCENTAGE` (incompatible with Google Docs) +- Table width must equal the sum of `columnWidths` +- Cell `width` must match corresponding `columnWidth` +- Cell `margins` are internal padding - they reduce content area, not add to cell width +- For full-width tables: use content width (page width minus left and right margins) + +### Images + +```javascript +// CRITICAL: type parameter is REQUIRED +new Paragraph({ + children: [new ImageRun({ + type: "png", // Required: png, jpg, jpeg, gif, bmp, svg + data: fs.readFileSync("image.png"), + transformation: { width: 200, height: 150 }, + altText: { title: "Title", description: "Desc", name: "Name" } // All three required + })] +}) +``` + +### Page Breaks + +```javascript +// CRITICAL: PageBreak must be inside a Paragraph +new Paragraph({ children: [new PageBreak()] }) + +// Or use pageBreakBefore +new Paragraph({ pageBreakBefore: true, children: [new TextRun("New page")] }) +``` + +### Hyperlinks + +```javascript +// External link +new Paragraph({ + children: [new ExternalHyperlink({ + children: [new TextRun({ text: "Click here", style: "Hyperlink" })], + link: "https://example.com", + })] +}) + +// Internal link (bookmark + reference) +// 1. Create bookmark at destination +new Paragraph({ heading: HeadingLevel.HEADING_1, children: [ + new Bookmark({ id: "chapter1", children: [new TextRun("Chapter 1")] }), +]}) +// 2. Link to it +new Paragraph({ children: [new InternalHyperlink({ + children: [new TextRun({ text: "See Chapter 1", style: "Hyperlink" })], + anchor: "chapter1", +})]}) +``` + +### Footnotes + +```javascript +const doc = new Document({ + footnotes: { + 1: { children: [new Paragraph("Source: Annual Report 2024")] }, + 2: { children: [new Paragraph("See appendix for methodology")] }, + }, + sections: [{ + children: [new Paragraph({ + children: [ + new TextRun("Revenue grew 15%"), + new FootnoteReferenceRun(1), + new TextRun(" using adjusted metrics"), + new FootnoteReferenceRun(2), + ], + })] + }] +}); +``` + +### Tab Stops + +```javascript +// Right-align text on same line (e.g., date opposite a title) +new Paragraph({ + children: [ + new TextRun("Company Name"), + new TextRun("\tJanuary 2025"), + ], + tabStops: [{ type: TabStopType.RIGHT, position: TabStopPosition.MAX }], +}) + +// Dot leader (e.g., TOC-style) +new Paragraph({ + children: [ + new TextRun("Introduction"), + new TextRun({ children: [ + new PositionalTab({ + alignment: PositionalTabAlignment.RIGHT, + relativeTo: PositionalTabRelativeTo.MARGIN, + leader: PositionalTabLeader.DOT, + }), + "3", + ]}), + ], +}) +``` + +### Multi-Column Layouts + +```javascript +// Equal-width columns +sections: [{ + properties: { + column: { + count: 2, // number of columns + space: 720, // gap between columns in DXA (720 = 0.5 inch) + equalWidth: true, + separate: true, // vertical line between columns + }, + }, + children: [/* content flows naturally across columns */] +}] + +// Custom-width columns (equalWidth must be false) +sections: [{ + properties: { + column: { + equalWidth: false, + children: [ + new Column({ width: 5400, space: 720 }), + new Column({ width: 3240 }), + ], + }, + }, + children: [/* content */] +}] +``` + +Force a column break with a new section using `type: SectionType.NEXT_COLUMN`. + +### Table of Contents + +```javascript +// CRITICAL: Headings must use HeadingLevel ONLY - no custom styles +new TableOfContents("Table of Contents", { hyperlink: true, headingStyleRange: "1-3" }) +``` + +### Headers/Footers + +```javascript +sections: [{ + properties: { + page: { margin: { top: 1440, right: 1440, bottom: 1440, left: 1440 } } // 1440 = 1 inch + }, + headers: { + default: new Header({ children: [new Paragraph({ children: [new TextRun("Header")] })] }) + }, + footers: { + default: new Footer({ children: [new Paragraph({ + children: [new TextRun("Page "), new TextRun({ children: [PageNumber.CURRENT] })] + })] }) + }, + children: [/* content */] +}] +``` + +### Critical Rules for docx-js + +- **Set page size explicitly** - docx-js defaults to A4; use US Letter (12240 x 15840 DXA) for US documents +- **Landscape: pass portrait dimensions** - docx-js swaps width/height internally; pass short edge as `width`, long edge as `height`, and set `orientation: PageOrientation.LANDSCAPE` +- **Never use `\n`** - use separate Paragraph elements +- **Never use unicode bullets** - use `LevelFormat.BULLET` with numbering config +- **PageBreak must be in Paragraph** - standalone creates invalid XML +- **ImageRun requires `type`** - always specify png/jpg/etc +- **Always set table `width` with DXA** - never use `WidthType.PERCENTAGE` (breaks in Google Docs) +- **Tables need dual widths** - `columnWidths` array AND cell `width`, both must match +- **Table width = sum of columnWidths** - for DXA, ensure they add up exactly +- **Always add cell margins** - use `margins: { top: 80, bottom: 80, left: 120, right: 120 }` for readable padding +- **Use `ShadingType.CLEAR`** - never SOLID for table shading +- **Never use tables as dividers/rules** - cells have minimum height and render as empty boxes (including in headers/footers); use `border: { bottom: { style: BorderStyle.SINGLE, size: 6, color: "2E75B6", space: 1 } }` on a Paragraph instead. For two-column footers, use tab stops (see Tab Stops section), not tables +- **TOC requires HeadingLevel only** - no custom styles on heading paragraphs +- **Override built-in styles** - use exact IDs: "Heading1", "Heading2", etc. +- **Include `outlineLevel`** - required for TOC (0 for H1, 1 for H2, etc.) + +--- + +## Editing Existing Documents + +**Follow all 3 steps in order.** + +### Step 1: Unpack +```bash +python scripts/office/unpack.py document.docx unpacked/ +``` +Extracts XML, pretty-prints, merges adjacent runs, and converts smart quotes to XML entities (`“` etc.) so they survive editing. Use `--merge-runs false` to skip run merging. + +### Step 2: Edit XML + +Edit files in `unpacked/word/`. See XML Reference below for patterns. + +**Use "Claude" as the author** for tracked changes and comments, unless the user explicitly requests use of a different name. + +**Use the Edit tool directly for string replacement. Do not write Python scripts.** Scripts introduce unnecessary complexity. The Edit tool shows exactly what is being replaced. + +**CRITICAL: Use smart quotes for new content.** When adding text with apostrophes or quotes, use XML entities to produce smart quotes: +```xml +<!-- Use these entities for professional typography --> +<w:t>Here’s a quote: “Hello”</w:t> +``` +| Entity | Character | +|--------|-----------| +| `‘` | ‘ (left single) | +| `’` | ’ (right single / apostrophe) | +| `“` | “ (left double) | +| `”` | ” (right double) | + +**Adding comments:** Use `comment.py` to handle boilerplate across multiple XML files (text must be pre-escaped XML): +```bash +python scripts/comment.py unpacked/ 0 "Comment text with & and ’" +python scripts/comment.py unpacked/ 1 "Reply text" --parent 0 # reply to comment 0 +python scripts/comment.py unpacked/ 0 "Text" --author "Custom Author" # custom author name +``` +Then add markers to document.xml (see Comments in XML Reference). + +### Step 3: Pack +```bash +python scripts/office/pack.py unpacked/ output.docx --original document.docx +``` +Validates with auto-repair, condenses XML, and creates DOCX. Use `--validate false` to skip. + +**Auto-repair will fix:** +- `durableId` >= 0x7FFFFFFF (regenerates valid ID) +- Missing `xml:space="preserve"` on `<w:t>` with whitespace + +**Auto-repair won't fix:** +- Malformed XML, invalid element nesting, missing relationships, schema violations + +### Common Pitfalls + +- **Replace entire `<w:r>` elements**: When adding tracked changes, replace the whole `<w:r>...</w:r>` block with `<w:del>...<w:ins>...` as siblings. Don't inject tracked change tags inside a run. +- **Preserve `<w:rPr>` formatting**: Copy the original run's `<w:rPr>` block into your tracked change runs to maintain bold, font size, etc. + +--- + +## XML Reference + +### Schema Compliance + +- **Element order in `<w:pPr>`**: `<w:pStyle>`, `<w:numPr>`, `<w:spacing>`, `<w:ind>`, `<w:jc>`, `<w:rPr>` last +- **Whitespace**: Add `xml:space="preserve"` to `<w:t>` with leading/trailing spaces +- **RSIDs**: Must be 8-digit hex (e.g., `00AB1234`) + +### Tracked Changes + +**Insertion:** +```xml +<w:ins w:id="1" w:author="Claude" w:date="2025-01-01T00:00:00Z"> + <w:r><w:t>inserted text</w:t></w:r> +</w:ins> +``` + +**Deletion:** +```xml +<w:del w:id="2" w:author="Claude" w:date="2025-01-01T00:00:00Z"> + <w:r><w:delText>deleted text</w:delText></w:r> +</w:del> +``` + +**Inside `<w:del>`**: Use `<w:delText>` instead of `<w:t>`, and `<w:delInstrText>` instead of `<w:instrText>`. + +**Minimal edits** - only mark what changes: +```xml +<!-- Change "30 days" to "60 days" --> +<w:r><w:t>The term is </w:t></w:r> +<w:del w:id="1" w:author="Claude" w:date="..."> + <w:r><w:delText>30</w:delText></w:r> +</w:del> +<w:ins w:id="2" w:author="Claude" w:date="..."> + <w:r><w:t>60</w:t></w:r> +</w:ins> +<w:r><w:t> days.</w:t></w:r> +``` + +**Deleting entire paragraphs/list items** - when removing ALL content from a paragraph, also mark the paragraph mark as deleted so it merges with the next paragraph. Add `<w:del/>` inside `<w:pPr><w:rPr>`: +```xml +<w:p> + <w:pPr> + <w:numPr>...</w:numPr> <!-- list numbering if present --> + <w:rPr> + <w:del w:id="1" w:author="Claude" w:date="2025-01-01T00:00:00Z"/> + </w:rPr> + </w:pPr> + <w:del w:id="2" w:author="Claude" w:date="2025-01-01T00:00:00Z"> + <w:r><w:delText>Entire paragraph content being deleted...</w:delText></w:r> + </w:del> +</w:p> +``` +Without the `<w:del/>` in `<w:pPr><w:rPr>`, accepting changes leaves an empty paragraph/list item. + +**Rejecting another author's insertion** - nest deletion inside their insertion: +```xml +<w:ins w:author="Jane" w:id="5"> + <w:del w:author="Claude" w:id="10"> + <w:r><w:delText>their inserted text</w:delText></w:r> + </w:del> +</w:ins> +``` + +**Restoring another author's deletion** - add insertion after (don't modify their deletion): +```xml +<w:del w:author="Jane" w:id="5"> + <w:r><w:delText>deleted text</w:delText></w:r> +</w:del> +<w:ins w:author="Claude" w:id="10"> + <w:r><w:t>deleted text</w:t></w:r> +</w:ins> +``` + +### Comments + +After running `comment.py` (see Step 2), add markers to document.xml. For replies, use `--parent` flag and nest markers inside the parent's. + +**CRITICAL: `<w:commentRangeStart>` and `<w:commentRangeEnd>` are siblings of `<w:r>`, never inside `<w:r>`.** + +```xml +<!-- Comment markers are direct children of w:p, never inside w:r --> +<w:commentRangeStart w:id="0"/> +<w:del w:id="1" w:author="Claude" w:date="2025-01-01T00:00:00Z"> + <w:r><w:delText>deleted</w:delText></w:r> +</w:del> +<w:r><w:t> more text</w:t></w:r> +<w:commentRangeEnd w:id="0"/> +<w:r><w:rPr><w:rStyle w:val="CommentReference"/></w:rPr><w:commentReference w:id="0"/></w:r> + +<!-- Comment 0 with reply 1 nested inside --> +<w:commentRangeStart w:id="0"/> + <w:commentRangeStart w:id="1"/> + <w:r><w:t>text</w:t></w:r> + <w:commentRangeEnd w:id="1"/> +<w:commentRangeEnd w:id="0"/> +<w:r><w:rPr><w:rStyle w:val="CommentReference"/></w:rPr><w:commentReference w:id="0"/></w:r> +<w:r><w:rPr><w:rStyle w:val="CommentReference"/></w:rPr><w:commentReference w:id="1"/></w:r> +``` + +### Images + +1. Add image file to `word/media/` +2. Add relationship to `word/_rels/document.xml.rels`: +```xml +<Relationship Id="rId5" Type=".../image" Target="media/image1.png"/> +``` +3. Add content type to `[Content_Types].xml`: +```xml +<Default Extension="png" ContentType="image/png"/> +``` +4. Reference in document.xml: +```xml +<w:drawing> + <wp:inline> + <wp:extent cx="914400" cy="914400"/> <!-- EMUs: 914400 = 1 inch --> + <a:graphic> + <a:graphicData uri=".../picture"> + <pic:pic> + <pic:blipFill><a:blip r:embed="rId5"/></pic:blipFill> + </pic:pic> + </a:graphicData> + </a:graphic> + </wp:inline> +</w:drawing> +``` + +--- + +## Dependencies + +- **pandoc**: Text extraction +- **docx**: `npm install -g docx` (new documents) +- **LibreOffice**: PDF conversion (auto-configured for sandboxed environments via `scripts/office/soffice.py`) +- **Poppler**: `pdftoppm` for images diff --git a/.claude/skills/docx/scripts/__init__.py b/.claude/skills/docx/scripts/__init__.py new file mode 100755 index 00000000..8b137891 --- /dev/null +++ b/.claude/skills/docx/scripts/__init__.py @@ -0,0 +1 @@ + diff --git a/.claude/skills/docx/scripts/accept_changes.py b/.claude/skills/docx/scripts/accept_changes.py new file mode 100755 index 00000000..8e363161 --- /dev/null +++ b/.claude/skills/docx/scripts/accept_changes.py @@ -0,0 +1,135 @@ +"""Accept all tracked changes in a DOCX file using LibreOffice. + +Requires LibreOffice (soffice) to be installed. +""" + +import argparse +import logging +import shutil +import subprocess +from pathlib import Path + +from office.soffice import get_soffice_env + +logger = logging.getLogger(__name__) + +LIBREOFFICE_PROFILE = "/tmp/libreoffice_docx_profile" +MACRO_DIR = f"{LIBREOFFICE_PROFILE}/user/basic/Standard" + +ACCEPT_CHANGES_MACRO = """<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE script:module PUBLIC "-//OpenOffice.org//DTD OfficeDocument 1.0//EN" "module.dtd"> +<script:module xmlns:script="http://openoffice.org/2000/script" script:name="Module1" script:language="StarBasic"> + Sub AcceptAllTrackedChanges() + Dim document As Object + Dim dispatcher As Object + + document = ThisComponent.CurrentController.Frame + dispatcher = createUnoService("com.sun.star.frame.DispatchHelper") + + dispatcher.executeDispatch(document, ".uno:AcceptAllTrackedChanges", "", 0, Array()) + ThisComponent.store() + ThisComponent.close(True) + End Sub +</script:module>""" + + +def accept_changes( + input_file: str, + output_file: str, +) -> tuple[None, str]: + input_path = Path(input_file) + output_path = Path(output_file) + + if not input_path.exists(): + return None, f"Error: Input file not found: {input_file}" + + if not input_path.suffix.lower() == ".docx": + return None, f"Error: Input file is not a DOCX file: {input_file}" + + try: + output_path.parent.mkdir(parents=True, exist_ok=True) + shutil.copy2(input_path, output_path) + except Exception as e: + return None, f"Error: Failed to copy input file to output location: {e}" + + if not _setup_libreoffice_macro(): + return None, "Error: Failed to setup LibreOffice macro" + + cmd = [ + "soffice", + "--headless", + f"-env:UserInstallation=file://{LIBREOFFICE_PROFILE}", + "--norestore", + "vnd.sun.star.script:Standard.Module1.AcceptAllTrackedChanges?language=Basic&location=application", + str(output_path.absolute()), + ] + + try: + result = subprocess.run( + cmd, + capture_output=True, + text=True, + timeout=30, + check=False, + env=get_soffice_env(), + ) + except subprocess.TimeoutExpired: + return ( + None, + f"Successfully accepted all tracked changes: {input_file} -> {output_file}", + ) + + if result.returncode != 0: + return None, f"Error: LibreOffice failed: {result.stderr}" + + return ( + None, + f"Successfully accepted all tracked changes: {input_file} -> {output_file}", + ) + + +def _setup_libreoffice_macro() -> bool: + macro_dir = Path(MACRO_DIR) + macro_file = macro_dir / "Module1.xba" + + if macro_file.exists() and "AcceptAllTrackedChanges" in macro_file.read_text(): + return True + + if not macro_dir.exists(): + subprocess.run( + [ + "soffice", + "--headless", + f"-env:UserInstallation=file://{LIBREOFFICE_PROFILE}", + "--terminate_after_init", + ], + capture_output=True, + timeout=10, + check=False, + env=get_soffice_env(), + ) + macro_dir.mkdir(parents=True, exist_ok=True) + + try: + macro_file.write_text(ACCEPT_CHANGES_MACRO) + return True + except Exception as e: + logger.warning(f"Failed to setup LibreOffice macro: {e}") + return False + + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description="Accept all tracked changes in a DOCX file" + ) + parser.add_argument("input_file", help="Input DOCX file with tracked changes") + parser.add_argument( + "output_file", help="Output DOCX file (clean, no tracked changes)" + ) + args = parser.parse_args() + + _, message = accept_changes(args.input_file, args.output_file) + print(message) + + if "Error" in message: + raise SystemExit(1) diff --git a/.claude/skills/docx/scripts/comment.py b/.claude/skills/docx/scripts/comment.py new file mode 100755 index 00000000..36e1c935 --- /dev/null +++ b/.claude/skills/docx/scripts/comment.py @@ -0,0 +1,318 @@ +"""Add comments to DOCX documents. + +Usage: + python comment.py unpacked/ 0 "Comment text" + python comment.py unpacked/ 1 "Reply text" --parent 0 + +Text should be pre-escaped XML (e.g., & for &, ’ for smart quotes). + +After running, add markers to document.xml: + <w:commentRangeStart w:id="0"/> + ... commented content ... + <w:commentRangeEnd w:id="0"/> + <w:r><w:rPr><w:rStyle w:val="CommentReference"/></w:rPr><w:commentReference w:id="0"/></w:r> +""" + +import argparse +import random +import shutil +import sys +from datetime import datetime, timezone +from pathlib import Path + +import defusedxml.minidom + +TEMPLATE_DIR = Path(__file__).parent / "templates" +NS = { + "w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main", + "w14": "http://schemas.microsoft.com/office/word/2010/wordml", + "w15": "http://schemas.microsoft.com/office/word/2012/wordml", + "w16cid": "http://schemas.microsoft.com/office/word/2016/wordml/cid", + "w16cex": "http://schemas.microsoft.com/office/word/2018/wordml/cex", +} + +COMMENT_XML = """\ +<w:comment w:id="{id}" w:author="{author}" w:date="{date}" w:initials="{initials}"> + <w:p w14:paraId="{para_id}" w14:textId="77777777"> + <w:r> + <w:rPr><w:rStyle w:val="CommentReference"/></w:rPr> + <w:annotationRef/> + </w:r> + <w:r> + <w:rPr> + <w:color w:val="000000"/> + <w:sz w:val="20"/> + <w:szCs w:val="20"/> + </w:rPr> + <w:t>{text}</w:t> + </w:r> + </w:p> +</w:comment>""" + +COMMENT_MARKER_TEMPLATE = """ +Add to document.xml (markers must be direct children of w:p, never inside w:r): + <w:commentRangeStart w:id="{cid}"/> + <w:r>...</w:r> + <w:commentRangeEnd w:id="{cid}"/> + <w:r><w:rPr><w:rStyle w:val="CommentReference"/></w:rPr><w:commentReference w:id="{cid}"/></w:r>""" + +REPLY_MARKER_TEMPLATE = """ +Nest markers inside parent {pid}'s markers (markers must be direct children of w:p, never inside w:r): + <w:commentRangeStart w:id="{pid}"/><w:commentRangeStart w:id="{cid}"/> + <w:r>...</w:r> + <w:commentRangeEnd w:id="{cid}"/><w:commentRangeEnd w:id="{pid}"/> + <w:r><w:rPr><w:rStyle w:val="CommentReference"/></w:rPr><w:commentReference w:id="{pid}"/></w:r> + <w:r><w:rPr><w:rStyle w:val="CommentReference"/></w:rPr><w:commentReference w:id="{cid}"/></w:r>""" + + +def _generate_hex_id() -> str: + return f"{random.randint(0, 0x7FFFFFFE):08X}" + + +SMART_QUOTE_ENTITIES = { + "\u201c": "“", + "\u201d": "”", + "\u2018": "‘", + "\u2019": "’", +} + + +def _encode_smart_quotes(text: str) -> str: + for char, entity in SMART_QUOTE_ENTITIES.items(): + text = text.replace(char, entity) + return text + + +def _append_xml(xml_path: Path, root_tag: str, content: str) -> None: + dom = defusedxml.minidom.parseString(xml_path.read_text(encoding="utf-8")) + root = dom.getElementsByTagName(root_tag)[0] + ns_attrs = " ".join(f'xmlns:{k}="{v}"' for k, v in NS.items()) + wrapper_dom = defusedxml.minidom.parseString(f"<root {ns_attrs}>{content}</root>") + for child in wrapper_dom.documentElement.childNodes: + if child.nodeType == child.ELEMENT_NODE: + root.appendChild(dom.importNode(child, True)) + output = _encode_smart_quotes(dom.toxml(encoding="UTF-8").decode("utf-8")) + xml_path.write_text(output, encoding="utf-8") + + +def _find_para_id(comments_path: Path, comment_id: int) -> str | None: + dom = defusedxml.minidom.parseString(comments_path.read_text(encoding="utf-8")) + for c in dom.getElementsByTagName("w:comment"): + if c.getAttribute("w:id") == str(comment_id): + for p in c.getElementsByTagName("w:p"): + if pid := p.getAttribute("w14:paraId"): + return pid + return None + + +def _get_next_rid(rels_path: Path) -> int: + dom = defusedxml.minidom.parseString(rels_path.read_text(encoding="utf-8")) + max_rid = 0 + for rel in dom.getElementsByTagName("Relationship"): + rid = rel.getAttribute("Id") + if rid and rid.startswith("rId"): + try: + max_rid = max(max_rid, int(rid[3:])) + except ValueError: + pass + return max_rid + 1 + + +def _has_relationship(rels_path: Path, target: str) -> bool: + dom = defusedxml.minidom.parseString(rels_path.read_text(encoding="utf-8")) + for rel in dom.getElementsByTagName("Relationship"): + if rel.getAttribute("Target") == target: + return True + return False + + +def _has_content_type(ct_path: Path, part_name: str) -> bool: + dom = defusedxml.minidom.parseString(ct_path.read_text(encoding="utf-8")) + for override in dom.getElementsByTagName("Override"): + if override.getAttribute("PartName") == part_name: + return True + return False + + +def _ensure_comment_relationships(unpacked_dir: Path) -> None: + rels_path = unpacked_dir / "word" / "_rels" / "document.xml.rels" + if not rels_path.exists(): + return + + if _has_relationship(rels_path, "comments.xml"): + return + + dom = defusedxml.minidom.parseString(rels_path.read_text(encoding="utf-8")) + root = dom.documentElement + next_rid = _get_next_rid(rels_path) + + rels = [ + ( + "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments", + "comments.xml", + ), + ( + "http://schemas.microsoft.com/office/2011/relationships/commentsExtended", + "commentsExtended.xml", + ), + ( + "http://schemas.microsoft.com/office/2016/09/relationships/commentsIds", + "commentsIds.xml", + ), + ( + "http://schemas.microsoft.com/office/2018/08/relationships/commentsExtensible", + "commentsExtensible.xml", + ), + ] + + for rel_type, target in rels: + rel = dom.createElement("Relationship") + rel.setAttribute("Id", f"rId{next_rid}") + rel.setAttribute("Type", rel_type) + rel.setAttribute("Target", target) + root.appendChild(rel) + next_rid += 1 + + rels_path.write_bytes(dom.toxml(encoding="UTF-8")) + + +def _ensure_comment_content_types(unpacked_dir: Path) -> None: + ct_path = unpacked_dir / "[Content_Types].xml" + if not ct_path.exists(): + return + + if _has_content_type(ct_path, "/word/comments.xml"): + return + + dom = defusedxml.minidom.parseString(ct_path.read_text(encoding="utf-8")) + root = dom.documentElement + + overrides = [ + ( + "/word/comments.xml", + "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml", + ), + ( + "/word/commentsExtended.xml", + "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtended+xml", + ), + ( + "/word/commentsIds.xml", + "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsIds+xml", + ), + ( + "/word/commentsExtensible.xml", + "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtensible+xml", + ), + ] + + for part_name, content_type in overrides: + override = dom.createElement("Override") + override.setAttribute("PartName", part_name) + override.setAttribute("ContentType", content_type) + root.appendChild(override) + + ct_path.write_bytes(dom.toxml(encoding="UTF-8")) + + +def add_comment( + unpacked_dir: str, + comment_id: int, + text: str, + author: str = "Claude", + initials: str = "C", + parent_id: int | None = None, +) -> tuple[str, str]: + word = Path(unpacked_dir) / "word" + if not word.exists(): + return "", f"Error: {word} not found" + + para_id, durable_id = _generate_hex_id(), _generate_hex_id() + ts = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ") + + comments = word / "comments.xml" + first_comment = not comments.exists() + if first_comment: + shutil.copy(TEMPLATE_DIR / "comments.xml", comments) + _ensure_comment_relationships(Path(unpacked_dir)) + _ensure_comment_content_types(Path(unpacked_dir)) + _append_xml( + comments, + "w:comments", + COMMENT_XML.format( + id=comment_id, + author=author, + date=ts, + initials=initials, + para_id=para_id, + text=text, + ), + ) + + ext = word / "commentsExtended.xml" + if not ext.exists(): + shutil.copy(TEMPLATE_DIR / "commentsExtended.xml", ext) + if parent_id is not None: + parent_para = _find_para_id(comments, parent_id) + if not parent_para: + return "", f"Error: Parent comment {parent_id} not found" + _append_xml( + ext, + "w15:commentsEx", + f'<w15:commentEx w15:paraId="{para_id}" w15:paraIdParent="{parent_para}" w15:done="0"/>', + ) + else: + _append_xml( + ext, + "w15:commentsEx", + f'<w15:commentEx w15:paraId="{para_id}" w15:done="0"/>', + ) + + ids = word / "commentsIds.xml" + if not ids.exists(): + shutil.copy(TEMPLATE_DIR / "commentsIds.xml", ids) + _append_xml( + ids, + "w16cid:commentsIds", + f'<w16cid:commentId w16cid:paraId="{para_id}" w16cid:durableId="{durable_id}"/>', + ) + + extensible = word / "commentsExtensible.xml" + if not extensible.exists(): + shutil.copy(TEMPLATE_DIR / "commentsExtensible.xml", extensible) + _append_xml( + extensible, + "w16cex:commentsExtensible", + f'<w16cex:commentExtensible w16cex:durableId="{durable_id}" w16cex:dateUtc="{ts}"/>', + ) + + action = "reply" if parent_id is not None else "comment" + return para_id, f"Added {action} {comment_id} (para_id={para_id})" + + +if __name__ == "__main__": + p = argparse.ArgumentParser(description="Add comments to DOCX documents") + p.add_argument("unpacked_dir", help="Unpacked DOCX directory") + p.add_argument("comment_id", type=int, help="Comment ID (must be unique)") + p.add_argument("text", help="Comment text") + p.add_argument("--author", default="Claude", help="Author name") + p.add_argument("--initials", default="C", help="Author initials") + p.add_argument("--parent", type=int, help="Parent comment ID (for replies)") + args = p.parse_args() + + para_id, msg = add_comment( + args.unpacked_dir, + args.comment_id, + args.text, + args.author, + args.initials, + args.parent, + ) + print(msg) + if "Error" in msg: + sys.exit(1) + cid = args.comment_id + if args.parent is not None: + print(REPLY_MARKER_TEMPLATE.format(pid=args.parent, cid=cid)) + else: + print(COMMENT_MARKER_TEMPLATE.format(cid=cid)) diff --git a/.claude/skills/docx/scripts/office/helpers/__init__.py b/.claude/skills/docx/scripts/office/helpers/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/.claude/skills/docx/scripts/office/helpers/merge_runs.py b/.claude/skills/docx/scripts/office/helpers/merge_runs.py new file mode 100644 index 00000000..ad7c25ee --- /dev/null +++ b/.claude/skills/docx/scripts/office/helpers/merge_runs.py @@ -0,0 +1,199 @@ +"""Merge adjacent runs with identical formatting in DOCX. + +Merges adjacent <w:r> elements that have identical <w:rPr> properties. +Works on runs in paragraphs and inside tracked changes (<w:ins>, <w:del>). + +Also: +- Removes rsid attributes from runs (revision metadata that doesn't affect rendering) +- Removes proofErr elements (spell/grammar markers that block merging) +""" + +from pathlib import Path + +import defusedxml.minidom + + +def merge_runs(input_dir: str) -> tuple[int, str]: + doc_xml = Path(input_dir) / "word" / "document.xml" + + if not doc_xml.exists(): + return 0, f"Error: {doc_xml} not found" + + try: + dom = defusedxml.minidom.parseString(doc_xml.read_text(encoding="utf-8")) + root = dom.documentElement + + _remove_elements(root, "proofErr") + _strip_run_rsid_attrs(root) + + containers = {run.parentNode for run in _find_elements(root, "r")} + + merge_count = 0 + for container in containers: + merge_count += _merge_runs_in(container) + + doc_xml.write_bytes(dom.toxml(encoding="UTF-8")) + return merge_count, f"Merged {merge_count} runs" + + except Exception as e: + return 0, f"Error: {e}" + + + + +def _find_elements(root, tag: str) -> list: + results = [] + + def traverse(node): + if node.nodeType == node.ELEMENT_NODE: + name = node.localName or node.tagName + if name == tag or name.endswith(f":{tag}"): + results.append(node) + for child in node.childNodes: + traverse(child) + + traverse(root) + return results + + +def _get_child(parent, tag: str): + for child in parent.childNodes: + if child.nodeType == child.ELEMENT_NODE: + name = child.localName or child.tagName + if name == tag or name.endswith(f":{tag}"): + return child + return None + + +def _get_children(parent, tag: str) -> list: + results = [] + for child in parent.childNodes: + if child.nodeType == child.ELEMENT_NODE: + name = child.localName or child.tagName + if name == tag or name.endswith(f":{tag}"): + results.append(child) + return results + + +def _is_adjacent(elem1, elem2) -> bool: + node = elem1.nextSibling + while node: + if node == elem2: + return True + if node.nodeType == node.ELEMENT_NODE: + return False + if node.nodeType == node.TEXT_NODE and node.data.strip(): + return False + node = node.nextSibling + return False + + + + +def _remove_elements(root, tag: str): + for elem in _find_elements(root, tag): + if elem.parentNode: + elem.parentNode.removeChild(elem) + + +def _strip_run_rsid_attrs(root): + for run in _find_elements(root, "r"): + for attr in list(run.attributes.values()): + if "rsid" in attr.name.lower(): + run.removeAttribute(attr.name) + + + + +def _merge_runs_in(container) -> int: + merge_count = 0 + run = _first_child_run(container) + + while run: + while True: + next_elem = _next_element_sibling(run) + if next_elem and _is_run(next_elem) and _can_merge(run, next_elem): + _merge_run_content(run, next_elem) + container.removeChild(next_elem) + merge_count += 1 + else: + break + + _consolidate_text(run) + run = _next_sibling_run(run) + + return merge_count + + +def _first_child_run(container): + for child in container.childNodes: + if child.nodeType == child.ELEMENT_NODE and _is_run(child): + return child + return None + + +def _next_element_sibling(node): + sibling = node.nextSibling + while sibling: + if sibling.nodeType == sibling.ELEMENT_NODE: + return sibling + sibling = sibling.nextSibling + return None + + +def _next_sibling_run(node): + sibling = node.nextSibling + while sibling: + if sibling.nodeType == sibling.ELEMENT_NODE: + if _is_run(sibling): + return sibling + sibling = sibling.nextSibling + return None + + +def _is_run(node) -> bool: + name = node.localName or node.tagName + return name == "r" or name.endswith(":r") + + +def _can_merge(run1, run2) -> bool: + rpr1 = _get_child(run1, "rPr") + rpr2 = _get_child(run2, "rPr") + + if (rpr1 is None) != (rpr2 is None): + return False + if rpr1 is None: + return True + return rpr1.toxml() == rpr2.toxml() + + +def _merge_run_content(target, source): + for child in list(source.childNodes): + if child.nodeType == child.ELEMENT_NODE: + name = child.localName or child.tagName + if name != "rPr" and not name.endswith(":rPr"): + target.appendChild(child) + + +def _consolidate_text(run): + t_elements = _get_children(run, "t") + + for i in range(len(t_elements) - 1, 0, -1): + curr, prev = t_elements[i], t_elements[i - 1] + + if _is_adjacent(prev, curr): + prev_text = prev.firstChild.data if prev.firstChild else "" + curr_text = curr.firstChild.data if curr.firstChild else "" + merged = prev_text + curr_text + + if prev.firstChild: + prev.firstChild.data = merged + else: + prev.appendChild(run.ownerDocument.createTextNode(merged)) + + if merged.startswith(" ") or merged.endswith(" "): + prev.setAttribute("xml:space", "preserve") + elif prev.hasAttribute("xml:space"): + prev.removeAttribute("xml:space") + + run.removeChild(curr) diff --git a/.claude/skills/docx/scripts/office/helpers/simplify_redlines.py b/.claude/skills/docx/scripts/office/helpers/simplify_redlines.py new file mode 100644 index 00000000..db963bb9 --- /dev/null +++ b/.claude/skills/docx/scripts/office/helpers/simplify_redlines.py @@ -0,0 +1,197 @@ +"""Simplify tracked changes by merging adjacent w:ins or w:del elements. + +Merges adjacent <w:ins> elements from the same author into a single element. +Same for <w:del> elements. This makes heavily-redlined documents easier to +work with by reducing the number of tracked change wrappers. + +Rules: +- Only merges w:ins with w:ins, w:del with w:del (same element type) +- Only merges if same author (ignores timestamp differences) +- Only merges if truly adjacent (only whitespace between them) +""" + +import xml.etree.ElementTree as ET +import zipfile +from pathlib import Path + +import defusedxml.minidom + +WORD_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main" + + +def simplify_redlines(input_dir: str) -> tuple[int, str]: + doc_xml = Path(input_dir) / "word" / "document.xml" + + if not doc_xml.exists(): + return 0, f"Error: {doc_xml} not found" + + try: + dom = defusedxml.minidom.parseString(doc_xml.read_text(encoding="utf-8")) + root = dom.documentElement + + merge_count = 0 + + containers = _find_elements(root, "p") + _find_elements(root, "tc") + + for container in containers: + merge_count += _merge_tracked_changes_in(container, "ins") + merge_count += _merge_tracked_changes_in(container, "del") + + doc_xml.write_bytes(dom.toxml(encoding="UTF-8")) + return merge_count, f"Simplified {merge_count} tracked changes" + + except Exception as e: + return 0, f"Error: {e}" + + +def _merge_tracked_changes_in(container, tag: str) -> int: + merge_count = 0 + + tracked = [ + child + for child in container.childNodes + if child.nodeType == child.ELEMENT_NODE and _is_element(child, tag) + ] + + if len(tracked) < 2: + return 0 + + i = 0 + while i < len(tracked) - 1: + curr = tracked[i] + next_elem = tracked[i + 1] + + if _can_merge_tracked(curr, next_elem): + _merge_tracked_content(curr, next_elem) + container.removeChild(next_elem) + tracked.pop(i + 1) + merge_count += 1 + else: + i += 1 + + return merge_count + + +def _is_element(node, tag: str) -> bool: + name = node.localName or node.tagName + return name == tag or name.endswith(f":{tag}") + + +def _get_author(elem) -> str: + author = elem.getAttribute("w:author") + if not author: + for attr in elem.attributes.values(): + if attr.localName == "author" or attr.name.endswith(":author"): + return attr.value + return author + + +def _can_merge_tracked(elem1, elem2) -> bool: + if _get_author(elem1) != _get_author(elem2): + return False + + node = elem1.nextSibling + while node and node != elem2: + if node.nodeType == node.ELEMENT_NODE: + return False + if node.nodeType == node.TEXT_NODE and node.data.strip(): + return False + node = node.nextSibling + + return True + + +def _merge_tracked_content(target, source): + while source.firstChild: + child = source.firstChild + source.removeChild(child) + target.appendChild(child) + + +def _find_elements(root, tag: str) -> list: + results = [] + + def traverse(node): + if node.nodeType == node.ELEMENT_NODE: + name = node.localName or node.tagName + if name == tag or name.endswith(f":{tag}"): + results.append(node) + for child in node.childNodes: + traverse(child) + + traverse(root) + return results + + +def get_tracked_change_authors(doc_xml_path: Path) -> dict[str, int]: + if not doc_xml_path.exists(): + return {} + + try: + tree = ET.parse(doc_xml_path) + root = tree.getroot() + except ET.ParseError: + return {} + + namespaces = {"w": WORD_NS} + author_attr = f"{{{WORD_NS}}}author" + + authors: dict[str, int] = {} + for tag in ["ins", "del"]: + for elem in root.findall(f".//w:{tag}", namespaces): + author = elem.get(author_attr) + if author: + authors[author] = authors.get(author, 0) + 1 + + return authors + + +def _get_authors_from_docx(docx_path: Path) -> dict[str, int]: + try: + with zipfile.ZipFile(docx_path, "r") as zf: + if "word/document.xml" not in zf.namelist(): + return {} + with zf.open("word/document.xml") as f: + tree = ET.parse(f) + root = tree.getroot() + + namespaces = {"w": WORD_NS} + author_attr = f"{{{WORD_NS}}}author" + + authors: dict[str, int] = {} + for tag in ["ins", "del"]: + for elem in root.findall(f".//w:{tag}", namespaces): + author = elem.get(author_attr) + if author: + authors[author] = authors.get(author, 0) + 1 + return authors + except (zipfile.BadZipFile, ET.ParseError): + return {} + + +def infer_author(modified_dir: Path, original_docx: Path, default: str = "Claude") -> str: + modified_xml = modified_dir / "word" / "document.xml" + modified_authors = get_tracked_change_authors(modified_xml) + + if not modified_authors: + return default + + original_authors = _get_authors_from_docx(original_docx) + + new_changes: dict[str, int] = {} + for author, count in modified_authors.items(): + original_count = original_authors.get(author, 0) + diff = count - original_count + if diff > 0: + new_changes[author] = diff + + if not new_changes: + return default + + if len(new_changes) == 1: + return next(iter(new_changes)) + + raise ValueError( + f"Multiple authors added new changes: {new_changes}. " + "Cannot infer which author to validate." + ) diff --git a/.claude/skills/docx/scripts/office/pack.py b/.claude/skills/docx/scripts/office/pack.py new file mode 100755 index 00000000..db29ed8b --- /dev/null +++ b/.claude/skills/docx/scripts/office/pack.py @@ -0,0 +1,159 @@ +"""Pack a directory into a DOCX, PPTX, or XLSX file. + +Validates with auto-repair, condenses XML formatting, and creates the Office file. + +Usage: + python pack.py <input_directory> <output_file> [--original <file>] [--validate true|false] + +Examples: + python pack.py unpacked/ output.docx --original input.docx + python pack.py unpacked/ output.pptx --validate false +""" + +import argparse +import sys +import shutil +import tempfile +import zipfile +from pathlib import Path + +import defusedxml.minidom + +from validators import DOCXSchemaValidator, PPTXSchemaValidator, RedliningValidator + +def pack( + input_directory: str, + output_file: str, + original_file: str | None = None, + validate: bool = True, + infer_author_func=None, +) -> tuple[None, str]: + input_dir = Path(input_directory) + output_path = Path(output_file) + suffix = output_path.suffix.lower() + + if not input_dir.is_dir(): + return None, f"Error: {input_dir} is not a directory" + + if suffix not in {".docx", ".pptx", ".xlsx"}: + return None, f"Error: {output_file} must be a .docx, .pptx, or .xlsx file" + + if validate and original_file: + original_path = Path(original_file) + if original_path.exists(): + success, output = _run_validation( + input_dir, original_path, suffix, infer_author_func + ) + if output: + print(output) + if not success: + return None, f"Error: Validation failed for {input_dir}" + + with tempfile.TemporaryDirectory() as temp_dir: + temp_content_dir = Path(temp_dir) / "content" + shutil.copytree(input_dir, temp_content_dir) + + for pattern in ["*.xml", "*.rels"]: + for xml_file in temp_content_dir.rglob(pattern): + _condense_xml(xml_file) + + output_path.parent.mkdir(parents=True, exist_ok=True) + with zipfile.ZipFile(output_path, "w", zipfile.ZIP_DEFLATED) as zf: + for f in temp_content_dir.rglob("*"): + if f.is_file(): + zf.write(f, f.relative_to(temp_content_dir)) + + return None, f"Successfully packed {input_dir} to {output_file}" + + +def _run_validation( + unpacked_dir: Path, + original_file: Path, + suffix: str, + infer_author_func=None, +) -> tuple[bool, str | None]: + output_lines = [] + validators = [] + + if suffix == ".docx": + author = "Claude" + if infer_author_func: + try: + author = infer_author_func(unpacked_dir, original_file) + except ValueError as e: + print(f"Warning: {e} Using default author 'Claude'.", file=sys.stderr) + + validators = [ + DOCXSchemaValidator(unpacked_dir, original_file), + RedliningValidator(unpacked_dir, original_file, author=author), + ] + elif suffix == ".pptx": + validators = [PPTXSchemaValidator(unpacked_dir, original_file)] + + if not validators: + return True, None + + total_repairs = sum(v.repair() for v in validators) + if total_repairs: + output_lines.append(f"Auto-repaired {total_repairs} issue(s)") + + success = all(v.validate() for v in validators) + + if success: + output_lines.append("All validations PASSED!") + + return success, "\n".join(output_lines) if output_lines else None + + +def _condense_xml(xml_file: Path) -> None: + try: + with open(xml_file, encoding="utf-8") as f: + dom = defusedxml.minidom.parse(f) + + for element in dom.getElementsByTagName("*"): + if element.tagName.endswith(":t"): + continue + + for child in list(element.childNodes): + if ( + child.nodeType == child.TEXT_NODE + and child.nodeValue + and child.nodeValue.strip() == "" + ) or child.nodeType == child.COMMENT_NODE: + element.removeChild(child) + + xml_file.write_bytes(dom.toxml(encoding="UTF-8")) + except Exception as e: + print(f"ERROR: Failed to parse {xml_file.name}: {e}", file=sys.stderr) + raise + + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description="Pack a directory into a DOCX, PPTX, or XLSX file" + ) + parser.add_argument("input_directory", help="Unpacked Office document directory") + parser.add_argument("output_file", help="Output Office file (.docx/.pptx/.xlsx)") + parser.add_argument( + "--original", + help="Original file for validation comparison", + ) + parser.add_argument( + "--validate", + type=lambda x: x.lower() == "true", + default=True, + metavar="true|false", + help="Run validation with auto-repair (default: true)", + ) + args = parser.parse_args() + + _, message = pack( + args.input_directory, + args.output_file, + original_file=args.original, + validate=args.validate, + ) + print(message) + + if "Error" in message: + sys.exit(1) diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/dml-chart.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/dml-chart.xsd new file mode 100644 index 00000000..6454ef9a --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/dml-chart.xsd @@ -0,0 +1,1499 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" + xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" + xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" + xmlns="http://schemas.openxmlformats.org/drawingml/2006/chart" + xmlns:cdr="http://schemas.openxmlformats.org/drawingml/2006/chartDrawing" + xmlns:s="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + targetNamespace="http://schemas.openxmlformats.org/drawingml/2006/chart" + elementFormDefault="qualified" attributeFormDefault="unqualified" blockDefault="#all"> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/relationships" + schemaLocation="shared-relationshipReference.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/drawingml/2006/main" + schemaLocation="dml-main.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/drawingml/2006/chartDrawing" + schemaLocation="dml-chartDrawing.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + schemaLocation="shared-commonSimpleTypes.xsd"/> + <xsd:complexType name="CT_Boolean"> + <xsd:attribute name="val" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_Double"> + <xsd:attribute name="val" type="xsd:double" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_UnsignedInt"> + <xsd:attribute name="val" type="xsd:unsignedInt" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_RelId"> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Extension"> + <xsd:sequence> + <xsd:any processContents="lax"/> + </xsd:sequence> + <xsd:attribute name="uri" type="xsd:token"/> + </xsd:complexType> + <xsd:complexType name="CT_ExtensionList"> + <xsd:sequence> + <xsd:element name="ext" type="CT_Extension" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_NumVal"> + <xsd:sequence> + <xsd:element name="v" type="s:ST_Xstring" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="idx" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="formatCode" type="s:ST_Xstring" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_NumData"> + <xsd:sequence> + <xsd:element name="formatCode" type="s:ST_Xstring" minOccurs="0" maxOccurs="1"/> + <xsd:element name="ptCount" type="CT_UnsignedInt" minOccurs="0" maxOccurs="1"/> + <xsd:element name="pt" type="CT_NumVal" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_NumRef"> + <xsd:sequence> + <xsd:element name="f" type="xsd:string" minOccurs="1" maxOccurs="1"/> + <xsd:element name="numCache" type="CT_NumData" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_NumDataSource"> + <xsd:sequence> + <xsd:choice minOccurs="1" maxOccurs="1"> + <xsd:element name="numRef" type="CT_NumRef" minOccurs="1" maxOccurs="1"/> + <xsd:element name="numLit" type="CT_NumData" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_StrVal"> + <xsd:sequence> + <xsd:element name="v" type="s:ST_Xstring" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="idx" type="xsd:unsignedInt" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_StrData"> + <xsd:sequence> + <xsd:element name="ptCount" type="CT_UnsignedInt" minOccurs="0" maxOccurs="1"/> + <xsd:element name="pt" type="CT_StrVal" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_StrRef"> + <xsd:sequence> + <xsd:element name="f" type="xsd:string" minOccurs="1" maxOccurs="1"/> + <xsd:element name="strCache" type="CT_StrData" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Tx"> + <xsd:sequence> + <xsd:choice minOccurs="1" maxOccurs="1"> + <xsd:element name="strRef" type="CT_StrRef" minOccurs="1" maxOccurs="1"/> + <xsd:element name="rich" type="a:CT_TextBody" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TextLanguageID"> + <xsd:attribute name="val" type="s:ST_Lang" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Lvl"> + <xsd:sequence> + <xsd:element name="pt" type="CT_StrVal" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_MultiLvlStrData"> + <xsd:sequence> + <xsd:element name="ptCount" type="CT_UnsignedInt" minOccurs="0" maxOccurs="1"/> + <xsd:element name="lvl" type="CT_Lvl" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_MultiLvlStrRef"> + <xsd:sequence> + <xsd:element name="f" type="xsd:string" minOccurs="1" maxOccurs="1"/> + <xsd:element name="multiLvlStrCache" type="CT_MultiLvlStrData" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_AxDataSource"> + <xsd:sequence> + <xsd:choice minOccurs="1" maxOccurs="1"> + <xsd:element name="multiLvlStrRef" type="CT_MultiLvlStrRef" minOccurs="1" maxOccurs="1"/> + <xsd:element name="numRef" type="CT_NumRef" minOccurs="1" maxOccurs="1"/> + <xsd:element name="numLit" type="CT_NumData" minOccurs="1" maxOccurs="1"/> + <xsd:element name="strRef" type="CT_StrRef" minOccurs="1" maxOccurs="1"/> + <xsd:element name="strLit" type="CT_StrData" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SerTx"> + <xsd:sequence> + <xsd:choice minOccurs="1" maxOccurs="1"> + <xsd:element name="strRef" type="CT_StrRef" minOccurs="1" maxOccurs="1"/> + <xsd:element name="v" type="s:ST_Xstring" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_LayoutTarget"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="inner"/> + <xsd:enumeration value="outer"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_LayoutTarget"> + <xsd:attribute name="val" type="ST_LayoutTarget" default="outer"/> + </xsd:complexType> + <xsd:simpleType name="ST_LayoutMode"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="edge"/> + <xsd:enumeration value="factor"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_LayoutMode"> + <xsd:attribute name="val" type="ST_LayoutMode" default="factor"/> + </xsd:complexType> + <xsd:complexType name="CT_ManualLayout"> + <xsd:sequence> + <xsd:element name="layoutTarget" type="CT_LayoutTarget" minOccurs="0" maxOccurs="1"/> + <xsd:element name="xMode" type="CT_LayoutMode" minOccurs="0" maxOccurs="1"/> + <xsd:element name="yMode" type="CT_LayoutMode" minOccurs="0" maxOccurs="1"/> + <xsd:element name="wMode" type="CT_LayoutMode" minOccurs="0" maxOccurs="1"/> + <xsd:element name="hMode" type="CT_LayoutMode" minOccurs="0" maxOccurs="1"/> + <xsd:element name="x" type="CT_Double" minOccurs="0" maxOccurs="1"/> + <xsd:element name="y" type="CT_Double" minOccurs="0" maxOccurs="1"/> + <xsd:element name="w" type="CT_Double" minOccurs="0" maxOccurs="1"/> + <xsd:element name="h" type="CT_Double" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Layout"> + <xsd:sequence> + <xsd:element name="manualLayout" type="CT_ManualLayout" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Title"> + <xsd:sequence> + <xsd:element name="tx" type="CT_Tx" minOccurs="0" maxOccurs="1"/> + <xsd:element name="layout" type="CT_Layout" minOccurs="0" maxOccurs="1"/> + <xsd:element name="overlay" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="txPr" type="a:CT_TextBody" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_RotX"> + <xsd:restriction base="xsd:byte"> + <xsd:minInclusive value="-90"/> + <xsd:maxInclusive value="90"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_RotX"> + <xsd:attribute name="val" type="ST_RotX" default="0"/> + </xsd:complexType> + <xsd:simpleType name="ST_HPercent"> + <xsd:union memberTypes="ST_HPercentWithSymbol ST_HPercentUShort"/> + </xsd:simpleType> + <xsd:simpleType name="ST_HPercentWithSymbol"> + <xsd:restriction base="xsd:string"> + <xsd:pattern value="0*(([5-9])|([1-9][0-9])|([1-4][0-9][0-9])|500)%"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_HPercentUShort"> + <xsd:restriction base="xsd:unsignedShort"> + <xsd:minInclusive value="5"/> + <xsd:maxInclusive value="500"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_HPercent"> + <xsd:attribute name="val" type="ST_HPercent" default="100%"/> + </xsd:complexType> + <xsd:simpleType name="ST_RotY"> + <xsd:restriction base="xsd:unsignedShort"> + <xsd:minInclusive value="0"/> + <xsd:maxInclusive value="360"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_RotY"> + <xsd:attribute name="val" type="ST_RotY" default="0"/> + </xsd:complexType> + <xsd:simpleType name="ST_DepthPercent"> + <xsd:union memberTypes="ST_DepthPercentWithSymbol ST_DepthPercentUShort"/> + </xsd:simpleType> + <xsd:simpleType name="ST_DepthPercentWithSymbol"> + <xsd:restriction base="xsd:string"> + <xsd:pattern value="0*(([2-9][0-9])|([1-9][0-9][0-9])|(1[0-9][0-9][0-9])|2000)%"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_DepthPercentUShort"> + <xsd:restriction base="xsd:unsignedShort"> + <xsd:minInclusive value="20"/> + <xsd:maxInclusive value="2000"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_DepthPercent"> + <xsd:attribute name="val" type="ST_DepthPercent" default="100%"/> + </xsd:complexType> + <xsd:simpleType name="ST_Perspective"> + <xsd:restriction base="xsd:unsignedByte"> + <xsd:minInclusive value="0"/> + <xsd:maxInclusive value="240"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Perspective"> + <xsd:attribute name="val" type="ST_Perspective" default="30"/> + </xsd:complexType> + <xsd:complexType name="CT_View3D"> + <xsd:sequence> + <xsd:element name="rotX" type="CT_RotX" minOccurs="0" maxOccurs="1"/> + <xsd:element name="hPercent" type="CT_HPercent" minOccurs="0" maxOccurs="1"/> + <xsd:element name="rotY" type="CT_RotY" minOccurs="0" maxOccurs="1"/> + <xsd:element name="depthPercent" type="CT_DepthPercent" minOccurs="0" maxOccurs="1"/> + <xsd:element name="rAngAx" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="perspective" type="CT_Perspective" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Surface"> + <xsd:sequence> + <xsd:element name="thickness" type="CT_Thickness" minOccurs="0" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="pictureOptions" type="CT_PictureOptions" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_Thickness"> + <xsd:union memberTypes="ST_ThicknessPercent xsd:unsignedInt"/> + </xsd:simpleType> + <xsd:simpleType name="ST_ThicknessPercent"> + <xsd:restriction base="xsd:string"> + <xsd:pattern value="([0-9]+)%"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Thickness"> + <xsd:attribute name="val" type="ST_Thickness" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_DTable"> + <xsd:sequence> + <xsd:element name="showHorzBorder" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="showVertBorder" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="showOutline" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="showKeys" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="txPr" type="a:CT_TextBody" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_GapAmount"> + <xsd:union memberTypes="ST_GapAmountPercent ST_GapAmountUShort"/> + </xsd:simpleType> + <xsd:simpleType name="ST_GapAmountPercent"> + <xsd:restriction base="xsd:string"> + <xsd:pattern value="0*(([0-9])|([1-9][0-9])|([1-4][0-9][0-9])|500)%"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_GapAmountUShort"> + <xsd:restriction base="xsd:unsignedShort"> + <xsd:minInclusive value="0"/> + <xsd:maxInclusive value="500"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_GapAmount"> + <xsd:attribute name="val" type="ST_GapAmount" default="150%"/> + </xsd:complexType> + <xsd:simpleType name="ST_Overlap"> + <xsd:union memberTypes="ST_OverlapPercent ST_OverlapByte"/> + </xsd:simpleType> + <xsd:simpleType name="ST_OverlapPercent"> + <xsd:restriction base="xsd:string"> + <xsd:pattern value="(-?0*(([0-9])|([1-9][0-9])|100))%"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_OverlapByte"> + <xsd:restriction base="xsd:byte"> + <xsd:minInclusive value="-100"/> + <xsd:maxInclusive value="100"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Overlap"> + <xsd:attribute name="val" type="ST_Overlap" default="0%"/> + </xsd:complexType> + <xsd:simpleType name="ST_BubbleScale"> + <xsd:union memberTypes="ST_BubbleScalePercent ST_BubbleScaleUInt"/> + </xsd:simpleType> + <xsd:simpleType name="ST_BubbleScalePercent"> + <xsd:restriction base="xsd:string"> + <xsd:pattern value="0*(([0-9])|([1-9][0-9])|([1-2][0-9][0-9])|300)%"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_BubbleScaleUInt"> + <xsd:restriction base="xsd:unsignedInt"> + <xsd:minInclusive value="0"/> + <xsd:maxInclusive value="300"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_BubbleScale"> + <xsd:attribute name="val" type="ST_BubbleScale" default="100%"/> + </xsd:complexType> + <xsd:simpleType name="ST_SizeRepresents"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="area"/> + <xsd:enumeration value="w"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_SizeRepresents"> + <xsd:attribute name="val" type="ST_SizeRepresents" default="area"/> + </xsd:complexType> + <xsd:simpleType name="ST_FirstSliceAng"> + <xsd:restriction base="xsd:unsignedShort"> + <xsd:minInclusive value="0"/> + <xsd:maxInclusive value="360"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_FirstSliceAng"> + <xsd:attribute name="val" type="ST_FirstSliceAng" default="0"/> + </xsd:complexType> + <xsd:simpleType name="ST_HoleSize"> + <xsd:union memberTypes="ST_HoleSizePercent ST_HoleSizeUByte"/> + </xsd:simpleType> + <xsd:simpleType name="ST_HoleSizePercent"> + <xsd:restriction base="xsd:string"> + <xsd:pattern value="0*([1-9]|([1-8][0-9])|90)%"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_HoleSizeUByte"> + <xsd:restriction base="xsd:unsignedByte"> + <xsd:minInclusive value="1"/> + <xsd:maxInclusive value="90"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_HoleSize"> + <xsd:attribute name="val" type="ST_HoleSize" default="10%"/> + </xsd:complexType> + <xsd:simpleType name="ST_SplitType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="auto"/> + <xsd:enumeration value="cust"/> + <xsd:enumeration value="percent"/> + <xsd:enumeration value="pos"/> + <xsd:enumeration value="val"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_SplitType"> + <xsd:attribute name="val" type="ST_SplitType" default="auto"/> + </xsd:complexType> + <xsd:complexType name="CT_CustSplit"> + <xsd:sequence> + <xsd:element name="secondPiePt" type="CT_UnsignedInt" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_SecondPieSize"> + <xsd:union memberTypes="ST_SecondPieSizePercent ST_SecondPieSizeUShort"/> + </xsd:simpleType> + <xsd:simpleType name="ST_SecondPieSizePercent"> + <xsd:restriction base="xsd:string"> + <xsd:pattern value="0*(([5-9])|([1-9][0-9])|(1[0-9][0-9])|200)%"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_SecondPieSizeUShort"> + <xsd:restriction base="xsd:unsignedShort"> + <xsd:minInclusive value="5"/> + <xsd:maxInclusive value="200"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_SecondPieSize"> + <xsd:attribute name="val" type="ST_SecondPieSize" default="75%"/> + </xsd:complexType> + <xsd:complexType name="CT_NumFmt"> + <xsd:attribute name="formatCode" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="sourceLinked" type="xsd:boolean"/> + </xsd:complexType> + <xsd:simpleType name="ST_LblAlgn"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="ctr"/> + <xsd:enumeration value="l"/> + <xsd:enumeration value="r"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_LblAlgn"> + <xsd:attribute name="val" type="ST_LblAlgn" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_DLblPos"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="bestFit"/> + <xsd:enumeration value="b"/> + <xsd:enumeration value="ctr"/> + <xsd:enumeration value="inBase"/> + <xsd:enumeration value="inEnd"/> + <xsd:enumeration value="l"/> + <xsd:enumeration value="outEnd"/> + <xsd:enumeration value="r"/> + <xsd:enumeration value="t"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_DLblPos"> + <xsd:attribute name="val" type="ST_DLblPos" use="required"/> + </xsd:complexType> + <xsd:group name="EG_DLblShared"> + <xsd:sequence> + <xsd:element name="numFmt" type="CT_NumFmt" minOccurs="0" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="txPr" type="a:CT_TextBody" minOccurs="0" maxOccurs="1"/> + <xsd:element name="dLblPos" type="CT_DLblPos" minOccurs="0" maxOccurs="1"/> + <xsd:element name="showLegendKey" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="showVal" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="showCatName" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="showSerName" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="showPercent" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="showBubbleSize" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="separator" type="xsd:string" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:group> + <xsd:group name="Group_DLbl"> + <xsd:sequence> + <xsd:element name="layout" type="CT_Layout" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tx" type="CT_Tx" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_DLblShared" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:group> + <xsd:complexType name="CT_DLbl"> + <xsd:sequence> + <xsd:element name="idx" type="CT_UnsignedInt" minOccurs="1" maxOccurs="1"/> + <xsd:choice> + <xsd:element name="delete" type="CT_Boolean" minOccurs="1" maxOccurs="1"/> + <xsd:group ref="Group_DLbl" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:group name="Group_DLbls"> + <xsd:sequence> + <xsd:group ref="EG_DLblShared" minOccurs="1" maxOccurs="1"/> + <xsd:element name="showLeaderLines" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="leaderLines" type="CT_ChartLines" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:group> + <xsd:complexType name="CT_DLbls"> + <xsd:sequence> + <xsd:element name="dLbl" type="CT_DLbl" minOccurs="0" maxOccurs="unbounded"/> + <xsd:choice> + <xsd:element name="delete" type="CT_Boolean" minOccurs="1" maxOccurs="1"/> + <xsd:group ref="Group_DLbls" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_MarkerStyle"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="circle"/> + <xsd:enumeration value="dash"/> + <xsd:enumeration value="diamond"/> + <xsd:enumeration value="dot"/> + <xsd:enumeration value="none"/> + <xsd:enumeration value="picture"/> + <xsd:enumeration value="plus"/> + <xsd:enumeration value="square"/> + <xsd:enumeration value="star"/> + <xsd:enumeration value="triangle"/> + <xsd:enumeration value="x"/> + <xsd:enumeration value="auto"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_MarkerStyle"> + <xsd:attribute name="val" type="ST_MarkerStyle" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_MarkerSize"> + <xsd:restriction base="xsd:unsignedByte"> + <xsd:minInclusive value="2"/> + <xsd:maxInclusive value="72"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_MarkerSize"> + <xsd:attribute name="val" type="ST_MarkerSize" default="5"/> + </xsd:complexType> + <xsd:complexType name="CT_Marker"> + <xsd:sequence> + <xsd:element name="symbol" type="CT_MarkerStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="size" type="CT_MarkerSize" minOccurs="0" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_DPt"> + <xsd:sequence> + <xsd:element name="idx" type="CT_UnsignedInt" minOccurs="1" maxOccurs="1"/> + <xsd:element name="invertIfNegative" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="marker" type="CT_Marker" minOccurs="0" maxOccurs="1"/> + <xsd:element name="bubble3D" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="explosion" type="CT_UnsignedInt" minOccurs="0" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="pictureOptions" type="CT_PictureOptions" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_TrendlineType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="exp"/> + <xsd:enumeration value="linear"/> + <xsd:enumeration value="log"/> + <xsd:enumeration value="movingAvg"/> + <xsd:enumeration value="poly"/> + <xsd:enumeration value="power"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TrendlineType"> + <xsd:attribute name="val" type="ST_TrendlineType" default="linear"/> + </xsd:complexType> + <xsd:simpleType name="ST_Order"> + <xsd:restriction base="xsd:unsignedByte"> + <xsd:minInclusive value="2"/> + <xsd:maxInclusive value="6"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Order"> + <xsd:attribute name="val" type="ST_Order" default="2"/> + </xsd:complexType> + <xsd:simpleType name="ST_Period"> + <xsd:restriction base="xsd:unsignedInt"> + <xsd:minInclusive value="2"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Period"> + <xsd:attribute name="val" type="ST_Period" default="2"/> + </xsd:complexType> + <xsd:complexType name="CT_TrendlineLbl"> + <xsd:sequence> + <xsd:element name="layout" type="CT_Layout" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tx" type="CT_Tx" minOccurs="0" maxOccurs="1"/> + <xsd:element name="numFmt" type="CT_NumFmt" minOccurs="0" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="txPr" type="a:CT_TextBody" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Trendline"> + <xsd:sequence> + <xsd:element name="name" type="xsd:string" minOccurs="0" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="trendlineType" type="CT_TrendlineType" minOccurs="1" maxOccurs="1"/> + <xsd:element name="order" type="CT_Order" minOccurs="0" maxOccurs="1"/> + <xsd:element name="period" type="CT_Period" minOccurs="0" maxOccurs="1"/> + <xsd:element name="forward" type="CT_Double" minOccurs="0" maxOccurs="1"/> + <xsd:element name="backward" type="CT_Double" minOccurs="0" maxOccurs="1"/> + <xsd:element name="intercept" type="CT_Double" minOccurs="0" maxOccurs="1"/> + <xsd:element name="dispRSqr" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="dispEq" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="trendlineLbl" type="CT_TrendlineLbl" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_ErrDir"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="x"/> + <xsd:enumeration value="y"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_ErrDir"> + <xsd:attribute name="val" type="ST_ErrDir" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_ErrBarType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="both"/> + <xsd:enumeration value="minus"/> + <xsd:enumeration value="plus"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_ErrBarType"> + <xsd:attribute name="val" type="ST_ErrBarType" default="both"/> + </xsd:complexType> + <xsd:simpleType name="ST_ErrValType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="cust"/> + <xsd:enumeration value="fixedVal"/> + <xsd:enumeration value="percentage"/> + <xsd:enumeration value="stdDev"/> + <xsd:enumeration value="stdErr"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_ErrValType"> + <xsd:attribute name="val" type="ST_ErrValType" default="fixedVal"/> + </xsd:complexType> + <xsd:complexType name="CT_ErrBars"> + <xsd:sequence> + <xsd:element name="errDir" type="CT_ErrDir" minOccurs="0" maxOccurs="1"/> + <xsd:element name="errBarType" type="CT_ErrBarType" minOccurs="1" maxOccurs="1"/> + <xsd:element name="errValType" type="CT_ErrValType" minOccurs="1" maxOccurs="1"/> + <xsd:element name="noEndCap" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="plus" type="CT_NumDataSource" minOccurs="0" maxOccurs="1"/> + <xsd:element name="minus" type="CT_NumDataSource" minOccurs="0" maxOccurs="1"/> + <xsd:element name="val" type="CT_Double" minOccurs="0" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_UpDownBar"> + <xsd:sequence> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_UpDownBars"> + <xsd:sequence> + <xsd:element name="gapWidth" type="CT_GapAmount" minOccurs="0" maxOccurs="1"/> + <xsd:element name="upBars" type="CT_UpDownBar" minOccurs="0" maxOccurs="1"/> + <xsd:element name="downBars" type="CT_UpDownBar" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:group name="EG_SerShared"> + <xsd:sequence> + <xsd:element name="idx" type="CT_UnsignedInt" minOccurs="1" maxOccurs="1"/> + <xsd:element name="order" type="CT_UnsignedInt" minOccurs="1" maxOccurs="1"/> + <xsd:element name="tx" type="CT_SerTx" minOccurs="0" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:group> + <xsd:complexType name="CT_LineSer"> + <xsd:sequence> + <xsd:group ref="EG_SerShared" minOccurs="1" maxOccurs="1"/> + <xsd:element name="marker" type="CT_Marker" minOccurs="0" maxOccurs="1"/> + <xsd:element name="dPt" type="CT_DPt" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="dLbls" type="CT_DLbls" minOccurs="0" maxOccurs="1"/> + <xsd:element name="trendline" type="CT_Trendline" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="errBars" type="CT_ErrBars" minOccurs="0" maxOccurs="1"/> + <xsd:element name="cat" type="CT_AxDataSource" minOccurs="0" maxOccurs="1"/> + <xsd:element name="val" type="CT_NumDataSource" minOccurs="0" maxOccurs="1"/> + <xsd:element name="smooth" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_ScatterSer"> + <xsd:sequence> + <xsd:group ref="EG_SerShared" minOccurs="1" maxOccurs="1"/> + <xsd:element name="marker" type="CT_Marker" minOccurs="0" maxOccurs="1"/> + <xsd:element name="dPt" type="CT_DPt" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="dLbls" type="CT_DLbls" minOccurs="0" maxOccurs="1"/> + <xsd:element name="trendline" type="CT_Trendline" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="errBars" type="CT_ErrBars" minOccurs="0" maxOccurs="2"/> + <xsd:element name="xVal" type="CT_AxDataSource" minOccurs="0" maxOccurs="1"/> + <xsd:element name="yVal" type="CT_NumDataSource" minOccurs="0" maxOccurs="1"/> + <xsd:element name="smooth" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_RadarSer"> + <xsd:sequence> + <xsd:group ref="EG_SerShared" minOccurs="1" maxOccurs="1"/> + <xsd:element name="marker" type="CT_Marker" minOccurs="0" maxOccurs="1"/> + <xsd:element name="dPt" type="CT_DPt" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="dLbls" type="CT_DLbls" minOccurs="0" maxOccurs="1"/> + <xsd:element name="cat" type="CT_AxDataSource" minOccurs="0" maxOccurs="1"/> + <xsd:element name="val" type="CT_NumDataSource" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_BarSer"> + <xsd:sequence> + <xsd:group ref="EG_SerShared" minOccurs="1" maxOccurs="1"/> + <xsd:element name="invertIfNegative" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="pictureOptions" type="CT_PictureOptions" minOccurs="0" maxOccurs="1"/> + <xsd:element name="dPt" type="CT_DPt" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="dLbls" type="CT_DLbls" minOccurs="0" maxOccurs="1"/> + <xsd:element name="trendline" type="CT_Trendline" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="errBars" type="CT_ErrBars" minOccurs="0" maxOccurs="1"/> + <xsd:element name="cat" type="CT_AxDataSource" minOccurs="0" maxOccurs="1"/> + <xsd:element name="val" type="CT_NumDataSource" minOccurs="0" maxOccurs="1"/> + <xsd:element name="shape" type="CT_Shape" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_AreaSer"> + <xsd:sequence> + <xsd:group ref="EG_SerShared" minOccurs="1" maxOccurs="1"/> + <xsd:element name="pictureOptions" type="CT_PictureOptions" minOccurs="0" maxOccurs="1"/> + <xsd:element name="dPt" type="CT_DPt" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="dLbls" type="CT_DLbls" minOccurs="0" maxOccurs="1"/> + <xsd:element name="trendline" type="CT_Trendline" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="errBars" type="CT_ErrBars" minOccurs="0" maxOccurs="2"/> + <xsd:element name="cat" type="CT_AxDataSource" minOccurs="0" maxOccurs="1"/> + <xsd:element name="val" type="CT_NumDataSource" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_PieSer"> + <xsd:sequence> + <xsd:group ref="EG_SerShared" minOccurs="1" maxOccurs="1"/> + <xsd:element name="explosion" type="CT_UnsignedInt" minOccurs="0" maxOccurs="1"/> + <xsd:element name="dPt" type="CT_DPt" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="dLbls" type="CT_DLbls" minOccurs="0" maxOccurs="1"/> + <xsd:element name="cat" type="CT_AxDataSource" minOccurs="0" maxOccurs="1"/> + <xsd:element name="val" type="CT_NumDataSource" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_BubbleSer"> + <xsd:sequence> + <xsd:group ref="EG_SerShared" minOccurs="1" maxOccurs="1"/> + <xsd:element name="invertIfNegative" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="dPt" type="CT_DPt" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="dLbls" type="CT_DLbls" minOccurs="0" maxOccurs="1"/> + <xsd:element name="trendline" type="CT_Trendline" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="errBars" type="CT_ErrBars" minOccurs="0" maxOccurs="2"/> + <xsd:element name="xVal" type="CT_AxDataSource" minOccurs="0" maxOccurs="1"/> + <xsd:element name="yVal" type="CT_NumDataSource" minOccurs="0" maxOccurs="1"/> + <xsd:element name="bubbleSize" type="CT_NumDataSource" minOccurs="0" maxOccurs="1"/> + <xsd:element name="bubble3D" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SurfaceSer"> + <xsd:sequence> + <xsd:group ref="EG_SerShared" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cat" type="CT_AxDataSource" minOccurs="0" maxOccurs="1"/> + <xsd:element name="val" type="CT_NumDataSource" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_Grouping"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="percentStacked"/> + <xsd:enumeration value="standard"/> + <xsd:enumeration value="stacked"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Grouping"> + <xsd:attribute name="val" type="ST_Grouping" default="standard"/> + </xsd:complexType> + <xsd:complexType name="CT_ChartLines"> + <xsd:sequence> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:group name="EG_LineChartShared"> + <xsd:sequence> + <xsd:element name="grouping" type="CT_Grouping" minOccurs="1" maxOccurs="1"/> + <xsd:element name="varyColors" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="ser" type="CT_LineSer" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="dLbls" type="CT_DLbls" minOccurs="0" maxOccurs="1"/> + <xsd:element name="dropLines" type="CT_ChartLines" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:group> + <xsd:complexType name="CT_LineChart"> + <xsd:sequence> + <xsd:group ref="EG_LineChartShared" minOccurs="1" maxOccurs="1"/> + <xsd:element name="hiLowLines" type="CT_ChartLines" minOccurs="0" maxOccurs="1"/> + <xsd:element name="upDownBars" type="CT_UpDownBars" minOccurs="0" maxOccurs="1"/> + <xsd:element name="marker" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="smooth" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="axId" type="CT_UnsignedInt" minOccurs="2" maxOccurs="2"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Line3DChart"> + <xsd:sequence> + <xsd:group ref="EG_LineChartShared" minOccurs="1" maxOccurs="1"/> + <xsd:element name="gapDepth" type="CT_GapAmount" minOccurs="0" maxOccurs="1"/> + <xsd:element name="axId" type="CT_UnsignedInt" minOccurs="3" maxOccurs="3"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_StockChart"> + <xsd:sequence> + <xsd:element name="ser" type="CT_LineSer" minOccurs="3" maxOccurs="4"/> + <xsd:element name="dLbls" type="CT_DLbls" minOccurs="0" maxOccurs="1"/> + <xsd:element name="dropLines" type="CT_ChartLines" minOccurs="0" maxOccurs="1"/> + <xsd:element name="hiLowLines" type="CT_ChartLines" minOccurs="0" maxOccurs="1"/> + <xsd:element name="upDownBars" type="CT_UpDownBars" minOccurs="0" maxOccurs="1"/> + <xsd:element name="axId" type="CT_UnsignedInt" minOccurs="2" maxOccurs="2"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_ScatterStyle"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="line"/> + <xsd:enumeration value="lineMarker"/> + <xsd:enumeration value="marker"/> + <xsd:enumeration value="smooth"/> + <xsd:enumeration value="smoothMarker"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_ScatterStyle"> + <xsd:attribute name="val" type="ST_ScatterStyle" default="marker"/> + </xsd:complexType> + <xsd:complexType name="CT_ScatterChart"> + <xsd:sequence> + <xsd:element name="scatterStyle" type="CT_ScatterStyle" minOccurs="1" maxOccurs="1"/> + <xsd:element name="varyColors" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="ser" type="CT_ScatterSer" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="dLbls" type="CT_DLbls" minOccurs="0" maxOccurs="1"/> + <xsd:element name="axId" type="CT_UnsignedInt" minOccurs="2" maxOccurs="2"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_RadarStyle"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="standard"/> + <xsd:enumeration value="marker"/> + <xsd:enumeration value="filled"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_RadarStyle"> + <xsd:attribute name="val" type="ST_RadarStyle" default="standard"/> + </xsd:complexType> + <xsd:complexType name="CT_RadarChart"> + <xsd:sequence> + <xsd:element name="radarStyle" type="CT_RadarStyle" minOccurs="1" maxOccurs="1"/> + <xsd:element name="varyColors" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="ser" type="CT_RadarSer" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="dLbls" type="CT_DLbls" minOccurs="0" maxOccurs="1"/> + <xsd:element name="axId" type="CT_UnsignedInt" minOccurs="2" maxOccurs="2"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_BarGrouping"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="percentStacked"/> + <xsd:enumeration value="clustered"/> + <xsd:enumeration value="standard"/> + <xsd:enumeration value="stacked"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_BarGrouping"> + <xsd:attribute name="val" type="ST_BarGrouping" default="clustered"/> + </xsd:complexType> + <xsd:simpleType name="ST_BarDir"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="bar"/> + <xsd:enumeration value="col"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_BarDir"> + <xsd:attribute name="val" type="ST_BarDir" default="col"/> + </xsd:complexType> + <xsd:simpleType name="ST_Shape"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="cone"/> + <xsd:enumeration value="coneToMax"/> + <xsd:enumeration value="box"/> + <xsd:enumeration value="cylinder"/> + <xsd:enumeration value="pyramid"/> + <xsd:enumeration value="pyramidToMax"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Shape"> + <xsd:attribute name="val" type="ST_Shape" default="box"/> + </xsd:complexType> + <xsd:group name="EG_BarChartShared"> + <xsd:sequence> + <xsd:element name="barDir" type="CT_BarDir" minOccurs="1" maxOccurs="1"/> + <xsd:element name="grouping" type="CT_BarGrouping" minOccurs="0" maxOccurs="1"/> + <xsd:element name="varyColors" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="ser" type="CT_BarSer" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="dLbls" type="CT_DLbls" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:group> + <xsd:complexType name="CT_BarChart"> + <xsd:sequence> + <xsd:group ref="EG_BarChartShared" minOccurs="1" maxOccurs="1"/> + <xsd:element name="gapWidth" type="CT_GapAmount" minOccurs="0" maxOccurs="1"/> + <xsd:element name="overlap" type="CT_Overlap" minOccurs="0" maxOccurs="1"/> + <xsd:element name="serLines" type="CT_ChartLines" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="axId" type="CT_UnsignedInt" minOccurs="2" maxOccurs="2"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Bar3DChart"> + <xsd:sequence> + <xsd:group ref="EG_BarChartShared" minOccurs="1" maxOccurs="1"/> + <xsd:element name="gapWidth" type="CT_GapAmount" minOccurs="0" maxOccurs="1"/> + <xsd:element name="gapDepth" type="CT_GapAmount" minOccurs="0" maxOccurs="1"/> + <xsd:element name="shape" type="CT_Shape" minOccurs="0" maxOccurs="1"/> + <xsd:element name="axId" type="CT_UnsignedInt" minOccurs="2" maxOccurs="3"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:group name="EG_AreaChartShared"> + <xsd:sequence> + <xsd:element name="grouping" type="CT_Grouping" minOccurs="0" maxOccurs="1"/> + <xsd:element name="varyColors" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="ser" type="CT_AreaSer" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="dLbls" type="CT_DLbls" minOccurs="0" maxOccurs="1"/> + <xsd:element name="dropLines" type="CT_ChartLines" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:group> + <xsd:complexType name="CT_AreaChart"> + <xsd:sequence> + <xsd:group ref="EG_AreaChartShared" minOccurs="1" maxOccurs="1"/> + <xsd:element name="axId" type="CT_UnsignedInt" minOccurs="2" maxOccurs="2"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Area3DChart"> + <xsd:sequence> + <xsd:group ref="EG_AreaChartShared" minOccurs="1" maxOccurs="1"/> + <xsd:element name="gapDepth" type="CT_GapAmount" minOccurs="0" maxOccurs="1"/> + <xsd:element name="axId" type="CT_UnsignedInt" minOccurs="2" maxOccurs="3"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:group name="EG_PieChartShared"> + <xsd:sequence> + <xsd:element name="varyColors" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="ser" type="CT_PieSer" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="dLbls" type="CT_DLbls" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:group> + <xsd:complexType name="CT_PieChart"> + <xsd:sequence> + <xsd:group ref="EG_PieChartShared" minOccurs="1" maxOccurs="1"/> + <xsd:element name="firstSliceAng" type="CT_FirstSliceAng" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Pie3DChart"> + <xsd:sequence> + <xsd:group ref="EG_PieChartShared" minOccurs="1" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_DoughnutChart"> + <xsd:sequence> + <xsd:group ref="EG_PieChartShared" minOccurs="1" maxOccurs="1"/> + <xsd:element name="firstSliceAng" type="CT_FirstSliceAng" minOccurs="0" maxOccurs="1"/> + <xsd:element name="holeSize" type="CT_HoleSize" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_OfPieType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="pie"/> + <xsd:enumeration value="bar"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_OfPieType"> + <xsd:attribute name="val" type="ST_OfPieType" default="pie"/> + </xsd:complexType> + <xsd:complexType name="CT_OfPieChart"> + <xsd:sequence> + <xsd:element name="ofPieType" type="CT_OfPieType" minOccurs="1" maxOccurs="1"/> + <xsd:group ref="EG_PieChartShared" minOccurs="1" maxOccurs="1"/> + <xsd:element name="gapWidth" type="CT_GapAmount" minOccurs="0" maxOccurs="1"/> + <xsd:element name="splitType" type="CT_SplitType" minOccurs="0" maxOccurs="1"/> + <xsd:element name="splitPos" type="CT_Double" minOccurs="0" maxOccurs="1"/> + <xsd:element name="custSplit" type="CT_CustSplit" minOccurs="0" maxOccurs="1"/> + <xsd:element name="secondPieSize" type="CT_SecondPieSize" minOccurs="0" maxOccurs="1"/> + <xsd:element name="serLines" type="CT_ChartLines" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_BubbleChart"> + <xsd:sequence> + <xsd:element name="varyColors" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="ser" type="CT_BubbleSer" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="dLbls" type="CT_DLbls" minOccurs="0" maxOccurs="1"/> + <xsd:element name="bubble3D" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="bubbleScale" type="CT_BubbleScale" minOccurs="0" maxOccurs="1"/> + <xsd:element name="showNegBubbles" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sizeRepresents" type="CT_SizeRepresents" minOccurs="0" maxOccurs="1"/> + <xsd:element name="axId" type="CT_UnsignedInt" minOccurs="2" maxOccurs="2"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_BandFmt"> + <xsd:sequence> + <xsd:element name="idx" type="CT_UnsignedInt" minOccurs="1" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_BandFmts"> + <xsd:sequence> + <xsd:element name="bandFmt" type="CT_BandFmt" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:group name="EG_SurfaceChartShared"> + <xsd:sequence> + <xsd:element name="wireframe" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="ser" type="CT_SurfaceSer" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="bandFmts" type="CT_BandFmts" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:group> + <xsd:complexType name="CT_SurfaceChart"> + <xsd:sequence> + <xsd:group ref="EG_SurfaceChartShared" minOccurs="1" maxOccurs="1"/> + <xsd:element name="axId" type="CT_UnsignedInt" minOccurs="2" maxOccurs="3"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Surface3DChart"> + <xsd:sequence> + <xsd:group ref="EG_SurfaceChartShared" minOccurs="1" maxOccurs="1"/> + <xsd:element name="axId" type="CT_UnsignedInt" minOccurs="3" maxOccurs="3"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_AxPos"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="b"/> + <xsd:enumeration value="l"/> + <xsd:enumeration value="r"/> + <xsd:enumeration value="t"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_AxPos"> + <xsd:attribute name="val" type="ST_AxPos" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_Crosses"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="autoZero"/> + <xsd:enumeration value="max"/> + <xsd:enumeration value="min"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Crosses"> + <xsd:attribute name="val" type="ST_Crosses" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_CrossBetween"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="between"/> + <xsd:enumeration value="midCat"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_CrossBetween"> + <xsd:attribute name="val" type="ST_CrossBetween" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_TickMark"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="cross"/> + <xsd:enumeration value="in"/> + <xsd:enumeration value="none"/> + <xsd:enumeration value="out"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TickMark"> + <xsd:attribute name="val" type="ST_TickMark" default="cross"/> + </xsd:complexType> + <xsd:simpleType name="ST_TickLblPos"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="high"/> + <xsd:enumeration value="low"/> + <xsd:enumeration value="nextTo"/> + <xsd:enumeration value="none"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TickLblPos"> + <xsd:attribute name="val" type="ST_TickLblPos" default="nextTo"/> + </xsd:complexType> + <xsd:simpleType name="ST_Skip"> + <xsd:restriction base="xsd:unsignedInt"> + <xsd:minInclusive value="1"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Skip"> + <xsd:attribute name="val" type="ST_Skip" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_TimeUnit"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="days"/> + <xsd:enumeration value="months"/> + <xsd:enumeration value="years"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TimeUnit"> + <xsd:attribute name="val" type="ST_TimeUnit" default="days"/> + </xsd:complexType> + <xsd:simpleType name="ST_AxisUnit"> + <xsd:restriction base="xsd:double"> + <xsd:minExclusive value="0"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_AxisUnit"> + <xsd:attribute name="val" type="ST_AxisUnit" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_BuiltInUnit"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="hundreds"/> + <xsd:enumeration value="thousands"/> + <xsd:enumeration value="tenThousands"/> + <xsd:enumeration value="hundredThousands"/> + <xsd:enumeration value="millions"/> + <xsd:enumeration value="tenMillions"/> + <xsd:enumeration value="hundredMillions"/> + <xsd:enumeration value="billions"/> + <xsd:enumeration value="trillions"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_BuiltInUnit"> + <xsd:attribute name="val" type="ST_BuiltInUnit" default="thousands"/> + </xsd:complexType> + <xsd:simpleType name="ST_PictureFormat"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="stretch"/> + <xsd:enumeration value="stack"/> + <xsd:enumeration value="stackScale"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_PictureFormat"> + <xsd:attribute name="val" type="ST_PictureFormat" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_PictureStackUnit"> + <xsd:restriction base="xsd:double"> + <xsd:minExclusive value="0"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_PictureStackUnit"> + <xsd:attribute name="val" type="ST_PictureStackUnit" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_PictureOptions"> + <xsd:sequence> + <xsd:element name="applyToFront" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="applyToSides" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="applyToEnd" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="pictureFormat" type="CT_PictureFormat" minOccurs="0" maxOccurs="1"/> + <xsd:element name="pictureStackUnit" type="CT_PictureStackUnit" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_DispUnitsLbl"> + <xsd:sequence> + <xsd:element name="layout" type="CT_Layout" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tx" type="CT_Tx" minOccurs="0" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="txPr" type="a:CT_TextBody" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_DispUnits"> + <xsd:sequence> + <xsd:choice> + <xsd:element name="custUnit" type="CT_Double" minOccurs="1" maxOccurs="1"/> + <xsd:element name="builtInUnit" type="CT_BuiltInUnit" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + <xsd:element name="dispUnitsLbl" type="CT_DispUnitsLbl" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_Orientation"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="maxMin"/> + <xsd:enumeration value="minMax"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Orientation"> + <xsd:attribute name="val" type="ST_Orientation" default="minMax"/> + </xsd:complexType> + <xsd:simpleType name="ST_LogBase"> + <xsd:restriction base="xsd:double"> + <xsd:minInclusive value="2"/> + <xsd:maxInclusive value="1000"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_LogBase"> + <xsd:attribute name="val" type="ST_LogBase" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Scaling"> + <xsd:sequence> + <xsd:element name="logBase" type="CT_LogBase" minOccurs="0" maxOccurs="1"/> + <xsd:element name="orientation" type="CT_Orientation" minOccurs="0" maxOccurs="1"/> + <xsd:element name="max" type="CT_Double" minOccurs="0" maxOccurs="1"/> + <xsd:element name="min" type="CT_Double" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_LblOffset"> + <xsd:union memberTypes="ST_LblOffsetPercent ST_LblOffsetUShort"/> + </xsd:simpleType> + <xsd:simpleType name="ST_LblOffsetPercent"> + <xsd:restriction base="xsd:string"> + <xsd:pattern value="0*(([0-9])|([1-9][0-9])|([1-9][0-9][0-9])|1000)%"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_LblOffsetUShort"> + <xsd:restriction base="xsd:unsignedShort"> + <xsd:minInclusive value="0"/> + <xsd:maxInclusive value="1000"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_LblOffset"> + <xsd:attribute name="val" type="ST_LblOffset" default="100%"/> + </xsd:complexType> + <xsd:group name="EG_AxShared"> + <xsd:sequence> + <xsd:element name="axId" type="CT_UnsignedInt" minOccurs="1" maxOccurs="1"/> + <xsd:element name="scaling" type="CT_Scaling" minOccurs="1" maxOccurs="1"/> + <xsd:element name="delete" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="axPos" type="CT_AxPos" minOccurs="1" maxOccurs="1"/> + <xsd:element name="majorGridlines" type="CT_ChartLines" minOccurs="0" maxOccurs="1"/> + <xsd:element name="minorGridlines" type="CT_ChartLines" minOccurs="0" maxOccurs="1"/> + <xsd:element name="title" type="CT_Title" minOccurs="0" maxOccurs="1"/> + <xsd:element name="numFmt" type="CT_NumFmt" minOccurs="0" maxOccurs="1"/> + <xsd:element name="majorTickMark" type="CT_TickMark" minOccurs="0" maxOccurs="1"/> + <xsd:element name="minorTickMark" type="CT_TickMark" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tickLblPos" type="CT_TickLblPos" minOccurs="0" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="txPr" type="a:CT_TextBody" minOccurs="0" maxOccurs="1"/> + <xsd:element name="crossAx" type="CT_UnsignedInt" minOccurs="1" maxOccurs="1"/> + <xsd:choice minOccurs="0" maxOccurs="1"> + <xsd:element name="crosses" type="CT_Crosses" minOccurs="1" maxOccurs="1"/> + <xsd:element name="crossesAt" type="CT_Double" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:sequence> + </xsd:group> + <xsd:complexType name="CT_CatAx"> + <xsd:sequence> + <xsd:group ref="EG_AxShared" minOccurs="1" maxOccurs="1"/> + <xsd:element name="auto" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="lblAlgn" type="CT_LblAlgn" minOccurs="0" maxOccurs="1"/> + <xsd:element name="lblOffset" type="CT_LblOffset" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tickLblSkip" type="CT_Skip" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tickMarkSkip" type="CT_Skip" minOccurs="0" maxOccurs="1"/> + <xsd:element name="noMultiLvlLbl" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_DateAx"> + <xsd:sequence> + <xsd:group ref="EG_AxShared" minOccurs="1" maxOccurs="1"/> + <xsd:element name="auto" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="lblOffset" type="CT_LblOffset" minOccurs="0" maxOccurs="1"/> + <xsd:element name="baseTimeUnit" type="CT_TimeUnit" minOccurs="0" maxOccurs="1"/> + <xsd:element name="majorUnit" type="CT_AxisUnit" minOccurs="0" maxOccurs="1"/> + <xsd:element name="majorTimeUnit" type="CT_TimeUnit" minOccurs="0" maxOccurs="1"/> + <xsd:element name="minorUnit" type="CT_AxisUnit" minOccurs="0" maxOccurs="1"/> + <xsd:element name="minorTimeUnit" type="CT_TimeUnit" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SerAx"> + <xsd:sequence> + <xsd:group ref="EG_AxShared" minOccurs="1" maxOccurs="1"/> + <xsd:element name="tickLblSkip" type="CT_Skip" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tickMarkSkip" type="CT_Skip" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_ValAx"> + <xsd:sequence> + <xsd:group ref="EG_AxShared" minOccurs="1" maxOccurs="1"/> + <xsd:element name="crossBetween" type="CT_CrossBetween" minOccurs="0" maxOccurs="1"/> + <xsd:element name="majorUnit" type="CT_AxisUnit" minOccurs="0" maxOccurs="1"/> + <xsd:element name="minorUnit" type="CT_AxisUnit" minOccurs="0" maxOccurs="1"/> + <xsd:element name="dispUnits" type="CT_DispUnits" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_PlotArea"> + <xsd:sequence> + <xsd:element name="layout" type="CT_Layout" minOccurs="0" maxOccurs="1"/> + <xsd:choice minOccurs="1" maxOccurs="unbounded"> + <xsd:element name="areaChart" type="CT_AreaChart" minOccurs="1" maxOccurs="1"/> + <xsd:element name="area3DChart" type="CT_Area3DChart" minOccurs="1" maxOccurs="1"/> + <xsd:element name="lineChart" type="CT_LineChart" minOccurs="1" maxOccurs="1"/> + <xsd:element name="line3DChart" type="CT_Line3DChart" minOccurs="1" maxOccurs="1"/> + <xsd:element name="stockChart" type="CT_StockChart" minOccurs="1" maxOccurs="1"/> + <xsd:element name="radarChart" type="CT_RadarChart" minOccurs="1" maxOccurs="1"/> + <xsd:element name="scatterChart" type="CT_ScatterChart" minOccurs="1" maxOccurs="1"/> + <xsd:element name="pieChart" type="CT_PieChart" minOccurs="1" maxOccurs="1"/> + <xsd:element name="pie3DChart" type="CT_Pie3DChart" minOccurs="1" maxOccurs="1"/> + <xsd:element name="doughnutChart" type="CT_DoughnutChart" minOccurs="1" maxOccurs="1"/> + <xsd:element name="barChart" type="CT_BarChart" minOccurs="1" maxOccurs="1"/> + <xsd:element name="bar3DChart" type="CT_Bar3DChart" minOccurs="1" maxOccurs="1"/> + <xsd:element name="ofPieChart" type="CT_OfPieChart" minOccurs="1" maxOccurs="1"/> + <xsd:element name="surfaceChart" type="CT_SurfaceChart" minOccurs="1" maxOccurs="1"/> + <xsd:element name="surface3DChart" type="CT_Surface3DChart" minOccurs="1" maxOccurs="1"/> + <xsd:element name="bubbleChart" type="CT_BubbleChart" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + <xsd:choice minOccurs="0" maxOccurs="unbounded"> + <xsd:element name="valAx" type="CT_ValAx" minOccurs="1" maxOccurs="1"/> + <xsd:element name="catAx" type="CT_CatAx" minOccurs="1" maxOccurs="1"/> + <xsd:element name="dateAx" type="CT_DateAx" minOccurs="1" maxOccurs="1"/> + <xsd:element name="serAx" type="CT_SerAx" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + <xsd:element name="dTable" type="CT_DTable" minOccurs="0" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_PivotFmt"> + <xsd:sequence> + <xsd:element name="idx" type="CT_UnsignedInt" minOccurs="1" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="txPr" type="a:CT_TextBody" minOccurs="0" maxOccurs="1"/> + <xsd:element name="marker" type="CT_Marker" minOccurs="0" maxOccurs="1"/> + <xsd:element name="dLbl" type="CT_DLbl" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_PivotFmts"> + <xsd:sequence> + <xsd:element name="pivotFmt" type="CT_PivotFmt" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_LegendPos"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="b"/> + <xsd:enumeration value="tr"/> + <xsd:enumeration value="l"/> + <xsd:enumeration value="r"/> + <xsd:enumeration value="t"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_LegendPos"> + <xsd:attribute name="val" type="ST_LegendPos" default="r"/> + </xsd:complexType> + <xsd:group name="EG_LegendEntryData"> + <xsd:sequence> + <xsd:element name="txPr" type="a:CT_TextBody" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:group> + <xsd:complexType name="CT_LegendEntry"> + <xsd:sequence> + <xsd:element name="idx" type="CT_UnsignedInt" minOccurs="1" maxOccurs="1"/> + <xsd:choice> + <xsd:element name="delete" type="CT_Boolean" minOccurs="1" maxOccurs="1"/> + <xsd:group ref="EG_LegendEntryData" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Legend"> + <xsd:sequence> + <xsd:element name="legendPos" type="CT_LegendPos" minOccurs="0" maxOccurs="1"/> + <xsd:element name="legendEntry" type="CT_LegendEntry" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="layout" type="CT_Layout" minOccurs="0" maxOccurs="1"/> + <xsd:element name="overlay" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="txPr" type="a:CT_TextBody" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_DispBlanksAs"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="span"/> + <xsd:enumeration value="gap"/> + <xsd:enumeration value="zero"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_DispBlanksAs"> + <xsd:attribute name="val" type="ST_DispBlanksAs" default="zero"/> + </xsd:complexType> + <xsd:complexType name="CT_Chart"> + <xsd:sequence> + <xsd:element name="title" type="CT_Title" minOccurs="0" maxOccurs="1"/> + <xsd:element name="autoTitleDeleted" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="pivotFmts" type="CT_PivotFmts" minOccurs="0" maxOccurs="1"/> + <xsd:element name="view3D" type="CT_View3D" minOccurs="0" maxOccurs="1"/> + <xsd:element name="floor" type="CT_Surface" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sideWall" type="CT_Surface" minOccurs="0" maxOccurs="1"/> + <xsd:element name="backWall" type="CT_Surface" minOccurs="0" maxOccurs="1"/> + <xsd:element name="plotArea" type="CT_PlotArea" minOccurs="1" maxOccurs="1"/> + <xsd:element name="legend" type="CT_Legend" minOccurs="0" maxOccurs="1"/> + <xsd:element name="plotVisOnly" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="dispBlanksAs" type="CT_DispBlanksAs" minOccurs="0" maxOccurs="1"/> + <xsd:element name="showDLblsOverMax" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_Style"> + <xsd:restriction base="xsd:unsignedByte"> + <xsd:minInclusive value="1"/> + <xsd:maxInclusive value="48"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Style"> + <xsd:attribute name="val" type="ST_Style" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_PivotSource"> + <xsd:sequence> + <xsd:element name="name" type="s:ST_Xstring" minOccurs="1" maxOccurs="1"/> + <xsd:element name="fmtId" type="CT_UnsignedInt" minOccurs="1" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Protection"> + <xsd:sequence> + <xsd:element name="chartObject" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="data" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="formatting" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="selection" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="userInterface" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_HeaderFooter"> + <xsd:sequence> + <xsd:element name="oddHeader" type="s:ST_Xstring" minOccurs="0" maxOccurs="1"/> + <xsd:element name="oddFooter" type="s:ST_Xstring" minOccurs="0" maxOccurs="1"/> + <xsd:element name="evenHeader" type="s:ST_Xstring" minOccurs="0" maxOccurs="1"/> + <xsd:element name="evenFooter" type="s:ST_Xstring" minOccurs="0" maxOccurs="1"/> + <xsd:element name="firstHeader" type="s:ST_Xstring" minOccurs="0" maxOccurs="1"/> + <xsd:element name="firstFooter" type="s:ST_Xstring" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="alignWithMargins" type="xsd:boolean" default="true"/> + <xsd:attribute name="differentOddEven" type="xsd:boolean" default="false"/> + <xsd:attribute name="differentFirst" type="xsd:boolean" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_PageMargins"> + <xsd:attribute name="l" type="xsd:double" use="required"/> + <xsd:attribute name="r" type="xsd:double" use="required"/> + <xsd:attribute name="t" type="xsd:double" use="required"/> + <xsd:attribute name="b" type="xsd:double" use="required"/> + <xsd:attribute name="header" type="xsd:double" use="required"/> + <xsd:attribute name="footer" type="xsd:double" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_PageSetupOrientation"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="default"/> + <xsd:enumeration value="portrait"/> + <xsd:enumeration value="landscape"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_ExternalData"> + <xsd:sequence> + <xsd:element name="autoUpdate" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_PageSetup"> + <xsd:attribute name="paperSize" type="xsd:unsignedInt" use="optional" default="1"/> + <xsd:attribute name="paperHeight" type="s:ST_PositiveUniversalMeasure" use="optional"/> + <xsd:attribute name="paperWidth" type="s:ST_PositiveUniversalMeasure" use="optional"/> + <xsd:attribute name="firstPageNumber" type="xsd:unsignedInt" use="optional" default="1"/> + <xsd:attribute name="orientation" type="ST_PageSetupOrientation" use="optional" + default="default"/> + <xsd:attribute name="blackAndWhite" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="draft" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="useFirstPageNumber" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="horizontalDpi" type="xsd:int" use="optional" default="600"/> + <xsd:attribute name="verticalDpi" type="xsd:int" use="optional" default="600"/> + <xsd:attribute name="copies" type="xsd:unsignedInt" use="optional" default="1"/> + </xsd:complexType> + <xsd:complexType name="CT_PrintSettings"> + <xsd:sequence> + <xsd:element name="headerFooter" type="CT_HeaderFooter" minOccurs="0" maxOccurs="1"/> + <xsd:element name="pageMargins" type="CT_PageMargins" minOccurs="0" maxOccurs="1"/> + <xsd:element name="pageSetup" type="CT_PageSetup" minOccurs="0" maxOccurs="1"/> + <xsd:element name="legacyDrawingHF" type="CT_RelId" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_ChartSpace"> + <xsd:sequence> + <xsd:element name="date1904" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="lang" type="CT_TextLanguageID" minOccurs="0" maxOccurs="1"/> + <xsd:element name="roundedCorners" type="CT_Boolean" minOccurs="0" maxOccurs="1"/> + <xsd:element name="style" type="CT_Style" minOccurs="0" maxOccurs="1"/> + <xsd:element name="clrMapOvr" type="a:CT_ColorMapping" minOccurs="0" maxOccurs="1"/> + <xsd:element name="pivotSource" type="CT_PivotSource" minOccurs="0" maxOccurs="1"/> + <xsd:element name="protection" type="CT_Protection" minOccurs="0" maxOccurs="1"/> + <xsd:element name="chart" type="CT_Chart" minOccurs="1" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="txPr" type="a:CT_TextBody" minOccurs="0" maxOccurs="1"/> + <xsd:element name="externalData" type="CT_ExternalData" minOccurs="0" maxOccurs="1"/> + <xsd:element name="printSettings" type="CT_PrintSettings" minOccurs="0" maxOccurs="1"/> + <xsd:element name="userShapes" type="CT_RelId" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="chartSpace" type="CT_ChartSpace"/> + <xsd:element name="userShapes" type="cdr:CT_Drawing"/> + <xsd:element name="chart" type="CT_RelId"/> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/dml-chartDrawing.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/dml-chartDrawing.xsd new file mode 100644 index 00000000..afa4f463 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/dml-chartDrawing.xsd @@ -0,0 +1,146 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" + xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" + xmlns="http://schemas.openxmlformats.org/drawingml/2006/chartDrawing" + targetNamespace="http://schemas.openxmlformats.org/drawingml/2006/chartDrawing" + elementFormDefault="qualified"> + <xsd:import namespace="http://schemas.openxmlformats.org/drawingml/2006/main" + schemaLocation="dml-main.xsd"/> + <xsd:complexType name="CT_ShapeNonVisual"> + <xsd:sequence> + <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cNvSpPr" type="a:CT_NonVisualDrawingShapeProps" minOccurs="1" maxOccurs="1" + /> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Shape"> + <xsd:sequence> + <xsd:element name="nvSpPr" type="CT_ShapeNonVisual" minOccurs="1" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="style" type="a:CT_ShapeStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="txBody" type="a:CT_TextBody" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="macro" type="xsd:string" use="optional"/> + <xsd:attribute name="textlink" type="xsd:string" use="optional"/> + <xsd:attribute name="fLocksText" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="fPublished" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_ConnectorNonVisual"> + <xsd:sequence> + <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cNvCxnSpPr" type="a:CT_NonVisualConnectorProperties" minOccurs="1" + maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Connector"> + <xsd:sequence> + <xsd:element name="nvCxnSpPr" type="CT_ConnectorNonVisual" minOccurs="1" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="style" type="a:CT_ShapeStyle" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="macro" type="xsd:string" use="optional"/> + <xsd:attribute name="fPublished" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_PictureNonVisual"> + <xsd:sequence> + <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cNvPicPr" type="a:CT_NonVisualPictureProperties" minOccurs="1" + maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Picture"> + <xsd:sequence> + <xsd:element name="nvPicPr" type="CT_PictureNonVisual" minOccurs="1" maxOccurs="1"/> + <xsd:element name="blipFill" type="a:CT_BlipFillProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="style" type="a:CT_ShapeStyle" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="macro" type="xsd:string" use="optional" default=""/> + <xsd:attribute name="fPublished" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_GraphicFrameNonVisual"> + <xsd:sequence> + <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cNvGraphicFramePr" type="a:CT_NonVisualGraphicFrameProperties" + minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_GraphicFrame"> + <xsd:sequence> + <xsd:element name="nvGraphicFramePr" type="CT_GraphicFrameNonVisual" minOccurs="1" + maxOccurs="1"/> + <xsd:element name="xfrm" type="a:CT_Transform2D" minOccurs="1" maxOccurs="1"/> + <xsd:element ref="a:graphic" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="macro" type="xsd:string" use="optional"/> + <xsd:attribute name="fPublished" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_GroupShapeNonVisual"> + <xsd:sequence> + <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cNvGrpSpPr" type="a:CT_NonVisualGroupDrawingShapeProps" minOccurs="1" + maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_GroupShape"> + <xsd:sequence> + <xsd:element name="nvGrpSpPr" type="CT_GroupShapeNonVisual" minOccurs="1" maxOccurs="1"/> + <xsd:element name="grpSpPr" type="a:CT_GroupShapeProperties" minOccurs="1" maxOccurs="1"/> + <xsd:choice minOccurs="0" maxOccurs="unbounded"> + <xsd:element name="sp" type="CT_Shape"/> + <xsd:element name="grpSp" type="CT_GroupShape"/> + <xsd:element name="graphicFrame" type="CT_GraphicFrame"/> + <xsd:element name="cxnSp" type="CT_Connector"/> + <xsd:element name="pic" type="CT_Picture"/> + </xsd:choice> + </xsd:sequence> + </xsd:complexType> + <xsd:group name="EG_ObjectChoices"> + <xsd:sequence> + <xsd:choice minOccurs="1" maxOccurs="1"> + <xsd:element name="sp" type="CT_Shape"/> + <xsd:element name="grpSp" type="CT_GroupShape"/> + <xsd:element name="graphicFrame" type="CT_GraphicFrame"/> + <xsd:element name="cxnSp" type="CT_Connector"/> + <xsd:element name="pic" type="CT_Picture"/> + </xsd:choice> + </xsd:sequence> + </xsd:group> + <xsd:simpleType name="ST_MarkerCoordinate"> + <xsd:restriction base="xsd:double"> + <xsd:minInclusive value="0.0"/> + <xsd:maxInclusive value="1.0"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Marker"> + <xsd:sequence> + <xsd:element name="x" type="ST_MarkerCoordinate" minOccurs="1" maxOccurs="1"/> + <xsd:element name="y" type="ST_MarkerCoordinate" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_RelSizeAnchor"> + <xsd:sequence> + <xsd:element name="from" type="CT_Marker"/> + <xsd:element name="to" type="CT_Marker"/> + <xsd:group ref="EG_ObjectChoices"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_AbsSizeAnchor"> + <xsd:sequence> + <xsd:element name="from" type="CT_Marker"/> + <xsd:element name="ext" type="a:CT_PositiveSize2D"/> + <xsd:group ref="EG_ObjectChoices"/> + </xsd:sequence> + </xsd:complexType> + <xsd:group name="EG_Anchor"> + <xsd:choice> + <xsd:element name="relSizeAnchor" type="CT_RelSizeAnchor"/> + <xsd:element name="absSizeAnchor" type="CT_AbsSizeAnchor"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_Drawing"> + <xsd:sequence> + <xsd:group ref="EG_Anchor" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/dml-diagram.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/dml-diagram.xsd new file mode 100644 index 00000000..64e66b8a --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/dml-diagram.xsd @@ -0,0 +1,1085 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" + xmlns="http://schemas.openxmlformats.org/drawingml/2006/diagram" + xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" + xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" + xmlns:s="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + targetNamespace="http://schemas.openxmlformats.org/drawingml/2006/diagram" + elementFormDefault="qualified" attributeFormDefault="unqualified"> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/relationships" + schemaLocation="shared-relationshipReference.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/drawingml/2006/main" + schemaLocation="dml-main.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + schemaLocation="shared-commonSimpleTypes.xsd"/> + <xsd:complexType name="CT_CTName"> + <xsd:attribute name="lang" type="xsd:string" use="optional" default=""/> + <xsd:attribute name="val" type="xsd:string" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_CTDescription"> + <xsd:attribute name="lang" type="xsd:string" use="optional" default=""/> + <xsd:attribute name="val" type="xsd:string" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_CTCategory"> + <xsd:attribute name="type" type="xsd:anyURI" use="required"/> + <xsd:attribute name="pri" type="xsd:unsignedInt" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_CTCategories"> + <xsd:sequence minOccurs="0" maxOccurs="unbounded"> + <xsd:element name="cat" type="CT_CTCategory" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_ClrAppMethod"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="span"/> + <xsd:enumeration value="cycle"/> + <xsd:enumeration value="repeat"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_HueDir"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="cw"/> + <xsd:enumeration value="ccw"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Colors"> + <xsd:sequence> + <xsd:group ref="a:EG_ColorChoice" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="meth" type="ST_ClrAppMethod" use="optional" default="span"/> + <xsd:attribute name="hueDir" type="ST_HueDir" use="optional" default="cw"/> + </xsd:complexType> + <xsd:complexType name="CT_CTStyleLabel"> + <xsd:sequence> + <xsd:element name="fillClrLst" type="CT_Colors" minOccurs="0" maxOccurs="1"/> + <xsd:element name="linClrLst" type="CT_Colors" minOccurs="0" maxOccurs="1"/> + <xsd:element name="effectClrLst" type="CT_Colors" minOccurs="0" maxOccurs="1"/> + <xsd:element name="txLinClrLst" type="CT_Colors" minOccurs="0" maxOccurs="1"/> + <xsd:element name="txFillClrLst" type="CT_Colors" minOccurs="0" maxOccurs="1"/> + <xsd:element name="txEffectClrLst" type="CT_Colors" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_ColorTransform"> + <xsd:sequence> + <xsd:element name="title" type="CT_CTName" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="desc" type="CT_CTDescription" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="catLst" type="CT_CTCategories" minOccurs="0"/> + <xsd:element name="styleLbl" type="CT_CTStyleLabel" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="uniqueId" type="xsd:string" use="optional" default=""/> + <xsd:attribute name="minVer" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:element name="colorsDef" type="CT_ColorTransform"/> + <xsd:complexType name="CT_ColorTransformHeader"> + <xsd:sequence> + <xsd:element name="title" type="CT_CTName" minOccurs="1" maxOccurs="unbounded"/> + <xsd:element name="desc" type="CT_CTDescription" minOccurs="1" maxOccurs="unbounded"/> + <xsd:element name="catLst" type="CT_CTCategories" minOccurs="0"/> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="uniqueId" type="xsd:string" use="required"/> + <xsd:attribute name="minVer" type="xsd:string" use="optional"/> + <xsd:attribute name="resId" type="xsd:int" use="optional" default="0"/> + </xsd:complexType> + <xsd:element name="colorsDefHdr" type="CT_ColorTransformHeader"/> + <xsd:complexType name="CT_ColorTransformHeaderLst"> + <xsd:sequence> + <xsd:element name="colorsDefHdr" type="CT_ColorTransformHeader" minOccurs="0" + maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="colorsDefHdrLst" type="CT_ColorTransformHeaderLst"/> + <xsd:simpleType name="ST_PtType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="node"/> + <xsd:enumeration value="asst"/> + <xsd:enumeration value="doc"/> + <xsd:enumeration value="pres"/> + <xsd:enumeration value="parTrans"/> + <xsd:enumeration value="sibTrans"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Pt"> + <xsd:sequence> + <xsd:element name="prSet" type="CT_ElemPropSet" minOccurs="0" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="t" type="a:CT_TextBody" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="modelId" type="ST_ModelId" use="required"/> + <xsd:attribute name="type" type="ST_PtType" use="optional" default="node"/> + <xsd:attribute name="cxnId" type="ST_ModelId" use="optional" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_PtList"> + <xsd:sequence> + <xsd:element name="pt" type="CT_Pt" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_CxnType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="parOf"/> + <xsd:enumeration value="presOf"/> + <xsd:enumeration value="presParOf"/> + <xsd:enumeration value="unknownRelationship"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Cxn"> + <xsd:sequence> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="modelId" type="ST_ModelId" use="required"/> + <xsd:attribute name="type" type="ST_CxnType" use="optional" default="parOf"/> + <xsd:attribute name="srcId" type="ST_ModelId" use="required"/> + <xsd:attribute name="destId" type="ST_ModelId" use="required"/> + <xsd:attribute name="srcOrd" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="destOrd" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="parTransId" type="ST_ModelId" use="optional" default="0"/> + <xsd:attribute name="sibTransId" type="ST_ModelId" use="optional" default="0"/> + <xsd:attribute name="presId" type="xsd:string" use="optional" default=""/> + </xsd:complexType> + <xsd:complexType name="CT_CxnList"> + <xsd:sequence> + <xsd:element name="cxn" type="CT_Cxn" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_DataModel"> + <xsd:sequence> + <xsd:element name="ptLst" type="CT_PtList"/> + <xsd:element name="cxnLst" type="CT_CxnList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="bg" type="a:CT_BackgroundFormatting" minOccurs="0"/> + <xsd:element name="whole" type="a:CT_WholeE2oFormatting" minOccurs="0"/> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="dataModel" type="CT_DataModel"/> + <xsd:attributeGroup name="AG_IteratorAttributes"> + <xsd:attribute name="axis" type="ST_AxisTypes" use="optional" default="none"/> + <xsd:attribute name="ptType" type="ST_ElementTypes" use="optional" default="all"/> + <xsd:attribute name="hideLastTrans" type="ST_Booleans" use="optional" default="true"/> + <xsd:attribute name="st" type="ST_Ints" use="optional" default="1"/> + <xsd:attribute name="cnt" type="ST_UnsignedInts" use="optional" default="0"/> + <xsd:attribute name="step" type="ST_Ints" use="optional" default="1"/> + </xsd:attributeGroup> + <xsd:attributeGroup name="AG_ConstraintAttributes"> + <xsd:attribute name="type" type="ST_ConstraintType" use="required"/> + <xsd:attribute name="for" type="ST_ConstraintRelationship" use="optional" default="self"/> + <xsd:attribute name="forName" type="xsd:string" use="optional" default=""/> + <xsd:attribute name="ptType" type="ST_ElementType" use="optional" default="all"/> + </xsd:attributeGroup> + <xsd:attributeGroup name="AG_ConstraintRefAttributes"> + <xsd:attribute name="refType" type="ST_ConstraintType" use="optional" default="none"/> + <xsd:attribute name="refFor" type="ST_ConstraintRelationship" use="optional" default="self"/> + <xsd:attribute name="refForName" type="xsd:string" use="optional" default=""/> + <xsd:attribute name="refPtType" type="ST_ElementType" use="optional" default="all"/> + </xsd:attributeGroup> + <xsd:complexType name="CT_Constraint"> + <xsd:sequence> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_ConstraintAttributes"/> + <xsd:attributeGroup ref="AG_ConstraintRefAttributes"/> + <xsd:attribute name="op" type="ST_BoolOperator" use="optional" default="none"/> + <xsd:attribute name="val" type="xsd:double" use="optional" default="0"/> + <xsd:attribute name="fact" type="xsd:double" use="optional" default="1"/> + </xsd:complexType> + <xsd:complexType name="CT_Constraints"> + <xsd:sequence> + <xsd:element name="constr" type="CT_Constraint" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_NumericRule"> + <xsd:sequence> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_ConstraintAttributes"/> + <xsd:attribute name="val" type="xsd:double" use="optional" default="NaN"/> + <xsd:attribute name="fact" type="xsd:double" use="optional" default="NaN"/> + <xsd:attribute name="max" type="xsd:double" use="optional" default="NaN"/> + </xsd:complexType> + <xsd:complexType name="CT_Rules"> + <xsd:sequence> + <xsd:element name="rule" type="CT_NumericRule" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_PresentationOf"> + <xsd:sequence> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_IteratorAttributes"/> + </xsd:complexType> + <xsd:simpleType name="ST_LayoutShapeType" final="restriction"> + <xsd:union memberTypes="a:ST_ShapeType ST_OutputShapeType"/> + </xsd:simpleType> + <xsd:simpleType name="ST_Index1"> + <xsd:restriction base="xsd:unsignedInt"> + <xsd:minInclusive value="1"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Adj"> + <xsd:attribute name="idx" type="ST_Index1" use="required"/> + <xsd:attribute name="val" type="xsd:double" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_AdjLst"> + <xsd:sequence> + <xsd:element name="adj" type="CT_Adj" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Shape"> + <xsd:sequence> + <xsd:element name="adjLst" type="CT_AdjLst" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="rot" type="xsd:double" use="optional" default="0"/> + <xsd:attribute name="type" type="ST_LayoutShapeType" use="optional" default="none"/> + <xsd:attribute ref="r:blip" use="optional"/> + <xsd:attribute name="zOrderOff" type="xsd:int" use="optional" default="0"/> + <xsd:attribute name="hideGeom" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="lkTxEntry" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="blipPhldr" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_Parameter"> + <xsd:attribute name="type" type="ST_ParameterId" use="required"/> + <xsd:attribute name="val" type="ST_ParameterVal" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Algorithm"> + <xsd:sequence> + <xsd:element name="param" type="CT_Parameter" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="type" type="ST_AlgorithmType" use="required"/> + <xsd:attribute name="rev" type="xsd:unsignedInt" use="optional" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_LayoutNode"> + <xsd:choice minOccurs="0" maxOccurs="unbounded"> + <xsd:element name="alg" type="CT_Algorithm" minOccurs="0" maxOccurs="1"/> + <xsd:element name="shape" type="CT_Shape" minOccurs="0" maxOccurs="1"/> + <xsd:element name="presOf" type="CT_PresentationOf" minOccurs="0" maxOccurs="1"/> + <xsd:element name="constrLst" type="CT_Constraints" minOccurs="0" maxOccurs="1"/> + <xsd:element name="ruleLst" type="CT_Rules" minOccurs="0" maxOccurs="1"/> + <xsd:element name="varLst" type="CT_LayoutVariablePropertySet" minOccurs="0" maxOccurs="1"/> + <xsd:element name="forEach" type="CT_ForEach"/> + <xsd:element name="layoutNode" type="CT_LayoutNode"/> + <xsd:element name="choose" type="CT_Choose"/> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:choice> + <xsd:attribute name="name" type="xsd:string" use="optional" default=""/> + <xsd:attribute name="styleLbl" type="xsd:string" use="optional" default=""/> + <xsd:attribute name="chOrder" type="ST_ChildOrderType" use="optional" default="b"/> + <xsd:attribute name="moveWith" type="xsd:string" use="optional" default=""/> + </xsd:complexType> + <xsd:complexType name="CT_ForEach"> + <xsd:choice minOccurs="0" maxOccurs="unbounded"> + <xsd:element name="alg" type="CT_Algorithm" minOccurs="0" maxOccurs="1"/> + <xsd:element name="shape" type="CT_Shape" minOccurs="0" maxOccurs="1"/> + <xsd:element name="presOf" type="CT_PresentationOf" minOccurs="0" maxOccurs="1"/> + <xsd:element name="constrLst" type="CT_Constraints" minOccurs="0" maxOccurs="1"/> + <xsd:element name="ruleLst" type="CT_Rules" minOccurs="0" maxOccurs="1"/> + <xsd:element name="forEach" type="CT_ForEach"/> + <xsd:element name="layoutNode" type="CT_LayoutNode"/> + <xsd:element name="choose" type="CT_Choose"/> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:choice> + <xsd:attribute name="name" type="xsd:string" use="optional" default=""/> + <xsd:attribute name="ref" type="xsd:string" use="optional" default=""/> + <xsd:attributeGroup ref="AG_IteratorAttributes"/> + </xsd:complexType> + <xsd:complexType name="CT_When"> + <xsd:choice minOccurs="0" maxOccurs="unbounded"> + <xsd:element name="alg" type="CT_Algorithm" minOccurs="0" maxOccurs="1"/> + <xsd:element name="shape" type="CT_Shape" minOccurs="0" maxOccurs="1"/> + <xsd:element name="presOf" type="CT_PresentationOf" minOccurs="0" maxOccurs="1"/> + <xsd:element name="constrLst" type="CT_Constraints" minOccurs="0" maxOccurs="1"/> + <xsd:element name="ruleLst" type="CT_Rules" minOccurs="0" maxOccurs="1"/> + <xsd:element name="forEach" type="CT_ForEach"/> + <xsd:element name="layoutNode" type="CT_LayoutNode"/> + <xsd:element name="choose" type="CT_Choose"/> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:choice> + <xsd:attribute name="name" type="xsd:string" use="optional" default=""/> + <xsd:attributeGroup ref="AG_IteratorAttributes"/> + <xsd:attribute name="func" type="ST_FunctionType" use="required"/> + <xsd:attribute name="arg" type="ST_FunctionArgument" use="optional" default="none"/> + <xsd:attribute name="op" type="ST_FunctionOperator" use="required"/> + <xsd:attribute name="val" type="ST_FunctionValue" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Otherwise"> + <xsd:choice minOccurs="0" maxOccurs="unbounded"> + <xsd:element name="alg" type="CT_Algorithm" minOccurs="0" maxOccurs="1"/> + <xsd:element name="shape" type="CT_Shape" minOccurs="0" maxOccurs="1"/> + <xsd:element name="presOf" type="CT_PresentationOf" minOccurs="0" maxOccurs="1"/> + <xsd:element name="constrLst" type="CT_Constraints" minOccurs="0" maxOccurs="1"/> + <xsd:element name="ruleLst" type="CT_Rules" minOccurs="0" maxOccurs="1"/> + <xsd:element name="forEach" type="CT_ForEach"/> + <xsd:element name="layoutNode" type="CT_LayoutNode"/> + <xsd:element name="choose" type="CT_Choose"/> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:choice> + <xsd:attribute name="name" type="xsd:string" use="optional" default=""/> + </xsd:complexType> + <xsd:complexType name="CT_Choose"> + <xsd:sequence> + <xsd:element name="if" type="CT_When" maxOccurs="unbounded"/> + <xsd:element name="else" type="CT_Otherwise" minOccurs="0"/> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="optional" default=""/> + </xsd:complexType> + <xsd:complexType name="CT_SampleData"> + <xsd:sequence> + <xsd:element name="dataModel" type="CT_DataModel" minOccurs="0"/> + </xsd:sequence> + <xsd:attribute name="useDef" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_Category"> + <xsd:attribute name="type" type="xsd:anyURI" use="required"/> + <xsd:attribute name="pri" type="xsd:unsignedInt" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Categories"> + <xsd:sequence> + <xsd:element name="cat" type="CT_Category" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Name"> + <xsd:attribute name="lang" type="xsd:string" use="optional" default=""/> + <xsd:attribute name="val" type="xsd:string" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Description"> + <xsd:attribute name="lang" type="xsd:string" use="optional" default=""/> + <xsd:attribute name="val" type="xsd:string" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_DiagramDefinition"> + <xsd:sequence> + <xsd:element name="title" type="CT_Name" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="desc" type="CT_Description" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="catLst" type="CT_Categories" minOccurs="0"/> + <xsd:element name="sampData" type="CT_SampleData" minOccurs="0"/> + <xsd:element name="styleData" type="CT_SampleData" minOccurs="0"/> + <xsd:element name="clrData" type="CT_SampleData" minOccurs="0"/> + <xsd:element name="layoutNode" type="CT_LayoutNode"/> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="uniqueId" type="xsd:string" use="optional" default=""/> + <xsd:attribute name="minVer" type="xsd:string" use="optional"/> + <xsd:attribute name="defStyle" type="xsd:string" use="optional" default=""/> + </xsd:complexType> + <xsd:element name="layoutDef" type="CT_DiagramDefinition"/> + <xsd:complexType name="CT_DiagramDefinitionHeader"> + <xsd:sequence> + <xsd:element name="title" type="CT_Name" minOccurs="1" maxOccurs="unbounded"/> + <xsd:element name="desc" type="CT_Description" minOccurs="1" maxOccurs="unbounded"/> + <xsd:element name="catLst" type="CT_Categories" minOccurs="0"/> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="uniqueId" type="xsd:string" use="required"/> + <xsd:attribute name="minVer" type="xsd:string" use="optional"/> + <xsd:attribute name="defStyle" type="xsd:string" use="optional" default=""/> + <xsd:attribute name="resId" type="xsd:int" use="optional" default="0"/> + </xsd:complexType> + <xsd:element name="layoutDefHdr" type="CT_DiagramDefinitionHeader"/> + <xsd:complexType name="CT_DiagramDefinitionHeaderLst"> + <xsd:sequence> + <xsd:element name="layoutDefHdr" type="CT_DiagramDefinitionHeader" minOccurs="0" + maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="layoutDefHdrLst" type="CT_DiagramDefinitionHeaderLst"/> + <xsd:complexType name="CT_RelIds"> + <xsd:attribute ref="r:dm" use="required"/> + <xsd:attribute ref="r:lo" use="required"/> + <xsd:attribute ref="r:qs" use="required"/> + <xsd:attribute ref="r:cs" use="required"/> + </xsd:complexType> + <xsd:element name="relIds" type="CT_RelIds"/> + <xsd:simpleType name="ST_ParameterVal"> + <xsd:union + memberTypes="ST_DiagramHorizontalAlignment ST_VerticalAlignment ST_ChildDirection ST_ChildAlignment ST_SecondaryChildAlignment ST_LinearDirection ST_SecondaryLinearDirection ST_StartingElement ST_BendPoint ST_ConnectorRouting ST_ArrowheadStyle ST_ConnectorDimension ST_RotationPath ST_CenterShapeMapping ST_NodeHorizontalAlignment ST_NodeVerticalAlignment ST_FallbackDimension ST_TextDirection ST_PyramidAccentPosition ST_PyramidAccentTextMargin ST_TextBlockDirection ST_TextAnchorHorizontal ST_TextAnchorVertical ST_DiagramTextAlignment ST_AutoTextRotation ST_GrowDirection ST_FlowDirection ST_ContinueDirection ST_Breakpoint ST_Offset ST_HierarchyAlignment xsd:int xsd:double xsd:boolean xsd:string ST_ConnectorPoint" + /> + </xsd:simpleType> + <xsd:simpleType name="ST_ModelId"> + <xsd:union memberTypes="xsd:int s:ST_Guid"/> + </xsd:simpleType> + <xsd:simpleType name="ST_PrSetCustVal"> + <xsd:union memberTypes="s:ST_Percentage xsd:int"/> + </xsd:simpleType> + <xsd:complexType name="CT_ElemPropSet"> + <xsd:sequence> + <xsd:element name="presLayoutVars" type="CT_LayoutVariablePropertySet" minOccurs="0" + maxOccurs="1"/> + <xsd:element name="style" type="a:CT_ShapeStyle" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="presAssocID" type="ST_ModelId" use="optional"/> + <xsd:attribute name="presName" type="xsd:string" use="optional"/> + <xsd:attribute name="presStyleLbl" type="xsd:string" use="optional"/> + <xsd:attribute name="presStyleIdx" type="xsd:int" use="optional"/> + <xsd:attribute name="presStyleCnt" type="xsd:int" use="optional"/> + <xsd:attribute name="loTypeId" type="xsd:string" use="optional"/> + <xsd:attribute name="loCatId" type="xsd:string" use="optional"/> + <xsd:attribute name="qsTypeId" type="xsd:string" use="optional"/> + <xsd:attribute name="qsCatId" type="xsd:string" use="optional"/> + <xsd:attribute name="csTypeId" type="xsd:string" use="optional"/> + <xsd:attribute name="csCatId" type="xsd:string" use="optional"/> + <xsd:attribute name="coherent3DOff" type="xsd:boolean" use="optional"/> + <xsd:attribute name="phldrT" type="xsd:string" use="optional"/> + <xsd:attribute name="phldr" type="xsd:boolean" use="optional"/> + <xsd:attribute name="custAng" type="xsd:int" use="optional"/> + <xsd:attribute name="custFlipVert" type="xsd:boolean" use="optional"/> + <xsd:attribute name="custFlipHor" type="xsd:boolean" use="optional"/> + <xsd:attribute name="custSzX" type="xsd:int" use="optional"/> + <xsd:attribute name="custSzY" type="xsd:int" use="optional"/> + <xsd:attribute name="custScaleX" type="ST_PrSetCustVal" use="optional"/> + <xsd:attribute name="custScaleY" type="ST_PrSetCustVal" use="optional"/> + <xsd:attribute name="custT" type="xsd:boolean" use="optional"/> + <xsd:attribute name="custLinFactX" type="ST_PrSetCustVal" use="optional"/> + <xsd:attribute name="custLinFactY" type="ST_PrSetCustVal" use="optional"/> + <xsd:attribute name="custLinFactNeighborX" type="ST_PrSetCustVal" use="optional"/> + <xsd:attribute name="custLinFactNeighborY" type="ST_PrSetCustVal" use="optional"/> + <xsd:attribute name="custRadScaleRad" type="ST_PrSetCustVal" use="optional"/> + <xsd:attribute name="custRadScaleInc" type="ST_PrSetCustVal" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_Direction" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="norm"/> + <xsd:enumeration value="rev"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_HierBranchStyle" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="l"/> + <xsd:enumeration value="r"/> + <xsd:enumeration value="hang"/> + <xsd:enumeration value="std"/> + <xsd:enumeration value="init"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_AnimOneStr" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="one"/> + <xsd:enumeration value="branch"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_AnimLvlStr" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="lvl"/> + <xsd:enumeration value="ctr"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_OrgChart"> + <xsd:attribute name="val" type="xsd:boolean" default="false" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_NodeCount"> + <xsd:restriction base="xsd:int"> + <xsd:minInclusive value="-1"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_ChildMax"> + <xsd:attribute name="val" type="ST_NodeCount" default="-1" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_ChildPref"> + <xsd:attribute name="val" type="ST_NodeCount" default="-1" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_BulletEnabled"> + <xsd:attribute name="val" type="xsd:boolean" default="false" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Direction"> + <xsd:attribute name="val" type="ST_Direction" default="norm" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_HierBranchStyle"> + <xsd:attribute name="val" type="ST_HierBranchStyle" default="std" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_AnimOne"> + <xsd:attribute name="val" type="ST_AnimOneStr" default="one" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_AnimLvl"> + <xsd:attribute name="val" type="ST_AnimLvlStr" default="none" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_ResizeHandlesStr" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="exact"/> + <xsd:enumeration value="rel"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_ResizeHandles"> + <xsd:attribute name="val" type="ST_ResizeHandlesStr" default="rel" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_LayoutVariablePropertySet"> + <xsd:sequence> + <xsd:element name="orgChart" type="CT_OrgChart" minOccurs="0" maxOccurs="1"/> + <xsd:element name="chMax" type="CT_ChildMax" minOccurs="0" maxOccurs="1"/> + <xsd:element name="chPref" type="CT_ChildPref" minOccurs="0" maxOccurs="1"/> + <xsd:element name="bulletEnabled" type="CT_BulletEnabled" minOccurs="0" maxOccurs="1"/> + <xsd:element name="dir" type="CT_Direction" minOccurs="0" maxOccurs="1"/> + <xsd:element name="hierBranch" type="CT_HierBranchStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="animOne" type="CT_AnimOne" minOccurs="0" maxOccurs="1"/> + <xsd:element name="animLvl" type="CT_AnimLvl" minOccurs="0" maxOccurs="1"/> + <xsd:element name="resizeHandles" type="CT_ResizeHandles" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SDName"> + <xsd:attribute name="lang" type="xsd:string" use="optional" default=""/> + <xsd:attribute name="val" type="xsd:string" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_SDDescription"> + <xsd:attribute name="lang" type="xsd:string" use="optional" default=""/> + <xsd:attribute name="val" type="xsd:string" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_SDCategory"> + <xsd:attribute name="type" type="xsd:anyURI" use="required"/> + <xsd:attribute name="pri" type="xsd:unsignedInt" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_SDCategories"> + <xsd:sequence minOccurs="0" maxOccurs="unbounded"> + <xsd:element name="cat" type="CT_SDCategory" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TextProps"> + <xsd:sequence> + <xsd:group ref="a:EG_Text3D" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_StyleLabel"> + <xsd:sequence> + <xsd:element name="scene3d" type="a:CT_Scene3D" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sp3d" type="a:CT_Shape3D" minOccurs="0" maxOccurs="1"/> + <xsd:element name="txPr" type="CT_TextProps" minOccurs="0" maxOccurs="1"/> + <xsd:element name="style" type="a:CT_ShapeStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_StyleDefinition"> + <xsd:sequence> + <xsd:element name="title" type="CT_SDName" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="desc" type="CT_SDDescription" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="catLst" type="CT_SDCategories" minOccurs="0"/> + <xsd:element name="scene3d" type="a:CT_Scene3D" minOccurs="0" maxOccurs="1"/> + <xsd:element name="styleLbl" type="CT_StyleLabel" minOccurs="1" maxOccurs="unbounded"/> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="uniqueId" type="xsd:string" use="optional" default=""/> + <xsd:attribute name="minVer" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:element name="styleDef" type="CT_StyleDefinition"/> + <xsd:complexType name="CT_StyleDefinitionHeader"> + <xsd:sequence> + <xsd:element name="title" type="CT_SDName" minOccurs="1" maxOccurs="unbounded"/> + <xsd:element name="desc" type="CT_SDDescription" minOccurs="1" maxOccurs="unbounded"/> + <xsd:element name="catLst" type="CT_SDCategories" minOccurs="0"/> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="uniqueId" type="xsd:string" use="required"/> + <xsd:attribute name="minVer" type="xsd:string" use="optional"/> + <xsd:attribute name="resId" type="xsd:int" use="optional" default="0"/> + </xsd:complexType> + <xsd:element name="styleDefHdr" type="CT_StyleDefinitionHeader"/> + <xsd:complexType name="CT_StyleDefinitionHeaderLst"> + <xsd:sequence> + <xsd:element name="styleDefHdr" type="CT_StyleDefinitionHeader" minOccurs="0" + maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="styleDefHdrLst" type="CT_StyleDefinitionHeaderLst"/> + <xsd:simpleType name="ST_AlgorithmType" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="composite"/> + <xsd:enumeration value="conn"/> + <xsd:enumeration value="cycle"/> + <xsd:enumeration value="hierChild"/> + <xsd:enumeration value="hierRoot"/> + <xsd:enumeration value="pyra"/> + <xsd:enumeration value="lin"/> + <xsd:enumeration value="sp"/> + <xsd:enumeration value="tx"/> + <xsd:enumeration value="snake"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_AxisType" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="self"/> + <xsd:enumeration value="ch"/> + <xsd:enumeration value="des"/> + <xsd:enumeration value="desOrSelf"/> + <xsd:enumeration value="par"/> + <xsd:enumeration value="ancst"/> + <xsd:enumeration value="ancstOrSelf"/> + <xsd:enumeration value="followSib"/> + <xsd:enumeration value="precedSib"/> + <xsd:enumeration value="follow"/> + <xsd:enumeration value="preced"/> + <xsd:enumeration value="root"/> + <xsd:enumeration value="none"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_AxisTypes"> + <xsd:list itemType="ST_AxisType"/> + </xsd:simpleType> + <xsd:simpleType name="ST_BoolOperator" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="equ"/> + <xsd:enumeration value="gte"/> + <xsd:enumeration value="lte"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ChildOrderType" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="b"/> + <xsd:enumeration value="t"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ConstraintType" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="alignOff"/> + <xsd:enumeration value="begMarg"/> + <xsd:enumeration value="bendDist"/> + <xsd:enumeration value="begPad"/> + <xsd:enumeration value="b"/> + <xsd:enumeration value="bMarg"/> + <xsd:enumeration value="bOff"/> + <xsd:enumeration value="ctrX"/> + <xsd:enumeration value="ctrXOff"/> + <xsd:enumeration value="ctrY"/> + <xsd:enumeration value="ctrYOff"/> + <xsd:enumeration value="connDist"/> + <xsd:enumeration value="diam"/> + <xsd:enumeration value="endMarg"/> + <xsd:enumeration value="endPad"/> + <xsd:enumeration value="h"/> + <xsd:enumeration value="hArH"/> + <xsd:enumeration value="hOff"/> + <xsd:enumeration value="l"/> + <xsd:enumeration value="lMarg"/> + <xsd:enumeration value="lOff"/> + <xsd:enumeration value="r"/> + <xsd:enumeration value="rMarg"/> + <xsd:enumeration value="rOff"/> + <xsd:enumeration value="primFontSz"/> + <xsd:enumeration value="pyraAcctRatio"/> + <xsd:enumeration value="secFontSz"/> + <xsd:enumeration value="sibSp"/> + <xsd:enumeration value="secSibSp"/> + <xsd:enumeration value="sp"/> + <xsd:enumeration value="stemThick"/> + <xsd:enumeration value="t"/> + <xsd:enumeration value="tMarg"/> + <xsd:enumeration value="tOff"/> + <xsd:enumeration value="userA"/> + <xsd:enumeration value="userB"/> + <xsd:enumeration value="userC"/> + <xsd:enumeration value="userD"/> + <xsd:enumeration value="userE"/> + <xsd:enumeration value="userF"/> + <xsd:enumeration value="userG"/> + <xsd:enumeration value="userH"/> + <xsd:enumeration value="userI"/> + <xsd:enumeration value="userJ"/> + <xsd:enumeration value="userK"/> + <xsd:enumeration value="userL"/> + <xsd:enumeration value="userM"/> + <xsd:enumeration value="userN"/> + <xsd:enumeration value="userO"/> + <xsd:enumeration value="userP"/> + <xsd:enumeration value="userQ"/> + <xsd:enumeration value="userR"/> + <xsd:enumeration value="userS"/> + <xsd:enumeration value="userT"/> + <xsd:enumeration value="userU"/> + <xsd:enumeration value="userV"/> + <xsd:enumeration value="userW"/> + <xsd:enumeration value="userX"/> + <xsd:enumeration value="userY"/> + <xsd:enumeration value="userZ"/> + <xsd:enumeration value="w"/> + <xsd:enumeration value="wArH"/> + <xsd:enumeration value="wOff"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ConstraintRelationship" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="self"/> + <xsd:enumeration value="ch"/> + <xsd:enumeration value="des"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ElementType" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="all"/> + <xsd:enumeration value="doc"/> + <xsd:enumeration value="node"/> + <xsd:enumeration value="norm"/> + <xsd:enumeration value="nonNorm"/> + <xsd:enumeration value="asst"/> + <xsd:enumeration value="nonAsst"/> + <xsd:enumeration value="parTrans"/> + <xsd:enumeration value="pres"/> + <xsd:enumeration value="sibTrans"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ElementTypes"> + <xsd:list itemType="ST_ElementType"/> + </xsd:simpleType> + <xsd:simpleType name="ST_ParameterId" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="horzAlign"/> + <xsd:enumeration value="vertAlign"/> + <xsd:enumeration value="chDir"/> + <xsd:enumeration value="chAlign"/> + <xsd:enumeration value="secChAlign"/> + <xsd:enumeration value="linDir"/> + <xsd:enumeration value="secLinDir"/> + <xsd:enumeration value="stElem"/> + <xsd:enumeration value="bendPt"/> + <xsd:enumeration value="connRout"/> + <xsd:enumeration value="begSty"/> + <xsd:enumeration value="endSty"/> + <xsd:enumeration value="dim"/> + <xsd:enumeration value="rotPath"/> + <xsd:enumeration value="ctrShpMap"/> + <xsd:enumeration value="nodeHorzAlign"/> + <xsd:enumeration value="nodeVertAlign"/> + <xsd:enumeration value="fallback"/> + <xsd:enumeration value="txDir"/> + <xsd:enumeration value="pyraAcctPos"/> + <xsd:enumeration value="pyraAcctTxMar"/> + <xsd:enumeration value="txBlDir"/> + <xsd:enumeration value="txAnchorHorz"/> + <xsd:enumeration value="txAnchorVert"/> + <xsd:enumeration value="txAnchorHorzCh"/> + <xsd:enumeration value="txAnchorVertCh"/> + <xsd:enumeration value="parTxLTRAlign"/> + <xsd:enumeration value="parTxRTLAlign"/> + <xsd:enumeration value="shpTxLTRAlignCh"/> + <xsd:enumeration value="shpTxRTLAlignCh"/> + <xsd:enumeration value="autoTxRot"/> + <xsd:enumeration value="grDir"/> + <xsd:enumeration value="flowDir"/> + <xsd:enumeration value="contDir"/> + <xsd:enumeration value="bkpt"/> + <xsd:enumeration value="off"/> + <xsd:enumeration value="hierAlign"/> + <xsd:enumeration value="bkPtFixedVal"/> + <xsd:enumeration value="stBulletLvl"/> + <xsd:enumeration value="stAng"/> + <xsd:enumeration value="spanAng"/> + <xsd:enumeration value="ar"/> + <xsd:enumeration value="lnSpPar"/> + <xsd:enumeration value="lnSpAfParP"/> + <xsd:enumeration value="lnSpCh"/> + <xsd:enumeration value="lnSpAfChP"/> + <xsd:enumeration value="rtShortDist"/> + <xsd:enumeration value="alignTx"/> + <xsd:enumeration value="pyraLvlNode"/> + <xsd:enumeration value="pyraAcctBkgdNode"/> + <xsd:enumeration value="pyraAcctTxNode"/> + <xsd:enumeration value="srcNode"/> + <xsd:enumeration value="dstNode"/> + <xsd:enumeration value="begPts"/> + <xsd:enumeration value="endPts"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_Ints"> + <xsd:list itemType="xsd:int"/> + </xsd:simpleType> + <xsd:simpleType name="ST_UnsignedInts"> + <xsd:list itemType="xsd:unsignedInt"/> + </xsd:simpleType> + <xsd:simpleType name="ST_Booleans"> + <xsd:list itemType="xsd:boolean"/> + </xsd:simpleType> + <xsd:simpleType name="ST_FunctionType" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="cnt"/> + <xsd:enumeration value="pos"/> + <xsd:enumeration value="revPos"/> + <xsd:enumeration value="posEven"/> + <xsd:enumeration value="posOdd"/> + <xsd:enumeration value="var"/> + <xsd:enumeration value="depth"/> + <xsd:enumeration value="maxDepth"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_FunctionOperator" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="equ"/> + <xsd:enumeration value="neq"/> + <xsd:enumeration value="gt"/> + <xsd:enumeration value="lt"/> + <xsd:enumeration value="gte"/> + <xsd:enumeration value="lte"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_DiagramHorizontalAlignment" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="l"/> + <xsd:enumeration value="ctr"/> + <xsd:enumeration value="r"/> + <xsd:enumeration value="none"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_VerticalAlignment" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="t"/> + <xsd:enumeration value="mid"/> + <xsd:enumeration value="b"/> + <xsd:enumeration value="none"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ChildDirection" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="horz"/> + <xsd:enumeration value="vert"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ChildAlignment" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="t"/> + <xsd:enumeration value="b"/> + <xsd:enumeration value="l"/> + <xsd:enumeration value="r"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_SecondaryChildAlignment" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="t"/> + <xsd:enumeration value="b"/> + <xsd:enumeration value="l"/> + <xsd:enumeration value="r"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_LinearDirection" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="fromL"/> + <xsd:enumeration value="fromR"/> + <xsd:enumeration value="fromT"/> + <xsd:enumeration value="fromB"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_SecondaryLinearDirection" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="fromL"/> + <xsd:enumeration value="fromR"/> + <xsd:enumeration value="fromT"/> + <xsd:enumeration value="fromB"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_StartingElement" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="node"/> + <xsd:enumeration value="trans"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_RotationPath" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="alongPath"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_CenterShapeMapping" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="fNode"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_BendPoint" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="beg"/> + <xsd:enumeration value="def"/> + <xsd:enumeration value="end"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ConnectorRouting" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="stra"/> + <xsd:enumeration value="bend"/> + <xsd:enumeration value="curve"/> + <xsd:enumeration value="longCurve"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ArrowheadStyle" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="auto"/> + <xsd:enumeration value="arr"/> + <xsd:enumeration value="noArr"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ConnectorDimension" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="1D"/> + <xsd:enumeration value="2D"/> + <xsd:enumeration value="cust"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ConnectorPoint" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="auto"/> + <xsd:enumeration value="bCtr"/> + <xsd:enumeration value="ctr"/> + <xsd:enumeration value="midL"/> + <xsd:enumeration value="midR"/> + <xsd:enumeration value="tCtr"/> + <xsd:enumeration value="bL"/> + <xsd:enumeration value="bR"/> + <xsd:enumeration value="tL"/> + <xsd:enumeration value="tR"/> + <xsd:enumeration value="radial"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_NodeHorizontalAlignment" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="l"/> + <xsd:enumeration value="ctr"/> + <xsd:enumeration value="r"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_NodeVerticalAlignment" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="t"/> + <xsd:enumeration value="mid"/> + <xsd:enumeration value="b"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_FallbackDimension" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="1D"/> + <xsd:enumeration value="2D"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TextDirection" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="fromT"/> + <xsd:enumeration value="fromB"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_PyramidAccentPosition" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="bef"/> + <xsd:enumeration value="aft"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_PyramidAccentTextMargin" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="step"/> + <xsd:enumeration value="stack"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TextBlockDirection" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="horz"/> + <xsd:enumeration value="vert"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TextAnchorHorizontal" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="ctr"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TextAnchorVertical" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="t"/> + <xsd:enumeration value="mid"/> + <xsd:enumeration value="b"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_DiagramTextAlignment" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="l"/> + <xsd:enumeration value="ctr"/> + <xsd:enumeration value="r"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_AutoTextRotation" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="upr"/> + <xsd:enumeration value="grav"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_GrowDirection" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="tL"/> + <xsd:enumeration value="tR"/> + <xsd:enumeration value="bL"/> + <xsd:enumeration value="bR"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_FlowDirection" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="row"/> + <xsd:enumeration value="col"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ContinueDirection" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="revDir"/> + <xsd:enumeration value="sameDir"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_Breakpoint" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="endCnv"/> + <xsd:enumeration value="bal"/> + <xsd:enumeration value="fixed"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_Offset" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="ctr"/> + <xsd:enumeration value="off"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_HierarchyAlignment" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="tL"/> + <xsd:enumeration value="tR"/> + <xsd:enumeration value="tCtrCh"/> + <xsd:enumeration value="tCtrDes"/> + <xsd:enumeration value="bL"/> + <xsd:enumeration value="bR"/> + <xsd:enumeration value="bCtrCh"/> + <xsd:enumeration value="bCtrDes"/> + <xsd:enumeration value="lT"/> + <xsd:enumeration value="lB"/> + <xsd:enumeration value="lCtrCh"/> + <xsd:enumeration value="lCtrDes"/> + <xsd:enumeration value="rT"/> + <xsd:enumeration value="rB"/> + <xsd:enumeration value="rCtrCh"/> + <xsd:enumeration value="rCtrDes"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_FunctionValue" final="restriction"> + <xsd:union + memberTypes="xsd:int xsd:boolean ST_Direction ST_HierBranchStyle ST_AnimOneStr ST_AnimLvlStr ST_ResizeHandlesStr" + /> + </xsd:simpleType> + <xsd:simpleType name="ST_VariableType" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="orgChart"/> + <xsd:enumeration value="chMax"/> + <xsd:enumeration value="chPref"/> + <xsd:enumeration value="bulEnabled"/> + <xsd:enumeration value="dir"/> + <xsd:enumeration value="hierBranch"/> + <xsd:enumeration value="animOne"/> + <xsd:enumeration value="animLvl"/> + <xsd:enumeration value="resizeHandles"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_FunctionArgument" final="restriction"> + <xsd:union memberTypes="ST_VariableType"/> + </xsd:simpleType> + <xsd:simpleType name="ST_OutputShapeType" final="restriction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="conn"/> + </xsd:restriction> + </xsd:simpleType> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/dml-lockedCanvas.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/dml-lockedCanvas.xsd new file mode 100644 index 00000000..687eea82 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/dml-lockedCanvas.xsd @@ -0,0 +1,11 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" + xmlns="http://schemas.openxmlformats.org/drawingml/2006/lockedCanvas" + xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" + xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" + elementFormDefault="qualified" + targetNamespace="http://schemas.openxmlformats.org/drawingml/2006/lockedCanvas"> + <xsd:import namespace="http://schemas.openxmlformats.org/drawingml/2006/main" + schemaLocation="dml-main.xsd"/> + <xsd:element name="lockedCanvas" type="a:CT_GvmlGroupShape"/> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/dml-main.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/dml-main.xsd new file mode 100644 index 00000000..6ac81b06 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/dml-main.xsd @@ -0,0 +1,3081 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" + xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" + xmlns:s="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + xmlns="http://schemas.openxmlformats.org/drawingml/2006/main" + targetNamespace="http://schemas.openxmlformats.org/drawingml/2006/main" + elementFormDefault="qualified"> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/relationships" + schemaLocation="shared-relationshipReference.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + schemaLocation="shared-commonSimpleTypes.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/drawingml/2006/diagram" + schemaLocation="dml-diagram.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/drawingml/2006/chart" + schemaLocation="dml-chart.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/drawingml/2006/picture" + schemaLocation="dml-picture.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/drawingml/2006/lockedCanvas" + schemaLocation="dml-lockedCanvas.xsd"/> + <xsd:complexType name="CT_AudioFile"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute ref="r:link" use="required"/> + <xsd:attribute name="contentType" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_VideoFile"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute ref="r:link" use="required"/> + <xsd:attribute name="contentType" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_QuickTimeFile"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute ref="r:link" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_AudioCDTime"> + <xsd:attribute name="track" type="xsd:unsignedByte" use="required"/> + <xsd:attribute name="time" type="xsd:unsignedInt" use="optional" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_AudioCD"> + <xsd:sequence> + <xsd:element name="st" type="CT_AudioCDTime" minOccurs="1" maxOccurs="1"/> + <xsd:element name="end" type="CT_AudioCDTime" minOccurs="1" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:group name="EG_Media"> + <xsd:choice> + <xsd:element name="audioCd" type="CT_AudioCD"/> + <xsd:element name="wavAudioFile" type="CT_EmbeddedWAVAudioFile"/> + <xsd:element name="audioFile" type="CT_AudioFile"/> + <xsd:element name="videoFile" type="CT_VideoFile"/> + <xsd:element name="quickTimeFile" type="CT_QuickTimeFile"/> + </xsd:choice> + </xsd:group> + <xsd:element name="videoFile" type="CT_VideoFile"/> + <xsd:simpleType name="ST_StyleMatrixColumnIndex"> + <xsd:restriction base="xsd:unsignedInt"/> + </xsd:simpleType> + <xsd:simpleType name="ST_FontCollectionIndex"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="major"/> + <xsd:enumeration value="minor"/> + <xsd:enumeration value="none"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ColorSchemeIndex"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="dk1"/> + <xsd:enumeration value="lt1"/> + <xsd:enumeration value="dk2"/> + <xsd:enumeration value="lt2"/> + <xsd:enumeration value="accent1"/> + <xsd:enumeration value="accent2"/> + <xsd:enumeration value="accent3"/> + <xsd:enumeration value="accent4"/> + <xsd:enumeration value="accent5"/> + <xsd:enumeration value="accent6"/> + <xsd:enumeration value="hlink"/> + <xsd:enumeration value="folHlink"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_ColorScheme"> + <xsd:sequence> + <xsd:element name="dk1" type="CT_Color" minOccurs="1" maxOccurs="1"/> + <xsd:element name="lt1" type="CT_Color" minOccurs="1" maxOccurs="1"/> + <xsd:element name="dk2" type="CT_Color" minOccurs="1" maxOccurs="1"/> + <xsd:element name="lt2" type="CT_Color" minOccurs="1" maxOccurs="1"/> + <xsd:element name="accent1" type="CT_Color" minOccurs="1" maxOccurs="1"/> + <xsd:element name="accent2" type="CT_Color" minOccurs="1" maxOccurs="1"/> + <xsd:element name="accent3" type="CT_Color" minOccurs="1" maxOccurs="1"/> + <xsd:element name="accent4" type="CT_Color" minOccurs="1" maxOccurs="1"/> + <xsd:element name="accent5" type="CT_Color" minOccurs="1" maxOccurs="1"/> + <xsd:element name="accent6" type="CT_Color" minOccurs="1" maxOccurs="1"/> + <xsd:element name="hlink" type="CT_Color" minOccurs="1" maxOccurs="1"/> + <xsd:element name="folHlink" type="CT_Color" minOccurs="1" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_CustomColor"> + <xsd:sequence> + <xsd:group ref="EG_ColorChoice" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="optional" default=""/> + </xsd:complexType> + <xsd:complexType name="CT_SupplementalFont"> + <xsd:attribute name="script" type="xsd:string" use="required"/> + <xsd:attribute name="typeface" type="ST_TextTypeface" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_CustomColorList"> + <xsd:sequence> + <xsd:element name="custClr" type="CT_CustomColor" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_FontCollection"> + <xsd:sequence> + <xsd:element name="latin" type="CT_TextFont" minOccurs="1" maxOccurs="1"/> + <xsd:element name="ea" type="CT_TextFont" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cs" type="CT_TextFont" minOccurs="1" maxOccurs="1"/> + <xsd:element name="font" type="CT_SupplementalFont" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_EffectStyleItem"> + <xsd:sequence> + <xsd:group ref="EG_EffectProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="scene3d" type="CT_Scene3D" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sp3d" type="CT_Shape3D" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_FontScheme"> + <xsd:sequence> + <xsd:element name="majorFont" type="CT_FontCollection" minOccurs="1" maxOccurs="1"/> + <xsd:element name="minorFont" type="CT_FontCollection" minOccurs="1" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_FillStyleList"> + <xsd:sequence> + <xsd:group ref="EG_FillProperties" minOccurs="3" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_LineStyleList"> + <xsd:sequence> + <xsd:element name="ln" type="CT_LineProperties" minOccurs="3" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_EffectStyleList"> + <xsd:sequence> + <xsd:element name="effectStyle" type="CT_EffectStyleItem" minOccurs="3" maxOccurs="unbounded" + /> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_BackgroundFillStyleList"> + <xsd:sequence> + <xsd:group ref="EG_FillProperties" minOccurs="3" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_StyleMatrix"> + <xsd:sequence> + <xsd:element name="fillStyleLst" type="CT_FillStyleList" minOccurs="1" maxOccurs="1"/> + <xsd:element name="lnStyleLst" type="CT_LineStyleList" minOccurs="1" maxOccurs="1"/> + <xsd:element name="effectStyleLst" type="CT_EffectStyleList" minOccurs="1" maxOccurs="1"/> + <xsd:element name="bgFillStyleLst" type="CT_BackgroundFillStyleList" minOccurs="1" + maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="optional" default=""/> + </xsd:complexType> + <xsd:complexType name="CT_BaseStyles"> + <xsd:sequence> + <xsd:element name="clrScheme" type="CT_ColorScheme" minOccurs="1" maxOccurs="1"/> + <xsd:element name="fontScheme" type="CT_FontScheme" minOccurs="1" maxOccurs="1"/> + <xsd:element name="fmtScheme" type="CT_StyleMatrix" minOccurs="1" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_OfficeArtExtension"> + <xsd:sequence> + <xsd:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="uri" type="xsd:token" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_Coordinate"> + <xsd:union memberTypes="ST_CoordinateUnqualified s:ST_UniversalMeasure"/> + </xsd:simpleType> + <xsd:simpleType name="ST_CoordinateUnqualified"> + <xsd:restriction base="xsd:long"> + <xsd:minInclusive value="-27273042329600"/> + <xsd:maxInclusive value="27273042316900"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_Coordinate32"> + <xsd:union memberTypes="ST_Coordinate32Unqualified s:ST_UniversalMeasure"/> + </xsd:simpleType> + <xsd:simpleType name="ST_Coordinate32Unqualified"> + <xsd:restriction base="xsd:int"/> + </xsd:simpleType> + <xsd:simpleType name="ST_PositiveCoordinate"> + <xsd:restriction base="xsd:long"> + <xsd:minInclusive value="0"/> + <xsd:maxInclusive value="27273042316900"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_PositiveCoordinate32"> + <xsd:restriction base="ST_Coordinate32Unqualified"> + <xsd:minInclusive value="0"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_Angle"> + <xsd:restriction base="xsd:int"/> + </xsd:simpleType> + <xsd:complexType name="CT_Angle"> + <xsd:attribute name="val" type="ST_Angle" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_FixedAngle"> + <xsd:restriction base="ST_Angle"> + <xsd:minExclusive value="-5400000"/> + <xsd:maxExclusive value="5400000"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_PositiveFixedAngle"> + <xsd:restriction base="ST_Angle"> + <xsd:minInclusive value="0"/> + <xsd:maxExclusive value="21600000"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_PositiveFixedAngle"> + <xsd:attribute name="val" type="ST_PositiveFixedAngle" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_Percentage"> + <xsd:union memberTypes="ST_PercentageDecimal s:ST_Percentage"/> + </xsd:simpleType> + <xsd:simpleType name="ST_PercentageDecimal"> + <xsd:restriction base="xsd:int"/> + </xsd:simpleType> + <xsd:complexType name="CT_Percentage"> + <xsd:attribute name="val" type="ST_Percentage" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_PositivePercentage"> + <xsd:union memberTypes="ST_PositivePercentageDecimal s:ST_PositivePercentage"/> + </xsd:simpleType> + <xsd:simpleType name="ST_PositivePercentageDecimal"> + <xsd:restriction base="ST_PercentageDecimal"> + <xsd:minInclusive value="0"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_PositivePercentage"> + <xsd:attribute name="val" type="ST_PositivePercentage" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_FixedPercentage"> + <xsd:union memberTypes="ST_FixedPercentageDecimal s:ST_FixedPercentage"/> + </xsd:simpleType> + <xsd:simpleType name="ST_FixedPercentageDecimal"> + <xsd:restriction base="ST_PercentageDecimal"> + <xsd:minInclusive value="-100000"/> + <xsd:maxInclusive value="100000"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_FixedPercentage"> + <xsd:attribute name="val" type="ST_FixedPercentage" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_PositiveFixedPercentage"> + <xsd:union memberTypes="ST_PositiveFixedPercentageDecimal s:ST_PositiveFixedPercentage"/> + </xsd:simpleType> + <xsd:simpleType name="ST_PositiveFixedPercentageDecimal"> + <xsd:restriction base="ST_PercentageDecimal"> + <xsd:minInclusive value="0"/> + <xsd:maxInclusive value="100000"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_PositiveFixedPercentage"> + <xsd:attribute name="val" type="ST_PositiveFixedPercentage" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Ratio"> + <xsd:attribute name="n" type="xsd:long" use="required"/> + <xsd:attribute name="d" type="xsd:long" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Point2D"> + <xsd:attribute name="x" type="ST_Coordinate" use="required"/> + <xsd:attribute name="y" type="ST_Coordinate" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_PositiveSize2D"> + <xsd:attribute name="cx" type="ST_PositiveCoordinate" use="required"/> + <xsd:attribute name="cy" type="ST_PositiveCoordinate" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_ComplementTransform"/> + <xsd:complexType name="CT_InverseTransform"/> + <xsd:complexType name="CT_GrayscaleTransform"/> + <xsd:complexType name="CT_GammaTransform"/> + <xsd:complexType name="CT_InverseGammaTransform"/> + <xsd:group name="EG_ColorTransform"> + <xsd:choice> + <xsd:element name="tint" type="CT_PositiveFixedPercentage" minOccurs="1" maxOccurs="1"/> + <xsd:element name="shade" type="CT_PositiveFixedPercentage" minOccurs="1" maxOccurs="1"/> + <xsd:element name="comp" type="CT_ComplementTransform" minOccurs="1" maxOccurs="1"/> + <xsd:element name="inv" type="CT_InverseTransform" minOccurs="1" maxOccurs="1"/> + <xsd:element name="gray" type="CT_GrayscaleTransform" minOccurs="1" maxOccurs="1"/> + <xsd:element name="alpha" type="CT_PositiveFixedPercentage" minOccurs="1" maxOccurs="1"/> + <xsd:element name="alphaOff" type="CT_FixedPercentage" minOccurs="1" maxOccurs="1"/> + <xsd:element name="alphaMod" type="CT_PositivePercentage" minOccurs="1" maxOccurs="1"/> + <xsd:element name="hue" type="CT_PositiveFixedAngle" minOccurs="1" maxOccurs="1"/> + <xsd:element name="hueOff" type="CT_Angle" minOccurs="1" maxOccurs="1"/> + <xsd:element name="hueMod" type="CT_PositivePercentage" minOccurs="1" maxOccurs="1"/> + <xsd:element name="sat" type="CT_Percentage" minOccurs="1" maxOccurs="1"/> + <xsd:element name="satOff" type="CT_Percentage" minOccurs="1" maxOccurs="1"/> + <xsd:element name="satMod" type="CT_Percentage" minOccurs="1" maxOccurs="1"/> + <xsd:element name="lum" type="CT_Percentage" minOccurs="1" maxOccurs="1"/> + <xsd:element name="lumOff" type="CT_Percentage" minOccurs="1" maxOccurs="1"/> + <xsd:element name="lumMod" type="CT_Percentage" minOccurs="1" maxOccurs="1"/> + <xsd:element name="red" type="CT_Percentage" minOccurs="1" maxOccurs="1"/> + <xsd:element name="redOff" type="CT_Percentage" minOccurs="1" maxOccurs="1"/> + <xsd:element name="redMod" type="CT_Percentage" minOccurs="1" maxOccurs="1"/> + <xsd:element name="green" type="CT_Percentage" minOccurs="1" maxOccurs="1"/> + <xsd:element name="greenOff" type="CT_Percentage" minOccurs="1" maxOccurs="1"/> + <xsd:element name="greenMod" type="CT_Percentage" minOccurs="1" maxOccurs="1"/> + <xsd:element name="blue" type="CT_Percentage" minOccurs="1" maxOccurs="1"/> + <xsd:element name="blueOff" type="CT_Percentage" minOccurs="1" maxOccurs="1"/> + <xsd:element name="blueMod" type="CT_Percentage" minOccurs="1" maxOccurs="1"/> + <xsd:element name="gamma" type="CT_GammaTransform" minOccurs="1" maxOccurs="1"/> + <xsd:element name="invGamma" type="CT_InverseGammaTransform" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_ScRgbColor"> + <xsd:sequence> + <xsd:group ref="EG_ColorTransform" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="r" type="ST_Percentage" use="required"/> + <xsd:attribute name="g" type="ST_Percentage" use="required"/> + <xsd:attribute name="b" type="ST_Percentage" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_SRgbColor"> + <xsd:sequence> + <xsd:group ref="EG_ColorTransform" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="val" type="s:ST_HexColorRGB" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_HslColor"> + <xsd:sequence> + <xsd:group ref="EG_ColorTransform" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="hue" type="ST_PositiveFixedAngle" use="required"/> + <xsd:attribute name="sat" type="ST_Percentage" use="required"/> + <xsd:attribute name="lum" type="ST_Percentage" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_SystemColorVal"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="scrollBar"/> + <xsd:enumeration value="background"/> + <xsd:enumeration value="activeCaption"/> + <xsd:enumeration value="inactiveCaption"/> + <xsd:enumeration value="menu"/> + <xsd:enumeration value="window"/> + <xsd:enumeration value="windowFrame"/> + <xsd:enumeration value="menuText"/> + <xsd:enumeration value="windowText"/> + <xsd:enumeration value="captionText"/> + <xsd:enumeration value="activeBorder"/> + <xsd:enumeration value="inactiveBorder"/> + <xsd:enumeration value="appWorkspace"/> + <xsd:enumeration value="highlight"/> + <xsd:enumeration value="highlightText"/> + <xsd:enumeration value="btnFace"/> + <xsd:enumeration value="btnShadow"/> + <xsd:enumeration value="grayText"/> + <xsd:enumeration value="btnText"/> + <xsd:enumeration value="inactiveCaptionText"/> + <xsd:enumeration value="btnHighlight"/> + <xsd:enumeration value="3dDkShadow"/> + <xsd:enumeration value="3dLight"/> + <xsd:enumeration value="infoText"/> + <xsd:enumeration value="infoBk"/> + <xsd:enumeration value="hotLight"/> + <xsd:enumeration value="gradientActiveCaption"/> + <xsd:enumeration value="gradientInactiveCaption"/> + <xsd:enumeration value="menuHighlight"/> + <xsd:enumeration value="menuBar"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_SystemColor"> + <xsd:sequence> + <xsd:group ref="EG_ColorTransform" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="val" type="ST_SystemColorVal" use="required"/> + <xsd:attribute name="lastClr" type="s:ST_HexColorRGB" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_SchemeColorVal"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="bg1"/> + <xsd:enumeration value="tx1"/> + <xsd:enumeration value="bg2"/> + <xsd:enumeration value="tx2"/> + <xsd:enumeration value="accent1"/> + <xsd:enumeration value="accent2"/> + <xsd:enumeration value="accent3"/> + <xsd:enumeration value="accent4"/> + <xsd:enumeration value="accent5"/> + <xsd:enumeration value="accent6"/> + <xsd:enumeration value="hlink"/> + <xsd:enumeration value="folHlink"/> + <xsd:enumeration value="phClr"/> + <xsd:enumeration value="dk1"/> + <xsd:enumeration value="lt1"/> + <xsd:enumeration value="dk2"/> + <xsd:enumeration value="lt2"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_SchemeColor"> + <xsd:sequence> + <xsd:group ref="EG_ColorTransform" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="val" type="ST_SchemeColorVal" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_PresetColorVal"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="aliceBlue"/> + <xsd:enumeration value="antiqueWhite"/> + <xsd:enumeration value="aqua"/> + <xsd:enumeration value="aquamarine"/> + <xsd:enumeration value="azure"/> + <xsd:enumeration value="beige"/> + <xsd:enumeration value="bisque"/> + <xsd:enumeration value="black"/> + <xsd:enumeration value="blanchedAlmond"/> + <xsd:enumeration value="blue"/> + <xsd:enumeration value="blueViolet"/> + <xsd:enumeration value="brown"/> + <xsd:enumeration value="burlyWood"/> + <xsd:enumeration value="cadetBlue"/> + <xsd:enumeration value="chartreuse"/> + <xsd:enumeration value="chocolate"/> + <xsd:enumeration value="coral"/> + <xsd:enumeration value="cornflowerBlue"/> + <xsd:enumeration value="cornsilk"/> + <xsd:enumeration value="crimson"/> + <xsd:enumeration value="cyan"/> + <xsd:enumeration value="darkBlue"/> + <xsd:enumeration value="darkCyan"/> + <xsd:enumeration value="darkGoldenrod"/> + <xsd:enumeration value="darkGray"/> + <xsd:enumeration value="darkGrey"/> + <xsd:enumeration value="darkGreen"/> + <xsd:enumeration value="darkKhaki"/> + <xsd:enumeration value="darkMagenta"/> + <xsd:enumeration value="darkOliveGreen"/> + <xsd:enumeration value="darkOrange"/> + <xsd:enumeration value="darkOrchid"/> + <xsd:enumeration value="darkRed"/> + <xsd:enumeration value="darkSalmon"/> + <xsd:enumeration value="darkSeaGreen"/> + <xsd:enumeration value="darkSlateBlue"/> + <xsd:enumeration value="darkSlateGray"/> + <xsd:enumeration value="darkSlateGrey"/> + <xsd:enumeration value="darkTurquoise"/> + <xsd:enumeration value="darkViolet"/> + <xsd:enumeration value="dkBlue"/> + <xsd:enumeration value="dkCyan"/> + <xsd:enumeration value="dkGoldenrod"/> + <xsd:enumeration value="dkGray"/> + <xsd:enumeration value="dkGrey"/> + <xsd:enumeration value="dkGreen"/> + <xsd:enumeration value="dkKhaki"/> + <xsd:enumeration value="dkMagenta"/> + <xsd:enumeration value="dkOliveGreen"/> + <xsd:enumeration value="dkOrange"/> + <xsd:enumeration value="dkOrchid"/> + <xsd:enumeration value="dkRed"/> + <xsd:enumeration value="dkSalmon"/> + <xsd:enumeration value="dkSeaGreen"/> + <xsd:enumeration value="dkSlateBlue"/> + <xsd:enumeration value="dkSlateGray"/> + <xsd:enumeration value="dkSlateGrey"/> + <xsd:enumeration value="dkTurquoise"/> + <xsd:enumeration value="dkViolet"/> + <xsd:enumeration value="deepPink"/> + <xsd:enumeration value="deepSkyBlue"/> + <xsd:enumeration value="dimGray"/> + <xsd:enumeration value="dimGrey"/> + <xsd:enumeration value="dodgerBlue"/> + <xsd:enumeration value="firebrick"/> + <xsd:enumeration value="floralWhite"/> + <xsd:enumeration value="forestGreen"/> + <xsd:enumeration value="fuchsia"/> + <xsd:enumeration value="gainsboro"/> + <xsd:enumeration value="ghostWhite"/> + <xsd:enumeration value="gold"/> + <xsd:enumeration value="goldenrod"/> + <xsd:enumeration value="gray"/> + <xsd:enumeration value="grey"/> + <xsd:enumeration value="green"/> + <xsd:enumeration value="greenYellow"/> + <xsd:enumeration value="honeydew"/> + <xsd:enumeration value="hotPink"/> + <xsd:enumeration value="indianRed"/> + <xsd:enumeration value="indigo"/> + <xsd:enumeration value="ivory"/> + <xsd:enumeration value="khaki"/> + <xsd:enumeration value="lavender"/> + <xsd:enumeration value="lavenderBlush"/> + <xsd:enumeration value="lawnGreen"/> + <xsd:enumeration value="lemonChiffon"/> + <xsd:enumeration value="lightBlue"/> + <xsd:enumeration value="lightCoral"/> + <xsd:enumeration value="lightCyan"/> + <xsd:enumeration value="lightGoldenrodYellow"/> + <xsd:enumeration value="lightGray"/> + <xsd:enumeration value="lightGrey"/> + <xsd:enumeration value="lightGreen"/> + <xsd:enumeration value="lightPink"/> + <xsd:enumeration value="lightSalmon"/> + <xsd:enumeration value="lightSeaGreen"/> + <xsd:enumeration value="lightSkyBlue"/> + <xsd:enumeration value="lightSlateGray"/> + <xsd:enumeration value="lightSlateGrey"/> + <xsd:enumeration value="lightSteelBlue"/> + <xsd:enumeration value="lightYellow"/> + <xsd:enumeration value="ltBlue"/> + <xsd:enumeration value="ltCoral"/> + <xsd:enumeration value="ltCyan"/> + <xsd:enumeration value="ltGoldenrodYellow"/> + <xsd:enumeration value="ltGray"/> + <xsd:enumeration value="ltGrey"/> + <xsd:enumeration value="ltGreen"/> + <xsd:enumeration value="ltPink"/> + <xsd:enumeration value="ltSalmon"/> + <xsd:enumeration value="ltSeaGreen"/> + <xsd:enumeration value="ltSkyBlue"/> + <xsd:enumeration value="ltSlateGray"/> + <xsd:enumeration value="ltSlateGrey"/> + <xsd:enumeration value="ltSteelBlue"/> + <xsd:enumeration value="ltYellow"/> + <xsd:enumeration value="lime"/> + <xsd:enumeration value="limeGreen"/> + <xsd:enumeration value="linen"/> + <xsd:enumeration value="magenta"/> + <xsd:enumeration value="maroon"/> + <xsd:enumeration value="medAquamarine"/> + <xsd:enumeration value="medBlue"/> + <xsd:enumeration value="medOrchid"/> + <xsd:enumeration value="medPurple"/> + <xsd:enumeration value="medSeaGreen"/> + <xsd:enumeration value="medSlateBlue"/> + <xsd:enumeration value="medSpringGreen"/> + <xsd:enumeration value="medTurquoise"/> + <xsd:enumeration value="medVioletRed"/> + <xsd:enumeration value="mediumAquamarine"/> + <xsd:enumeration value="mediumBlue"/> + <xsd:enumeration value="mediumOrchid"/> + <xsd:enumeration value="mediumPurple"/> + <xsd:enumeration value="mediumSeaGreen"/> + <xsd:enumeration value="mediumSlateBlue"/> + <xsd:enumeration value="mediumSpringGreen"/> + <xsd:enumeration value="mediumTurquoise"/> + <xsd:enumeration value="mediumVioletRed"/> + <xsd:enumeration value="midnightBlue"/> + <xsd:enumeration value="mintCream"/> + <xsd:enumeration value="mistyRose"/> + <xsd:enumeration value="moccasin"/> + <xsd:enumeration value="navajoWhite"/> + <xsd:enumeration value="navy"/> + <xsd:enumeration value="oldLace"/> + <xsd:enumeration value="olive"/> + <xsd:enumeration value="oliveDrab"/> + <xsd:enumeration value="orange"/> + <xsd:enumeration value="orangeRed"/> + <xsd:enumeration value="orchid"/> + <xsd:enumeration value="paleGoldenrod"/> + <xsd:enumeration value="paleGreen"/> + <xsd:enumeration value="paleTurquoise"/> + <xsd:enumeration value="paleVioletRed"/> + <xsd:enumeration value="papayaWhip"/> + <xsd:enumeration value="peachPuff"/> + <xsd:enumeration value="peru"/> + <xsd:enumeration value="pink"/> + <xsd:enumeration value="plum"/> + <xsd:enumeration value="powderBlue"/> + <xsd:enumeration value="purple"/> + <xsd:enumeration value="red"/> + <xsd:enumeration value="rosyBrown"/> + <xsd:enumeration value="royalBlue"/> + <xsd:enumeration value="saddleBrown"/> + <xsd:enumeration value="salmon"/> + <xsd:enumeration value="sandyBrown"/> + <xsd:enumeration value="seaGreen"/> + <xsd:enumeration value="seaShell"/> + <xsd:enumeration value="sienna"/> + <xsd:enumeration value="silver"/> + <xsd:enumeration value="skyBlue"/> + <xsd:enumeration value="slateBlue"/> + <xsd:enumeration value="slateGray"/> + <xsd:enumeration value="slateGrey"/> + <xsd:enumeration value="snow"/> + <xsd:enumeration value="springGreen"/> + <xsd:enumeration value="steelBlue"/> + <xsd:enumeration value="tan"/> + <xsd:enumeration value="teal"/> + <xsd:enumeration value="thistle"/> + <xsd:enumeration value="tomato"/> + <xsd:enumeration value="turquoise"/> + <xsd:enumeration value="violet"/> + <xsd:enumeration value="wheat"/> + <xsd:enumeration value="white"/> + <xsd:enumeration value="whiteSmoke"/> + <xsd:enumeration value="yellow"/> + <xsd:enumeration value="yellowGreen"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_PresetColor"> + <xsd:sequence> + <xsd:group ref="EG_ColorTransform" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="val" type="ST_PresetColorVal" use="required"/> + </xsd:complexType> + <xsd:group name="EG_OfficeArtExtensionList"> + <xsd:sequence> + <xsd:element name="ext" type="CT_OfficeArtExtension" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:group> + <xsd:complexType name="CT_OfficeArtExtensionList"> + <xsd:sequence> + <xsd:group ref="EG_OfficeArtExtensionList" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Scale2D"> + <xsd:sequence> + <xsd:element name="sx" type="CT_Ratio" minOccurs="1" maxOccurs="1"/> + <xsd:element name="sy" type="CT_Ratio" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Transform2D"> + <xsd:sequence> + <xsd:element name="off" type="CT_Point2D" minOccurs="0" maxOccurs="1"/> + <xsd:element name="ext" type="CT_PositiveSize2D" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="rot" type="ST_Angle" use="optional" default="0"/> + <xsd:attribute name="flipH" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="flipV" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_GroupTransform2D"> + <xsd:sequence> + <xsd:element name="off" type="CT_Point2D" minOccurs="0" maxOccurs="1"/> + <xsd:element name="ext" type="CT_PositiveSize2D" minOccurs="0" maxOccurs="1"/> + <xsd:element name="chOff" type="CT_Point2D" minOccurs="0" maxOccurs="1"/> + <xsd:element name="chExt" type="CT_PositiveSize2D" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="rot" type="ST_Angle" use="optional" default="0"/> + <xsd:attribute name="flipH" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="flipV" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_Point3D"> + <xsd:attribute name="x" type="ST_Coordinate" use="required"/> + <xsd:attribute name="y" type="ST_Coordinate" use="required"/> + <xsd:attribute name="z" type="ST_Coordinate" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Vector3D"> + <xsd:attribute name="dx" type="ST_Coordinate" use="required"/> + <xsd:attribute name="dy" type="ST_Coordinate" use="required"/> + <xsd:attribute name="dz" type="ST_Coordinate" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_SphereCoords"> + <xsd:attribute name="lat" type="ST_PositiveFixedAngle" use="required"/> + <xsd:attribute name="lon" type="ST_PositiveFixedAngle" use="required"/> + <xsd:attribute name="rev" type="ST_PositiveFixedAngle" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_RelativeRect"> + <xsd:attribute name="l" type="ST_Percentage" use="optional" default="0%"/> + <xsd:attribute name="t" type="ST_Percentage" use="optional" default="0%"/> + <xsd:attribute name="r" type="ST_Percentage" use="optional" default="0%"/> + <xsd:attribute name="b" type="ST_Percentage" use="optional" default="0%"/> + </xsd:complexType> + <xsd:simpleType name="ST_RectAlignment"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="tl"/> + <xsd:enumeration value="t"/> + <xsd:enumeration value="tr"/> + <xsd:enumeration value="l"/> + <xsd:enumeration value="ctr"/> + <xsd:enumeration value="r"/> + <xsd:enumeration value="bl"/> + <xsd:enumeration value="b"/> + <xsd:enumeration value="br"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:group name="EG_ColorChoice"> + <xsd:choice> + <xsd:element name="scrgbClr" type="CT_ScRgbColor" minOccurs="1" maxOccurs="1"/> + <xsd:element name="srgbClr" type="CT_SRgbColor" minOccurs="1" maxOccurs="1"/> + <xsd:element name="hslClr" type="CT_HslColor" minOccurs="1" maxOccurs="1"/> + <xsd:element name="sysClr" type="CT_SystemColor" minOccurs="1" maxOccurs="1"/> + <xsd:element name="schemeClr" type="CT_SchemeColor" minOccurs="1" maxOccurs="1"/> + <xsd:element name="prstClr" type="CT_PresetColor" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_Color"> + <xsd:sequence> + <xsd:group ref="EG_ColorChoice"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_ColorMRU"> + <xsd:sequence> + <xsd:group ref="EG_ColorChoice" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_BlackWhiteMode"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="clr"/> + <xsd:enumeration value="auto"/> + <xsd:enumeration value="gray"/> + <xsd:enumeration value="ltGray"/> + <xsd:enumeration value="invGray"/> + <xsd:enumeration value="grayWhite"/> + <xsd:enumeration value="blackGray"/> + <xsd:enumeration value="blackWhite"/> + <xsd:enumeration value="black"/> + <xsd:enumeration value="white"/> + <xsd:enumeration value="hidden"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:attributeGroup name="AG_Blob"> + <xsd:attribute ref="r:embed" use="optional" default=""/> + <xsd:attribute ref="r:link" use="optional" default=""/> + </xsd:attributeGroup> + <xsd:complexType name="CT_EmbeddedWAVAudioFile"> + <xsd:attribute ref="r:embed" use="required"/> + <xsd:attribute name="name" type="xsd:string" use="optional" default=""/> + </xsd:complexType> + <xsd:complexType name="CT_Hyperlink"> + <xsd:sequence> + <xsd:element name="snd" type="CT_EmbeddedWAVAudioFile" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute ref="r:id" use="optional"/> + <xsd:attribute name="invalidUrl" type="xsd:string" use="optional" default=""/> + <xsd:attribute name="action" type="xsd:string" use="optional" default=""/> + <xsd:attribute name="tgtFrame" type="xsd:string" use="optional" default=""/> + <xsd:attribute name="tooltip" type="xsd:string" use="optional" default=""/> + <xsd:attribute name="history" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="highlightClick" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="endSnd" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:simpleType name="ST_DrawingElementId"> + <xsd:restriction base="xsd:unsignedInt"/> + </xsd:simpleType> + <xsd:attributeGroup name="AG_Locking"> + <xsd:attribute name="noGrp" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="noSelect" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="noRot" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="noChangeAspect" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="noMove" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="noResize" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="noEditPoints" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="noAdjustHandles" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="noChangeArrowheads" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="noChangeShapeType" type="xsd:boolean" use="optional" default="false"/> + </xsd:attributeGroup> + <xsd:complexType name="CT_ConnectorLocking"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_Locking"/> + </xsd:complexType> + <xsd:complexType name="CT_ShapeLocking"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_Locking"/> + <xsd:attribute name="noTextEdit" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_PictureLocking"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_Locking"/> + <xsd:attribute name="noCrop" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_GroupLocking"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="noGrp" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="noUngrp" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="noSelect" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="noRot" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="noChangeAspect" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="noMove" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="noResize" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_GraphicalObjectFrameLocking"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="noGrp" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="noDrilldown" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="noSelect" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="noChangeAspect" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="noMove" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="noResize" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_ContentPartLocking"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_Locking"/> + </xsd:complexType> + <xsd:complexType name="CT_NonVisualDrawingProps"> + <xsd:sequence> + <xsd:element name="hlinkClick" type="CT_Hyperlink" minOccurs="0" maxOccurs="1"/> + <xsd:element name="hlinkHover" type="CT_Hyperlink" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="id" type="ST_DrawingElementId" use="required"/> + <xsd:attribute name="name" type="xsd:string" use="required"/> + <xsd:attribute name="descr" type="xsd:string" use="optional" default=""/> + <xsd:attribute name="hidden" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="title" type="xsd:string" use="optional" default=""/> + </xsd:complexType> + <xsd:complexType name="CT_NonVisualDrawingShapeProps"> + <xsd:sequence> + <xsd:element name="spLocks" type="CT_ShapeLocking" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="txBox" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_NonVisualConnectorProperties"> + <xsd:sequence> + <xsd:element name="cxnSpLocks" type="CT_ConnectorLocking" minOccurs="0" maxOccurs="1"/> + <xsd:element name="stCxn" type="CT_Connection" minOccurs="0" maxOccurs="1"/> + <xsd:element name="endCxn" type="CT_Connection" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_NonVisualPictureProperties"> + <xsd:sequence> + <xsd:element name="picLocks" type="CT_PictureLocking" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="preferRelativeResize" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_NonVisualGroupDrawingShapeProps"> + <xsd:sequence> + <xsd:element name="grpSpLocks" type="CT_GroupLocking" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_NonVisualGraphicFrameProperties"> + <xsd:sequence> + <xsd:element name="graphicFrameLocks" type="CT_GraphicalObjectFrameLocking" minOccurs="0" + maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_NonVisualContentPartProperties"> + <xsd:sequence> + <xsd:element name="cpLocks" type="CT_ContentPartLocking" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="isComment" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_GraphicalObjectData"> + <xsd:sequence> + <xsd:any minOccurs="0" maxOccurs="unbounded" processContents="strict"/> + </xsd:sequence> + <xsd:attribute name="uri" type="xsd:token" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_GraphicalObject"> + <xsd:sequence> + <xsd:element name="graphicData" type="CT_GraphicalObjectData"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="graphic" type="CT_GraphicalObject"/> + <xsd:simpleType name="ST_ChartBuildStep"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="category"/> + <xsd:enumeration value="ptInCategory"/> + <xsd:enumeration value="series"/> + <xsd:enumeration value="ptInSeries"/> + <xsd:enumeration value="allPts"/> + <xsd:enumeration value="gridLegend"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_DgmBuildStep"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="sp"/> + <xsd:enumeration value="bg"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_AnimationDgmElement"> + <xsd:attribute name="id" type="s:ST_Guid" use="optional" + default="{00000000-0000-0000-0000-000000000000}"/> + <xsd:attribute name="bldStep" type="ST_DgmBuildStep" use="optional" default="sp"/> + </xsd:complexType> + <xsd:complexType name="CT_AnimationChartElement"> + <xsd:attribute name="seriesIdx" type="xsd:int" use="optional" default="-1"/> + <xsd:attribute name="categoryIdx" type="xsd:int" use="optional" default="-1"/> + <xsd:attribute name="bldStep" type="ST_ChartBuildStep" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_AnimationElementChoice"> + <xsd:choice minOccurs="1" maxOccurs="1"> + <xsd:element name="dgm" type="CT_AnimationDgmElement"/> + <xsd:element name="chart" type="CT_AnimationChartElement"/> + </xsd:choice> + </xsd:complexType> + <xsd:simpleType name="ST_AnimationBuildType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="allAtOnce"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_AnimationDgmOnlyBuildType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="one"/> + <xsd:enumeration value="lvlOne"/> + <xsd:enumeration value="lvlAtOnce"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_AnimationDgmBuildType"> + <xsd:union memberTypes="ST_AnimationBuildType ST_AnimationDgmOnlyBuildType"/> + </xsd:simpleType> + <xsd:complexType name="CT_AnimationDgmBuildProperties"> + <xsd:attribute name="bld" type="ST_AnimationDgmBuildType" use="optional" default="allAtOnce"/> + <xsd:attribute name="rev" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:simpleType name="ST_AnimationChartOnlyBuildType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="series"/> + <xsd:enumeration value="category"/> + <xsd:enumeration value="seriesEl"/> + <xsd:enumeration value="categoryEl"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_AnimationChartBuildType"> + <xsd:union memberTypes="ST_AnimationBuildType ST_AnimationChartOnlyBuildType"/> + </xsd:simpleType> + <xsd:complexType name="CT_AnimationChartBuildProperties"> + <xsd:attribute name="bld" type="ST_AnimationChartBuildType" use="optional" default="allAtOnce"/> + <xsd:attribute name="animBg" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_AnimationGraphicalObjectBuildProperties"> + <xsd:choice> + <xsd:element name="bldDgm" type="CT_AnimationDgmBuildProperties"/> + <xsd:element name="bldChart" type="CT_AnimationChartBuildProperties"/> + </xsd:choice> + </xsd:complexType> + <xsd:complexType name="CT_BackgroundFormatting"> + <xsd:sequence> + <xsd:group ref="EG_FillProperties" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_EffectProperties" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_WholeE2oFormatting"> + <xsd:sequence> + <xsd:element name="ln" type="CT_LineProperties" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_EffectProperties" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_GvmlUseShapeRectangle"/> + <xsd:complexType name="CT_GvmlTextShape"> + <xsd:sequence> + <xsd:element name="txBody" type="CT_TextBody" minOccurs="1" maxOccurs="1"/> + <xsd:choice> + <xsd:element name="useSpRect" type="CT_GvmlUseShapeRectangle" minOccurs="1" maxOccurs="1"/> + <xsd:element name="xfrm" type="CT_Transform2D" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_GvmlShapeNonVisual"> + <xsd:sequence> + <xsd:element name="cNvPr" type="CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cNvSpPr" type="CT_NonVisualDrawingShapeProps" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_GvmlShape"> + <xsd:sequence> + <xsd:element name="nvSpPr" type="CT_GvmlShapeNonVisual" minOccurs="1" maxOccurs="1"/> + <xsd:element name="spPr" type="CT_ShapeProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="txSp" type="CT_GvmlTextShape" minOccurs="0" maxOccurs="1"/> + <xsd:element name="style" type="CT_ShapeStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_GvmlConnectorNonVisual"> + <xsd:sequence> + <xsd:element name="cNvPr" type="CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cNvCxnSpPr" type="CT_NonVisualConnectorProperties" minOccurs="1" + maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_GvmlConnector"> + <xsd:sequence> + <xsd:element name="nvCxnSpPr" type="CT_GvmlConnectorNonVisual" minOccurs="1" maxOccurs="1"/> + <xsd:element name="spPr" type="CT_ShapeProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="style" type="CT_ShapeStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_GvmlPictureNonVisual"> + <xsd:sequence> + <xsd:element name="cNvPr" type="CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cNvPicPr" type="CT_NonVisualPictureProperties" minOccurs="1" maxOccurs="1" + /> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_GvmlPicture"> + <xsd:sequence> + <xsd:element name="nvPicPr" type="CT_GvmlPictureNonVisual" minOccurs="1" maxOccurs="1"/> + <xsd:element name="blipFill" type="CT_BlipFillProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="spPr" type="CT_ShapeProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="style" type="CT_ShapeStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_GvmlGraphicFrameNonVisual"> + <xsd:sequence> + <xsd:element name="cNvPr" type="CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cNvGraphicFramePr" type="CT_NonVisualGraphicFrameProperties" minOccurs="1" + maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_GvmlGraphicalObjectFrame"> + <xsd:sequence> + <xsd:element name="nvGraphicFramePr" type="CT_GvmlGraphicFrameNonVisual" minOccurs="1" + maxOccurs="1"/> + <xsd:element ref="graphic" minOccurs="1" maxOccurs="1"/> + <xsd:element name="xfrm" type="CT_Transform2D" minOccurs="1" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_GvmlGroupShapeNonVisual"> + <xsd:sequence> + <xsd:element name="cNvPr" type="CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cNvGrpSpPr" type="CT_NonVisualGroupDrawingShapeProps" minOccurs="1" + maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_GvmlGroupShape"> + <xsd:sequence> + <xsd:element name="nvGrpSpPr" type="CT_GvmlGroupShapeNonVisual" minOccurs="1" maxOccurs="1"/> + <xsd:element name="grpSpPr" type="CT_GroupShapeProperties" minOccurs="1" maxOccurs="1"/> + <xsd:choice minOccurs="0" maxOccurs="unbounded"> + <xsd:element name="txSp" type="CT_GvmlTextShape"/> + <xsd:element name="sp" type="CT_GvmlShape"/> + <xsd:element name="cxnSp" type="CT_GvmlConnector"/> + <xsd:element name="pic" type="CT_GvmlPicture"/> + <xsd:element name="graphicFrame" type="CT_GvmlGraphicalObjectFrame"/> + <xsd:element name="grpSp" type="CT_GvmlGroupShape"/> + </xsd:choice> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_PresetCameraType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="legacyObliqueTopLeft"/> + <xsd:enumeration value="legacyObliqueTop"/> + <xsd:enumeration value="legacyObliqueTopRight"/> + <xsd:enumeration value="legacyObliqueLeft"/> + <xsd:enumeration value="legacyObliqueFront"/> + <xsd:enumeration value="legacyObliqueRight"/> + <xsd:enumeration value="legacyObliqueBottomLeft"/> + <xsd:enumeration value="legacyObliqueBottom"/> + <xsd:enumeration value="legacyObliqueBottomRight"/> + <xsd:enumeration value="legacyPerspectiveTopLeft"/> + <xsd:enumeration value="legacyPerspectiveTop"/> + <xsd:enumeration value="legacyPerspectiveTopRight"/> + <xsd:enumeration value="legacyPerspectiveLeft"/> + <xsd:enumeration value="legacyPerspectiveFront"/> + <xsd:enumeration value="legacyPerspectiveRight"/> + <xsd:enumeration value="legacyPerspectiveBottomLeft"/> + <xsd:enumeration value="legacyPerspectiveBottom"/> + <xsd:enumeration value="legacyPerspectiveBottomRight"/> + <xsd:enumeration value="orthographicFront"/> + <xsd:enumeration value="isometricTopUp"/> + <xsd:enumeration value="isometricTopDown"/> + <xsd:enumeration value="isometricBottomUp"/> + <xsd:enumeration value="isometricBottomDown"/> + <xsd:enumeration value="isometricLeftUp"/> + <xsd:enumeration value="isometricLeftDown"/> + <xsd:enumeration value="isometricRightUp"/> + <xsd:enumeration value="isometricRightDown"/> + <xsd:enumeration value="isometricOffAxis1Left"/> + <xsd:enumeration value="isometricOffAxis1Right"/> + <xsd:enumeration value="isometricOffAxis1Top"/> + <xsd:enumeration value="isometricOffAxis2Left"/> + <xsd:enumeration value="isometricOffAxis2Right"/> + <xsd:enumeration value="isometricOffAxis2Top"/> + <xsd:enumeration value="isometricOffAxis3Left"/> + <xsd:enumeration value="isometricOffAxis3Right"/> + <xsd:enumeration value="isometricOffAxis3Bottom"/> + <xsd:enumeration value="isometricOffAxis4Left"/> + <xsd:enumeration value="isometricOffAxis4Right"/> + <xsd:enumeration value="isometricOffAxis4Bottom"/> + <xsd:enumeration value="obliqueTopLeft"/> + <xsd:enumeration value="obliqueTop"/> + <xsd:enumeration value="obliqueTopRight"/> + <xsd:enumeration value="obliqueLeft"/> + <xsd:enumeration value="obliqueRight"/> + <xsd:enumeration value="obliqueBottomLeft"/> + <xsd:enumeration value="obliqueBottom"/> + <xsd:enumeration value="obliqueBottomRight"/> + <xsd:enumeration value="perspectiveFront"/> + <xsd:enumeration value="perspectiveLeft"/> + <xsd:enumeration value="perspectiveRight"/> + <xsd:enumeration value="perspectiveAbove"/> + <xsd:enumeration value="perspectiveBelow"/> + <xsd:enumeration value="perspectiveAboveLeftFacing"/> + <xsd:enumeration value="perspectiveAboveRightFacing"/> + <xsd:enumeration value="perspectiveContrastingLeftFacing"/> + <xsd:enumeration value="perspectiveContrastingRightFacing"/> + <xsd:enumeration value="perspectiveHeroicLeftFacing"/> + <xsd:enumeration value="perspectiveHeroicRightFacing"/> + <xsd:enumeration value="perspectiveHeroicExtremeLeftFacing"/> + <xsd:enumeration value="perspectiveHeroicExtremeRightFacing"/> + <xsd:enumeration value="perspectiveRelaxed"/> + <xsd:enumeration value="perspectiveRelaxedModerately"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_FOVAngle"> + <xsd:restriction base="ST_Angle"> + <xsd:minInclusive value="0"/> + <xsd:maxInclusive value="10800000"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Camera"> + <xsd:sequence> + <xsd:element name="rot" type="CT_SphereCoords" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="prst" type="ST_PresetCameraType" use="required"/> + <xsd:attribute name="fov" type="ST_FOVAngle" use="optional"/> + <xsd:attribute name="zoom" type="ST_PositivePercentage" use="optional" default="100%"/> + </xsd:complexType> + <xsd:simpleType name="ST_LightRigDirection"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="tl"/> + <xsd:enumeration value="t"/> + <xsd:enumeration value="tr"/> + <xsd:enumeration value="l"/> + <xsd:enumeration value="r"/> + <xsd:enumeration value="bl"/> + <xsd:enumeration value="b"/> + <xsd:enumeration value="br"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_LightRigType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="legacyFlat1"/> + <xsd:enumeration value="legacyFlat2"/> + <xsd:enumeration value="legacyFlat3"/> + <xsd:enumeration value="legacyFlat4"/> + <xsd:enumeration value="legacyNormal1"/> + <xsd:enumeration value="legacyNormal2"/> + <xsd:enumeration value="legacyNormal3"/> + <xsd:enumeration value="legacyNormal4"/> + <xsd:enumeration value="legacyHarsh1"/> + <xsd:enumeration value="legacyHarsh2"/> + <xsd:enumeration value="legacyHarsh3"/> + <xsd:enumeration value="legacyHarsh4"/> + <xsd:enumeration value="threePt"/> + <xsd:enumeration value="balanced"/> + <xsd:enumeration value="soft"/> + <xsd:enumeration value="harsh"/> + <xsd:enumeration value="flood"/> + <xsd:enumeration value="contrasting"/> + <xsd:enumeration value="morning"/> + <xsd:enumeration value="sunrise"/> + <xsd:enumeration value="sunset"/> + <xsd:enumeration value="chilly"/> + <xsd:enumeration value="freezing"/> + <xsd:enumeration value="flat"/> + <xsd:enumeration value="twoPt"/> + <xsd:enumeration value="glow"/> + <xsd:enumeration value="brightRoom"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_LightRig"> + <xsd:sequence> + <xsd:element name="rot" type="CT_SphereCoords" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="rig" type="ST_LightRigType" use="required"/> + <xsd:attribute name="dir" type="ST_LightRigDirection" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Scene3D"> + <xsd:sequence> + <xsd:element name="camera" type="CT_Camera" minOccurs="1" maxOccurs="1"/> + <xsd:element name="lightRig" type="CT_LightRig" minOccurs="1" maxOccurs="1"/> + <xsd:element name="backdrop" type="CT_Backdrop" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Backdrop"> + <xsd:sequence> + <xsd:element name="anchor" type="CT_Point3D" minOccurs="1" maxOccurs="1"/> + <xsd:element name="norm" type="CT_Vector3D" minOccurs="1" maxOccurs="1"/> + <xsd:element name="up" type="CT_Vector3D" minOccurs="1" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_BevelPresetType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="relaxedInset"/> + <xsd:enumeration value="circle"/> + <xsd:enumeration value="slope"/> + <xsd:enumeration value="cross"/> + <xsd:enumeration value="angle"/> + <xsd:enumeration value="softRound"/> + <xsd:enumeration value="convex"/> + <xsd:enumeration value="coolSlant"/> + <xsd:enumeration value="divot"/> + <xsd:enumeration value="riblet"/> + <xsd:enumeration value="hardEdge"/> + <xsd:enumeration value="artDeco"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Bevel"> + <xsd:attribute name="w" type="ST_PositiveCoordinate" use="optional" default="76200"/> + <xsd:attribute name="h" type="ST_PositiveCoordinate" use="optional" default="76200"/> + <xsd:attribute name="prst" type="ST_BevelPresetType" use="optional" default="circle"/> + </xsd:complexType> + <xsd:simpleType name="ST_PresetMaterialType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="legacyMatte"/> + <xsd:enumeration value="legacyPlastic"/> + <xsd:enumeration value="legacyMetal"/> + <xsd:enumeration value="legacyWireframe"/> + <xsd:enumeration value="matte"/> + <xsd:enumeration value="plastic"/> + <xsd:enumeration value="metal"/> + <xsd:enumeration value="warmMatte"/> + <xsd:enumeration value="translucentPowder"/> + <xsd:enumeration value="powder"/> + <xsd:enumeration value="dkEdge"/> + <xsd:enumeration value="softEdge"/> + <xsd:enumeration value="clear"/> + <xsd:enumeration value="flat"/> + <xsd:enumeration value="softmetal"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Shape3D"> + <xsd:sequence> + <xsd:element name="bevelT" type="CT_Bevel" minOccurs="0" maxOccurs="1"/> + <xsd:element name="bevelB" type="CT_Bevel" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extrusionClr" type="CT_Color" minOccurs="0" maxOccurs="1"/> + <xsd:element name="contourClr" type="CT_Color" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="z" type="ST_Coordinate" use="optional" default="0"/> + <xsd:attribute name="extrusionH" type="ST_PositiveCoordinate" use="optional" default="0"/> + <xsd:attribute name="contourW" type="ST_PositiveCoordinate" use="optional" default="0"/> + <xsd:attribute name="prstMaterial" type="ST_PresetMaterialType" use="optional" + default="warmMatte"/> + </xsd:complexType> + <xsd:complexType name="CT_FlatText"> + <xsd:attribute name="z" type="ST_Coordinate" use="optional" default="0"/> + </xsd:complexType> + <xsd:group name="EG_Text3D"> + <xsd:choice> + <xsd:element name="sp3d" type="CT_Shape3D" minOccurs="1" maxOccurs="1"/> + <xsd:element name="flatTx" type="CT_FlatText" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_AlphaBiLevelEffect"> + <xsd:attribute name="thresh" type="ST_PositiveFixedPercentage" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_AlphaCeilingEffect"/> + <xsd:complexType name="CT_AlphaFloorEffect"/> + <xsd:complexType name="CT_AlphaInverseEffect"> + <xsd:sequence> + <xsd:group ref="EG_ColorChoice" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_AlphaModulateFixedEffect"> + <xsd:attribute name="amt" type="ST_PositivePercentage" use="optional" default="100%"/> + </xsd:complexType> + <xsd:complexType name="CT_AlphaOutsetEffect"> + <xsd:attribute name="rad" type="ST_Coordinate" use="optional" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_AlphaReplaceEffect"> + <xsd:attribute name="a" type="ST_PositiveFixedPercentage" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_BiLevelEffect"> + <xsd:attribute name="thresh" type="ST_PositiveFixedPercentage" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_BlurEffect"> + <xsd:attribute name="rad" type="ST_PositiveCoordinate" use="optional" default="0"/> + <xsd:attribute name="grow" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_ColorChangeEffect"> + <xsd:sequence> + <xsd:element name="clrFrom" type="CT_Color" minOccurs="1" maxOccurs="1"/> + <xsd:element name="clrTo" type="CT_Color" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="useA" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_ColorReplaceEffect"> + <xsd:sequence> + <xsd:group ref="EG_ColorChoice" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_DuotoneEffect"> + <xsd:sequence> + <xsd:group ref="EG_ColorChoice" minOccurs="2" maxOccurs="2"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_GlowEffect"> + <xsd:sequence> + <xsd:group ref="EG_ColorChoice" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="rad" type="ST_PositiveCoordinate" use="optional" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_GrayscaleEffect"/> + <xsd:complexType name="CT_HSLEffect"> + <xsd:attribute name="hue" type="ST_PositiveFixedAngle" use="optional" default="0"/> + <xsd:attribute name="sat" type="ST_FixedPercentage" use="optional" default="0%"/> + <xsd:attribute name="lum" type="ST_FixedPercentage" use="optional" default="0%"/> + </xsd:complexType> + <xsd:complexType name="CT_InnerShadowEffect"> + <xsd:sequence> + <xsd:group ref="EG_ColorChoice" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="blurRad" type="ST_PositiveCoordinate" use="optional" default="0"/> + <xsd:attribute name="dist" type="ST_PositiveCoordinate" use="optional" default="0"/> + <xsd:attribute name="dir" type="ST_PositiveFixedAngle" use="optional" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_LuminanceEffect"> + <xsd:attribute name="bright" type="ST_FixedPercentage" use="optional" default="0%"/> + <xsd:attribute name="contrast" type="ST_FixedPercentage" use="optional" default="0%"/> + </xsd:complexType> + <xsd:complexType name="CT_OuterShadowEffect"> + <xsd:sequence> + <xsd:group ref="EG_ColorChoice" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="blurRad" type="ST_PositiveCoordinate" use="optional" default="0"/> + <xsd:attribute name="dist" type="ST_PositiveCoordinate" use="optional" default="0"/> + <xsd:attribute name="dir" type="ST_PositiveFixedAngle" use="optional" default="0"/> + <xsd:attribute name="sx" type="ST_Percentage" use="optional" default="100%"/> + <xsd:attribute name="sy" type="ST_Percentage" use="optional" default="100%"/> + <xsd:attribute name="kx" type="ST_FixedAngle" use="optional" default="0"/> + <xsd:attribute name="ky" type="ST_FixedAngle" use="optional" default="0"/> + <xsd:attribute name="algn" type="ST_RectAlignment" use="optional" default="b"/> + <xsd:attribute name="rotWithShape" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:simpleType name="ST_PresetShadowVal"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="shdw1"/> + <xsd:enumeration value="shdw2"/> + <xsd:enumeration value="shdw3"/> + <xsd:enumeration value="shdw4"/> + <xsd:enumeration value="shdw5"/> + <xsd:enumeration value="shdw6"/> + <xsd:enumeration value="shdw7"/> + <xsd:enumeration value="shdw8"/> + <xsd:enumeration value="shdw9"/> + <xsd:enumeration value="shdw10"/> + <xsd:enumeration value="shdw11"/> + <xsd:enumeration value="shdw12"/> + <xsd:enumeration value="shdw13"/> + <xsd:enumeration value="shdw14"/> + <xsd:enumeration value="shdw15"/> + <xsd:enumeration value="shdw16"/> + <xsd:enumeration value="shdw17"/> + <xsd:enumeration value="shdw18"/> + <xsd:enumeration value="shdw19"/> + <xsd:enumeration value="shdw20"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_PresetShadowEffect"> + <xsd:sequence> + <xsd:group ref="EG_ColorChoice" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="prst" type="ST_PresetShadowVal" use="required"/> + <xsd:attribute name="dist" type="ST_PositiveCoordinate" use="optional" default="0"/> + <xsd:attribute name="dir" type="ST_PositiveFixedAngle" use="optional" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_ReflectionEffect"> + <xsd:attribute name="blurRad" type="ST_PositiveCoordinate" use="optional" default="0"/> + <xsd:attribute name="stA" type="ST_PositiveFixedPercentage" use="optional" default="100%"/> + <xsd:attribute name="stPos" type="ST_PositiveFixedPercentage" use="optional" default="0%"/> + <xsd:attribute name="endA" type="ST_PositiveFixedPercentage" use="optional" default="0%"/> + <xsd:attribute name="endPos" type="ST_PositiveFixedPercentage" use="optional" default="100%"/> + <xsd:attribute name="dist" type="ST_PositiveCoordinate" use="optional" default="0"/> + <xsd:attribute name="dir" type="ST_PositiveFixedAngle" use="optional" default="0"/> + <xsd:attribute name="fadeDir" type="ST_PositiveFixedAngle" use="optional" default="5400000"/> + <xsd:attribute name="sx" type="ST_Percentage" use="optional" default="100%"/> + <xsd:attribute name="sy" type="ST_Percentage" use="optional" default="100%"/> + <xsd:attribute name="kx" type="ST_FixedAngle" use="optional" default="0"/> + <xsd:attribute name="ky" type="ST_FixedAngle" use="optional" default="0"/> + <xsd:attribute name="algn" type="ST_RectAlignment" use="optional" default="b"/> + <xsd:attribute name="rotWithShape" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_RelativeOffsetEffect"> + <xsd:attribute name="tx" type="ST_Percentage" use="optional" default="0%"/> + <xsd:attribute name="ty" type="ST_Percentage" use="optional" default="0%"/> + </xsd:complexType> + <xsd:complexType name="CT_SoftEdgesEffect"> + <xsd:attribute name="rad" type="ST_PositiveCoordinate" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_TintEffect"> + <xsd:attribute name="hue" type="ST_PositiveFixedAngle" use="optional" default="0"/> + <xsd:attribute name="amt" type="ST_FixedPercentage" use="optional" default="0%"/> + </xsd:complexType> + <xsd:complexType name="CT_TransformEffect"> + <xsd:attribute name="sx" type="ST_Percentage" use="optional" default="100%"/> + <xsd:attribute name="sy" type="ST_Percentage" use="optional" default="100%"/> + <xsd:attribute name="kx" type="ST_FixedAngle" use="optional" default="0"/> + <xsd:attribute name="ky" type="ST_FixedAngle" use="optional" default="0"/> + <xsd:attribute name="tx" type="ST_Coordinate" use="optional" default="0"/> + <xsd:attribute name="ty" type="ST_Coordinate" use="optional" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_NoFillProperties"/> + <xsd:complexType name="CT_SolidColorFillProperties"> + <xsd:sequence> + <xsd:group ref="EG_ColorChoice" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_LinearShadeProperties"> + <xsd:attribute name="ang" type="ST_PositiveFixedAngle" use="optional"/> + <xsd:attribute name="scaled" type="xsd:boolean" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_PathShadeType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="shape"/> + <xsd:enumeration value="circle"/> + <xsd:enumeration value="rect"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_PathShadeProperties"> + <xsd:sequence> + <xsd:element name="fillToRect" type="CT_RelativeRect" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="path" type="ST_PathShadeType" use="optional"/> + </xsd:complexType> + <xsd:group name="EG_ShadeProperties"> + <xsd:choice> + <xsd:element name="lin" type="CT_LinearShadeProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="path" type="CT_PathShadeProperties" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:group> + <xsd:simpleType name="ST_TileFlipMode"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="x"/> + <xsd:enumeration value="y"/> + <xsd:enumeration value="xy"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_GradientStop"> + <xsd:sequence> + <xsd:group ref="EG_ColorChoice" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="pos" type="ST_PositiveFixedPercentage" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_GradientStopList"> + <xsd:sequence> + <xsd:element name="gs" type="CT_GradientStop" minOccurs="2" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_GradientFillProperties"> + <xsd:sequence> + <xsd:element name="gsLst" type="CT_GradientStopList" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_ShadeProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tileRect" type="CT_RelativeRect" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="flip" type="ST_TileFlipMode" use="optional" default="none"/> + <xsd:attribute name="rotWithShape" type="xsd:boolean" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_TileInfoProperties"> + <xsd:attribute name="tx" type="ST_Coordinate" use="optional"/> + <xsd:attribute name="ty" type="ST_Coordinate" use="optional"/> + <xsd:attribute name="sx" type="ST_Percentage" use="optional"/> + <xsd:attribute name="sy" type="ST_Percentage" use="optional"/> + <xsd:attribute name="flip" type="ST_TileFlipMode" use="optional" default="none"/> + <xsd:attribute name="algn" type="ST_RectAlignment" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_StretchInfoProperties"> + <xsd:sequence> + <xsd:element name="fillRect" type="CT_RelativeRect" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:group name="EG_FillModeProperties"> + <xsd:choice> + <xsd:element name="tile" type="CT_TileInfoProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="stretch" type="CT_StretchInfoProperties" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:group> + <xsd:simpleType name="ST_BlipCompression"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="email"/> + <xsd:enumeration value="screen"/> + <xsd:enumeration value="print"/> + <xsd:enumeration value="hqprint"/> + <xsd:enumeration value="none"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Blip"> + <xsd:sequence> + <xsd:choice minOccurs="0" maxOccurs="unbounded"> + <xsd:element name="alphaBiLevel" type="CT_AlphaBiLevelEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="alphaCeiling" type="CT_AlphaCeilingEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="alphaFloor" type="CT_AlphaFloorEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="alphaInv" type="CT_AlphaInverseEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="alphaMod" type="CT_AlphaModulateEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="alphaModFix" type="CT_AlphaModulateFixedEffect" minOccurs="1" + maxOccurs="1"/> + <xsd:element name="alphaRepl" type="CT_AlphaReplaceEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="biLevel" type="CT_BiLevelEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="blur" type="CT_BlurEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="clrChange" type="CT_ColorChangeEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="clrRepl" type="CT_ColorReplaceEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="duotone" type="CT_DuotoneEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="fillOverlay" type="CT_FillOverlayEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="grayscl" type="CT_GrayscaleEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="hsl" type="CT_HSLEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="lum" type="CT_LuminanceEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="tint" type="CT_TintEffect" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_Blob"/> + <xsd:attribute name="cstate" type="ST_BlipCompression" use="optional" default="none"/> + </xsd:complexType> + <xsd:complexType name="CT_BlipFillProperties"> + <xsd:sequence> + <xsd:element name="blip" type="CT_Blip" minOccurs="0" maxOccurs="1"/> + <xsd:element name="srcRect" type="CT_RelativeRect" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_FillModeProperties" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="dpi" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="rotWithShape" type="xsd:boolean" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_PresetPatternVal"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="pct5"/> + <xsd:enumeration value="pct10"/> + <xsd:enumeration value="pct20"/> + <xsd:enumeration value="pct25"/> + <xsd:enumeration value="pct30"/> + <xsd:enumeration value="pct40"/> + <xsd:enumeration value="pct50"/> + <xsd:enumeration value="pct60"/> + <xsd:enumeration value="pct70"/> + <xsd:enumeration value="pct75"/> + <xsd:enumeration value="pct80"/> + <xsd:enumeration value="pct90"/> + <xsd:enumeration value="horz"/> + <xsd:enumeration value="vert"/> + <xsd:enumeration value="ltHorz"/> + <xsd:enumeration value="ltVert"/> + <xsd:enumeration value="dkHorz"/> + <xsd:enumeration value="dkVert"/> + <xsd:enumeration value="narHorz"/> + <xsd:enumeration value="narVert"/> + <xsd:enumeration value="dashHorz"/> + <xsd:enumeration value="dashVert"/> + <xsd:enumeration value="cross"/> + <xsd:enumeration value="dnDiag"/> + <xsd:enumeration value="upDiag"/> + <xsd:enumeration value="ltDnDiag"/> + <xsd:enumeration value="ltUpDiag"/> + <xsd:enumeration value="dkDnDiag"/> + <xsd:enumeration value="dkUpDiag"/> + <xsd:enumeration value="wdDnDiag"/> + <xsd:enumeration value="wdUpDiag"/> + <xsd:enumeration value="dashDnDiag"/> + <xsd:enumeration value="dashUpDiag"/> + <xsd:enumeration value="diagCross"/> + <xsd:enumeration value="smCheck"/> + <xsd:enumeration value="lgCheck"/> + <xsd:enumeration value="smGrid"/> + <xsd:enumeration value="lgGrid"/> + <xsd:enumeration value="dotGrid"/> + <xsd:enumeration value="smConfetti"/> + <xsd:enumeration value="lgConfetti"/> + <xsd:enumeration value="horzBrick"/> + <xsd:enumeration value="diagBrick"/> + <xsd:enumeration value="solidDmnd"/> + <xsd:enumeration value="openDmnd"/> + <xsd:enumeration value="dotDmnd"/> + <xsd:enumeration value="plaid"/> + <xsd:enumeration value="sphere"/> + <xsd:enumeration value="weave"/> + <xsd:enumeration value="divot"/> + <xsd:enumeration value="shingle"/> + <xsd:enumeration value="wave"/> + <xsd:enumeration value="trellis"/> + <xsd:enumeration value="zigZag"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_PatternFillProperties"> + <xsd:sequence> + <xsd:element name="fgClr" type="CT_Color" minOccurs="0" maxOccurs="1"/> + <xsd:element name="bgClr" type="CT_Color" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="prst" type="ST_PresetPatternVal" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_GroupFillProperties"/> + <xsd:group name="EG_FillProperties"> + <xsd:choice> + <xsd:element name="noFill" type="CT_NoFillProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="solidFill" type="CT_SolidColorFillProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="gradFill" type="CT_GradientFillProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="blipFill" type="CT_BlipFillProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="pattFill" type="CT_PatternFillProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="grpFill" type="CT_GroupFillProperties" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_FillProperties"> + <xsd:sequence> + <xsd:group ref="EG_FillProperties" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_FillEffect"> + <xsd:sequence> + <xsd:group ref="EG_FillProperties" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_BlendMode"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="over"/> + <xsd:enumeration value="mult"/> + <xsd:enumeration value="screen"/> + <xsd:enumeration value="darken"/> + <xsd:enumeration value="lighten"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_FillOverlayEffect"> + <xsd:sequence> + <xsd:group ref="EG_FillProperties" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="blend" type="ST_BlendMode" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_EffectReference"> + <xsd:attribute name="ref" type="xsd:token" use="required"/> + </xsd:complexType> + <xsd:group name="EG_Effect"> + <xsd:choice> + <xsd:element name="cont" type="CT_EffectContainer" minOccurs="1" maxOccurs="1"/> + <xsd:element name="effect" type="CT_EffectReference" minOccurs="1" maxOccurs="1"/> + <xsd:element name="alphaBiLevel" type="CT_AlphaBiLevelEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="alphaCeiling" type="CT_AlphaCeilingEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="alphaFloor" type="CT_AlphaFloorEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="alphaInv" type="CT_AlphaInverseEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="alphaMod" type="CT_AlphaModulateEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="alphaModFix" type="CT_AlphaModulateFixedEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="alphaOutset" type="CT_AlphaOutsetEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="alphaRepl" type="CT_AlphaReplaceEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="biLevel" type="CT_BiLevelEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="blend" type="CT_BlendEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="blur" type="CT_BlurEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="clrChange" type="CT_ColorChangeEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="clrRepl" type="CT_ColorReplaceEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="duotone" type="CT_DuotoneEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="fill" type="CT_FillEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="fillOverlay" type="CT_FillOverlayEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="glow" type="CT_GlowEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="grayscl" type="CT_GrayscaleEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="hsl" type="CT_HSLEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="innerShdw" type="CT_InnerShadowEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="lum" type="CT_LuminanceEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="outerShdw" type="CT_OuterShadowEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="prstShdw" type="CT_PresetShadowEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="reflection" type="CT_ReflectionEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="relOff" type="CT_RelativeOffsetEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="softEdge" type="CT_SoftEdgesEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="tint" type="CT_TintEffect" minOccurs="1" maxOccurs="1"/> + <xsd:element name="xfrm" type="CT_TransformEffect" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:group> + <xsd:simpleType name="ST_EffectContainerType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="sib"/> + <xsd:enumeration value="tree"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_EffectContainer"> + <xsd:group ref="EG_Effect" minOccurs="0" maxOccurs="unbounded"/> + <xsd:attribute name="type" type="ST_EffectContainerType" use="optional" default="sib"/> + <xsd:attribute name="name" type="xsd:token" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_AlphaModulateEffect"> + <xsd:sequence> + <xsd:element name="cont" type="CT_EffectContainer" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_BlendEffect"> + <xsd:sequence> + <xsd:element name="cont" type="CT_EffectContainer" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="blend" type="ST_BlendMode" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_EffectList"> + <xsd:sequence> + <xsd:element name="blur" type="CT_BlurEffect" minOccurs="0" maxOccurs="1"/> + <xsd:element name="fillOverlay" type="CT_FillOverlayEffect" minOccurs="0" maxOccurs="1"/> + <xsd:element name="glow" type="CT_GlowEffect" minOccurs="0" maxOccurs="1"/> + <xsd:element name="innerShdw" type="CT_InnerShadowEffect" minOccurs="0" maxOccurs="1"/> + <xsd:element name="outerShdw" type="CT_OuterShadowEffect" minOccurs="0" maxOccurs="1"/> + <xsd:element name="prstShdw" type="CT_PresetShadowEffect" minOccurs="0" maxOccurs="1"/> + <xsd:element name="reflection" type="CT_ReflectionEffect" minOccurs="0" maxOccurs="1"/> + <xsd:element name="softEdge" type="CT_SoftEdgesEffect" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:group name="EG_EffectProperties"> + <xsd:choice> + <xsd:element name="effectLst" type="CT_EffectList" minOccurs="1" maxOccurs="1"/> + <xsd:element name="effectDag" type="CT_EffectContainer" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_EffectProperties"> + <xsd:sequence> + <xsd:group ref="EG_EffectProperties" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="blip" type="CT_Blip"/> + <xsd:simpleType name="ST_ShapeType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="line"/> + <xsd:enumeration value="lineInv"/> + <xsd:enumeration value="triangle"/> + <xsd:enumeration value="rtTriangle"/> + <xsd:enumeration value="rect"/> + <xsd:enumeration value="diamond"/> + <xsd:enumeration value="parallelogram"/> + <xsd:enumeration value="trapezoid"/> + <xsd:enumeration value="nonIsoscelesTrapezoid"/> + <xsd:enumeration value="pentagon"/> + <xsd:enumeration value="hexagon"/> + <xsd:enumeration value="heptagon"/> + <xsd:enumeration value="octagon"/> + <xsd:enumeration value="decagon"/> + <xsd:enumeration value="dodecagon"/> + <xsd:enumeration value="star4"/> + <xsd:enumeration value="star5"/> + <xsd:enumeration value="star6"/> + <xsd:enumeration value="star7"/> + <xsd:enumeration value="star8"/> + <xsd:enumeration value="star10"/> + <xsd:enumeration value="star12"/> + <xsd:enumeration value="star16"/> + <xsd:enumeration value="star24"/> + <xsd:enumeration value="star32"/> + <xsd:enumeration value="roundRect"/> + <xsd:enumeration value="round1Rect"/> + <xsd:enumeration value="round2SameRect"/> + <xsd:enumeration value="round2DiagRect"/> + <xsd:enumeration value="snipRoundRect"/> + <xsd:enumeration value="snip1Rect"/> + <xsd:enumeration value="snip2SameRect"/> + <xsd:enumeration value="snip2DiagRect"/> + <xsd:enumeration value="plaque"/> + <xsd:enumeration value="ellipse"/> + <xsd:enumeration value="teardrop"/> + <xsd:enumeration value="homePlate"/> + <xsd:enumeration value="chevron"/> + <xsd:enumeration value="pieWedge"/> + <xsd:enumeration value="pie"/> + <xsd:enumeration value="blockArc"/> + <xsd:enumeration value="donut"/> + <xsd:enumeration value="noSmoking"/> + <xsd:enumeration value="rightArrow"/> + <xsd:enumeration value="leftArrow"/> + <xsd:enumeration value="upArrow"/> + <xsd:enumeration value="downArrow"/> + <xsd:enumeration value="stripedRightArrow"/> + <xsd:enumeration value="notchedRightArrow"/> + <xsd:enumeration value="bentUpArrow"/> + <xsd:enumeration value="leftRightArrow"/> + <xsd:enumeration value="upDownArrow"/> + <xsd:enumeration value="leftUpArrow"/> + <xsd:enumeration value="leftRightUpArrow"/> + <xsd:enumeration value="quadArrow"/> + <xsd:enumeration value="leftArrowCallout"/> + <xsd:enumeration value="rightArrowCallout"/> + <xsd:enumeration value="upArrowCallout"/> + <xsd:enumeration value="downArrowCallout"/> + <xsd:enumeration value="leftRightArrowCallout"/> + <xsd:enumeration value="upDownArrowCallout"/> + <xsd:enumeration value="quadArrowCallout"/> + <xsd:enumeration value="bentArrow"/> + <xsd:enumeration value="uturnArrow"/> + <xsd:enumeration value="circularArrow"/> + <xsd:enumeration value="leftCircularArrow"/> + <xsd:enumeration value="leftRightCircularArrow"/> + <xsd:enumeration value="curvedRightArrow"/> + <xsd:enumeration value="curvedLeftArrow"/> + <xsd:enumeration value="curvedUpArrow"/> + <xsd:enumeration value="curvedDownArrow"/> + <xsd:enumeration value="swooshArrow"/> + <xsd:enumeration value="cube"/> + <xsd:enumeration value="can"/> + <xsd:enumeration value="lightningBolt"/> + <xsd:enumeration value="heart"/> + <xsd:enumeration value="sun"/> + <xsd:enumeration value="moon"/> + <xsd:enumeration value="smileyFace"/> + <xsd:enumeration value="irregularSeal1"/> + <xsd:enumeration value="irregularSeal2"/> + <xsd:enumeration value="foldedCorner"/> + <xsd:enumeration value="bevel"/> + <xsd:enumeration value="frame"/> + <xsd:enumeration value="halfFrame"/> + <xsd:enumeration value="corner"/> + <xsd:enumeration value="diagStripe"/> + <xsd:enumeration value="chord"/> + <xsd:enumeration value="arc"/> + <xsd:enumeration value="leftBracket"/> + <xsd:enumeration value="rightBracket"/> + <xsd:enumeration value="leftBrace"/> + <xsd:enumeration value="rightBrace"/> + <xsd:enumeration value="bracketPair"/> + <xsd:enumeration value="bracePair"/> + <xsd:enumeration value="straightConnector1"/> + <xsd:enumeration value="bentConnector2"/> + <xsd:enumeration value="bentConnector3"/> + <xsd:enumeration value="bentConnector4"/> + <xsd:enumeration value="bentConnector5"/> + <xsd:enumeration value="curvedConnector2"/> + <xsd:enumeration value="curvedConnector3"/> + <xsd:enumeration value="curvedConnector4"/> + <xsd:enumeration value="curvedConnector5"/> + <xsd:enumeration value="callout1"/> + <xsd:enumeration value="callout2"/> + <xsd:enumeration value="callout3"/> + <xsd:enumeration value="accentCallout1"/> + <xsd:enumeration value="accentCallout2"/> + <xsd:enumeration value="accentCallout3"/> + <xsd:enumeration value="borderCallout1"/> + <xsd:enumeration value="borderCallout2"/> + <xsd:enumeration value="borderCallout3"/> + <xsd:enumeration value="accentBorderCallout1"/> + <xsd:enumeration value="accentBorderCallout2"/> + <xsd:enumeration value="accentBorderCallout3"/> + <xsd:enumeration value="wedgeRectCallout"/> + <xsd:enumeration value="wedgeRoundRectCallout"/> + <xsd:enumeration value="wedgeEllipseCallout"/> + <xsd:enumeration value="cloudCallout"/> + <xsd:enumeration value="cloud"/> + <xsd:enumeration value="ribbon"/> + <xsd:enumeration value="ribbon2"/> + <xsd:enumeration value="ellipseRibbon"/> + <xsd:enumeration value="ellipseRibbon2"/> + <xsd:enumeration value="leftRightRibbon"/> + <xsd:enumeration value="verticalScroll"/> + <xsd:enumeration value="horizontalScroll"/> + <xsd:enumeration value="wave"/> + <xsd:enumeration value="doubleWave"/> + <xsd:enumeration value="plus"/> + <xsd:enumeration value="flowChartProcess"/> + <xsd:enumeration value="flowChartDecision"/> + <xsd:enumeration value="flowChartInputOutput"/> + <xsd:enumeration value="flowChartPredefinedProcess"/> + <xsd:enumeration value="flowChartInternalStorage"/> + <xsd:enumeration value="flowChartDocument"/> + <xsd:enumeration value="flowChartMultidocument"/> + <xsd:enumeration value="flowChartTerminator"/> + <xsd:enumeration value="flowChartPreparation"/> + <xsd:enumeration value="flowChartManualInput"/> + <xsd:enumeration value="flowChartManualOperation"/> + <xsd:enumeration value="flowChartConnector"/> + <xsd:enumeration value="flowChartPunchedCard"/> + <xsd:enumeration value="flowChartPunchedTape"/> + <xsd:enumeration value="flowChartSummingJunction"/> + <xsd:enumeration value="flowChartOr"/> + <xsd:enumeration value="flowChartCollate"/> + <xsd:enumeration value="flowChartSort"/> + <xsd:enumeration value="flowChartExtract"/> + <xsd:enumeration value="flowChartMerge"/> + <xsd:enumeration value="flowChartOfflineStorage"/> + <xsd:enumeration value="flowChartOnlineStorage"/> + <xsd:enumeration value="flowChartMagneticTape"/> + <xsd:enumeration value="flowChartMagneticDisk"/> + <xsd:enumeration value="flowChartMagneticDrum"/> + <xsd:enumeration value="flowChartDisplay"/> + <xsd:enumeration value="flowChartDelay"/> + <xsd:enumeration value="flowChartAlternateProcess"/> + <xsd:enumeration value="flowChartOffpageConnector"/> + <xsd:enumeration value="actionButtonBlank"/> + <xsd:enumeration value="actionButtonHome"/> + <xsd:enumeration value="actionButtonHelp"/> + <xsd:enumeration value="actionButtonInformation"/> + <xsd:enumeration value="actionButtonForwardNext"/> + <xsd:enumeration value="actionButtonBackPrevious"/> + <xsd:enumeration value="actionButtonEnd"/> + <xsd:enumeration value="actionButtonBeginning"/> + <xsd:enumeration value="actionButtonReturn"/> + <xsd:enumeration value="actionButtonDocument"/> + <xsd:enumeration value="actionButtonSound"/> + <xsd:enumeration value="actionButtonMovie"/> + <xsd:enumeration value="gear6"/> + <xsd:enumeration value="gear9"/> + <xsd:enumeration value="funnel"/> + <xsd:enumeration value="mathPlus"/> + <xsd:enumeration value="mathMinus"/> + <xsd:enumeration value="mathMultiply"/> + <xsd:enumeration value="mathDivide"/> + <xsd:enumeration value="mathEqual"/> + <xsd:enumeration value="mathNotEqual"/> + <xsd:enumeration value="cornerTabs"/> + <xsd:enumeration value="squareTabs"/> + <xsd:enumeration value="plaqueTabs"/> + <xsd:enumeration value="chartX"/> + <xsd:enumeration value="chartStar"/> + <xsd:enumeration value="chartPlus"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TextShapeType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="textNoShape"/> + <xsd:enumeration value="textPlain"/> + <xsd:enumeration value="textStop"/> + <xsd:enumeration value="textTriangle"/> + <xsd:enumeration value="textTriangleInverted"/> + <xsd:enumeration value="textChevron"/> + <xsd:enumeration value="textChevronInverted"/> + <xsd:enumeration value="textRingInside"/> + <xsd:enumeration value="textRingOutside"/> + <xsd:enumeration value="textArchUp"/> + <xsd:enumeration value="textArchDown"/> + <xsd:enumeration value="textCircle"/> + <xsd:enumeration value="textButton"/> + <xsd:enumeration value="textArchUpPour"/> + <xsd:enumeration value="textArchDownPour"/> + <xsd:enumeration value="textCirclePour"/> + <xsd:enumeration value="textButtonPour"/> + <xsd:enumeration value="textCurveUp"/> + <xsd:enumeration value="textCurveDown"/> + <xsd:enumeration value="textCanUp"/> + <xsd:enumeration value="textCanDown"/> + <xsd:enumeration value="textWave1"/> + <xsd:enumeration value="textWave2"/> + <xsd:enumeration value="textDoubleWave1"/> + <xsd:enumeration value="textWave4"/> + <xsd:enumeration value="textInflate"/> + <xsd:enumeration value="textDeflate"/> + <xsd:enumeration value="textInflateBottom"/> + <xsd:enumeration value="textDeflateBottom"/> + <xsd:enumeration value="textInflateTop"/> + <xsd:enumeration value="textDeflateTop"/> + <xsd:enumeration value="textDeflateInflate"/> + <xsd:enumeration value="textDeflateInflateDeflate"/> + <xsd:enumeration value="textFadeRight"/> + <xsd:enumeration value="textFadeLeft"/> + <xsd:enumeration value="textFadeUp"/> + <xsd:enumeration value="textFadeDown"/> + <xsd:enumeration value="textSlantUp"/> + <xsd:enumeration value="textSlantDown"/> + <xsd:enumeration value="textCascadeUp"/> + <xsd:enumeration value="textCascadeDown"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_GeomGuideName"> + <xsd:restriction base="xsd:token"/> + </xsd:simpleType> + <xsd:simpleType name="ST_GeomGuideFormula"> + <xsd:restriction base="xsd:string"/> + </xsd:simpleType> + <xsd:complexType name="CT_GeomGuide"> + <xsd:attribute name="name" type="ST_GeomGuideName" use="required"/> + <xsd:attribute name="fmla" type="ST_GeomGuideFormula" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_GeomGuideList"> + <xsd:sequence> + <xsd:element name="gd" type="CT_GeomGuide" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_AdjCoordinate"> + <xsd:union memberTypes="ST_Coordinate ST_GeomGuideName"/> + </xsd:simpleType> + <xsd:simpleType name="ST_AdjAngle"> + <xsd:union memberTypes="ST_Angle ST_GeomGuideName"/> + </xsd:simpleType> + <xsd:complexType name="CT_AdjPoint2D"> + <xsd:attribute name="x" type="ST_AdjCoordinate" use="required"/> + <xsd:attribute name="y" type="ST_AdjCoordinate" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_GeomRect"> + <xsd:attribute name="l" type="ST_AdjCoordinate" use="required"/> + <xsd:attribute name="t" type="ST_AdjCoordinate" use="required"/> + <xsd:attribute name="r" type="ST_AdjCoordinate" use="required"/> + <xsd:attribute name="b" type="ST_AdjCoordinate" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_XYAdjustHandle"> + <xsd:sequence> + <xsd:element name="pos" type="CT_AdjPoint2D" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="gdRefX" type="ST_GeomGuideName" use="optional"/> + <xsd:attribute name="minX" type="ST_AdjCoordinate" use="optional"/> + <xsd:attribute name="maxX" type="ST_AdjCoordinate" use="optional"/> + <xsd:attribute name="gdRefY" type="ST_GeomGuideName" use="optional"/> + <xsd:attribute name="minY" type="ST_AdjCoordinate" use="optional"/> + <xsd:attribute name="maxY" type="ST_AdjCoordinate" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_PolarAdjustHandle"> + <xsd:sequence> + <xsd:element name="pos" type="CT_AdjPoint2D" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="gdRefR" type="ST_GeomGuideName" use="optional"/> + <xsd:attribute name="minR" type="ST_AdjCoordinate" use="optional"/> + <xsd:attribute name="maxR" type="ST_AdjCoordinate" use="optional"/> + <xsd:attribute name="gdRefAng" type="ST_GeomGuideName" use="optional"/> + <xsd:attribute name="minAng" type="ST_AdjAngle" use="optional"/> + <xsd:attribute name="maxAng" type="ST_AdjAngle" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_ConnectionSite"> + <xsd:sequence> + <xsd:element name="pos" type="CT_AdjPoint2D" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="ang" type="ST_AdjAngle" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_AdjustHandleList"> + <xsd:choice minOccurs="0" maxOccurs="unbounded"> + <xsd:element name="ahXY" type="CT_XYAdjustHandle" minOccurs="1" maxOccurs="1"/> + <xsd:element name="ahPolar" type="CT_PolarAdjustHandle" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:complexType> + <xsd:complexType name="CT_ConnectionSiteList"> + <xsd:sequence> + <xsd:element name="cxn" type="CT_ConnectionSite" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Connection"> + <xsd:attribute name="id" type="ST_DrawingElementId" use="required"/> + <xsd:attribute name="idx" type="xsd:unsignedInt" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Path2DMoveTo"> + <xsd:sequence> + <xsd:element name="pt" type="CT_AdjPoint2D" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Path2DLineTo"> + <xsd:sequence> + <xsd:element name="pt" type="CT_AdjPoint2D" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Path2DArcTo"> + <xsd:attribute name="wR" type="ST_AdjCoordinate" use="required"/> + <xsd:attribute name="hR" type="ST_AdjCoordinate" use="required"/> + <xsd:attribute name="stAng" type="ST_AdjAngle" use="required"/> + <xsd:attribute name="swAng" type="ST_AdjAngle" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Path2DQuadBezierTo"> + <xsd:sequence> + <xsd:element name="pt" type="CT_AdjPoint2D" minOccurs="2" maxOccurs="2"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Path2DCubicBezierTo"> + <xsd:sequence> + <xsd:element name="pt" type="CT_AdjPoint2D" minOccurs="3" maxOccurs="3"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Path2DClose"/> + <xsd:simpleType name="ST_PathFillMode"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="norm"/> + <xsd:enumeration value="lighten"/> + <xsd:enumeration value="lightenLess"/> + <xsd:enumeration value="darken"/> + <xsd:enumeration value="darkenLess"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Path2D"> + <xsd:choice minOccurs="0" maxOccurs="unbounded"> + <xsd:element name="close" type="CT_Path2DClose" minOccurs="1" maxOccurs="1"/> + <xsd:element name="moveTo" type="CT_Path2DMoveTo" minOccurs="1" maxOccurs="1"/> + <xsd:element name="lnTo" type="CT_Path2DLineTo" minOccurs="1" maxOccurs="1"/> + <xsd:element name="arcTo" type="CT_Path2DArcTo" minOccurs="1" maxOccurs="1"/> + <xsd:element name="quadBezTo" type="CT_Path2DQuadBezierTo" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cubicBezTo" type="CT_Path2DCubicBezierTo" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + <xsd:attribute name="w" type="ST_PositiveCoordinate" use="optional" default="0"/> + <xsd:attribute name="h" type="ST_PositiveCoordinate" use="optional" default="0"/> + <xsd:attribute name="fill" type="ST_PathFillMode" use="optional" default="norm"/> + <xsd:attribute name="stroke" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="extrusionOk" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_Path2DList"> + <xsd:sequence> + <xsd:element name="path" type="CT_Path2D" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_PresetGeometry2D"> + <xsd:sequence> + <xsd:element name="avLst" type="CT_GeomGuideList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="prst" type="ST_ShapeType" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_PresetTextShape"> + <xsd:sequence> + <xsd:element name="avLst" type="CT_GeomGuideList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="prst" type="ST_TextShapeType" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_CustomGeometry2D"> + <xsd:sequence> + <xsd:element name="avLst" type="CT_GeomGuideList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="gdLst" type="CT_GeomGuideList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="ahLst" type="CT_AdjustHandleList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="cxnLst" type="CT_ConnectionSiteList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="rect" type="CT_GeomRect" minOccurs="0" maxOccurs="1"/> + <xsd:element name="pathLst" type="CT_Path2DList" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:group name="EG_Geometry"> + <xsd:choice> + <xsd:element name="custGeom" type="CT_CustomGeometry2D" minOccurs="1" maxOccurs="1"/> + <xsd:element name="prstGeom" type="CT_PresetGeometry2D" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:group> + <xsd:group name="EG_TextGeometry"> + <xsd:choice> + <xsd:element name="custGeom" type="CT_CustomGeometry2D" minOccurs="1" maxOccurs="1"/> + <xsd:element name="prstTxWarp" type="CT_PresetTextShape" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:group> + <xsd:simpleType name="ST_LineEndType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="triangle"/> + <xsd:enumeration value="stealth"/> + <xsd:enumeration value="diamond"/> + <xsd:enumeration value="oval"/> + <xsd:enumeration value="arrow"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_LineEndWidth"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="sm"/> + <xsd:enumeration value="med"/> + <xsd:enumeration value="lg"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_LineEndLength"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="sm"/> + <xsd:enumeration value="med"/> + <xsd:enumeration value="lg"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_LineEndProperties"> + <xsd:attribute name="type" type="ST_LineEndType" use="optional" default="none"/> + <xsd:attribute name="w" type="ST_LineEndWidth" use="optional"/> + <xsd:attribute name="len" type="ST_LineEndLength" use="optional"/> + </xsd:complexType> + <xsd:group name="EG_LineFillProperties"> + <xsd:choice> + <xsd:element name="noFill" type="CT_NoFillProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="solidFill" type="CT_SolidColorFillProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="gradFill" type="CT_GradientFillProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="pattFill" type="CT_PatternFillProperties" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_LineJoinBevel"/> + <xsd:complexType name="CT_LineJoinRound"/> + <xsd:complexType name="CT_LineJoinMiterProperties"> + <xsd:attribute name="lim" type="ST_PositivePercentage" use="optional"/> + </xsd:complexType> + <xsd:group name="EG_LineJoinProperties"> + <xsd:choice> + <xsd:element name="round" type="CT_LineJoinRound" minOccurs="1" maxOccurs="1"/> + <xsd:element name="bevel" type="CT_LineJoinBevel" minOccurs="1" maxOccurs="1"/> + <xsd:element name="miter" type="CT_LineJoinMiterProperties" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:group> + <xsd:simpleType name="ST_PresetLineDashVal"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="solid"/> + <xsd:enumeration value="dot"/> + <xsd:enumeration value="dash"/> + <xsd:enumeration value="lgDash"/> + <xsd:enumeration value="dashDot"/> + <xsd:enumeration value="lgDashDot"/> + <xsd:enumeration value="lgDashDotDot"/> + <xsd:enumeration value="sysDash"/> + <xsd:enumeration value="sysDot"/> + <xsd:enumeration value="sysDashDot"/> + <xsd:enumeration value="sysDashDotDot"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_PresetLineDashProperties"> + <xsd:attribute name="val" type="ST_PresetLineDashVal" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_DashStop"> + <xsd:attribute name="d" type="ST_PositivePercentage" use="required"/> + <xsd:attribute name="sp" type="ST_PositivePercentage" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_DashStopList"> + <xsd:sequence> + <xsd:element name="ds" type="CT_DashStop" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:group name="EG_LineDashProperties"> + <xsd:choice> + <xsd:element name="prstDash" type="CT_PresetLineDashProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="custDash" type="CT_DashStopList" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:group> + <xsd:simpleType name="ST_LineCap"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="rnd"/> + <xsd:enumeration value="sq"/> + <xsd:enumeration value="flat"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_LineWidth"> + <xsd:restriction base="ST_Coordinate32Unqualified"> + <xsd:minInclusive value="0"/> + <xsd:maxInclusive value="20116800"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_PenAlignment"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="ctr"/> + <xsd:enumeration value="in"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_CompoundLine"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="sng"/> + <xsd:enumeration value="dbl"/> + <xsd:enumeration value="thickThin"/> + <xsd:enumeration value="thinThick"/> + <xsd:enumeration value="tri"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_LineProperties"> + <xsd:sequence> + <xsd:group ref="EG_LineFillProperties" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_LineDashProperties" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_LineJoinProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="headEnd" type="CT_LineEndProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tailEnd" type="CT_LineEndProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="w" type="ST_LineWidth" use="optional"/> + <xsd:attribute name="cap" type="ST_LineCap" use="optional"/> + <xsd:attribute name="cmpd" type="ST_CompoundLine" use="optional"/> + <xsd:attribute name="algn" type="ST_PenAlignment" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_ShapeID"> + <xsd:restriction base="xsd:token"/> + </xsd:simpleType> + <xsd:complexType name="CT_ShapeProperties"> + <xsd:sequence> + <xsd:element name="xfrm" type="CT_Transform2D" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_Geometry" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_FillProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="ln" type="CT_LineProperties" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_EffectProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="scene3d" type="CT_Scene3D" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sp3d" type="CT_Shape3D" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="bwMode" type="ST_BlackWhiteMode" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_GroupShapeProperties"> + <xsd:sequence> + <xsd:element name="xfrm" type="CT_GroupTransform2D" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_FillProperties" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_EffectProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="scene3d" type="CT_Scene3D" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="bwMode" type="ST_BlackWhiteMode" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_StyleMatrixReference"> + <xsd:sequence> + <xsd:group ref="EG_ColorChoice" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="idx" type="ST_StyleMatrixColumnIndex" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_FontReference"> + <xsd:sequence> + <xsd:group ref="EG_ColorChoice" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="idx" type="ST_FontCollectionIndex" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_ShapeStyle"> + <xsd:sequence> + <xsd:element name="lnRef" type="CT_StyleMatrixReference" minOccurs="1" maxOccurs="1"/> + <xsd:element name="fillRef" type="CT_StyleMatrixReference" minOccurs="1" maxOccurs="1"/> + <xsd:element name="effectRef" type="CT_StyleMatrixReference" minOccurs="1" maxOccurs="1"/> + <xsd:element name="fontRef" type="CT_FontReference" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_DefaultShapeDefinition"> + <xsd:sequence> + <xsd:element name="spPr" type="CT_ShapeProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="bodyPr" type="CT_TextBodyProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="lstStyle" type="CT_TextListStyle" minOccurs="1" maxOccurs="1"/> + <xsd:element name="style" type="CT_ShapeStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_ObjectStyleDefaults"> + <xsd:sequence> + <xsd:element name="spDef" type="CT_DefaultShapeDefinition" minOccurs="0" maxOccurs="1"/> + <xsd:element name="lnDef" type="CT_DefaultShapeDefinition" minOccurs="0" maxOccurs="1"/> + <xsd:element name="txDef" type="CT_DefaultShapeDefinition" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_EmptyElement"/> + <xsd:complexType name="CT_ColorMapping"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="bg1" type="ST_ColorSchemeIndex" use="required"/> + <xsd:attribute name="tx1" type="ST_ColorSchemeIndex" use="required"/> + <xsd:attribute name="bg2" type="ST_ColorSchemeIndex" use="required"/> + <xsd:attribute name="tx2" type="ST_ColorSchemeIndex" use="required"/> + <xsd:attribute name="accent1" type="ST_ColorSchemeIndex" use="required"/> + <xsd:attribute name="accent2" type="ST_ColorSchemeIndex" use="required"/> + <xsd:attribute name="accent3" type="ST_ColorSchemeIndex" use="required"/> + <xsd:attribute name="accent4" type="ST_ColorSchemeIndex" use="required"/> + <xsd:attribute name="accent5" type="ST_ColorSchemeIndex" use="required"/> + <xsd:attribute name="accent6" type="ST_ColorSchemeIndex" use="required"/> + <xsd:attribute name="hlink" type="ST_ColorSchemeIndex" use="required"/> + <xsd:attribute name="folHlink" type="ST_ColorSchemeIndex" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_ColorMappingOverride"> + <xsd:sequence> + <xsd:choice minOccurs="1" maxOccurs="1"> + <xsd:element name="masterClrMapping" type="CT_EmptyElement"/> + <xsd:element name="overrideClrMapping" type="CT_ColorMapping"/> + </xsd:choice> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_ColorSchemeAndMapping"> + <xsd:sequence> + <xsd:element name="clrScheme" type="CT_ColorScheme" minOccurs="1" maxOccurs="1"/> + <xsd:element name="clrMap" type="CT_ColorMapping" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_ColorSchemeList"> + <xsd:sequence> + <xsd:element name="extraClrScheme" type="CT_ColorSchemeAndMapping" minOccurs="0" + maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_OfficeStyleSheet"> + <xsd:sequence> + <xsd:element name="themeElements" type="CT_BaseStyles" minOccurs="1" maxOccurs="1"/> + <xsd:element name="objectDefaults" type="CT_ObjectStyleDefaults" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extraClrSchemeLst" type="CT_ColorSchemeList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="custClrLst" type="CT_CustomColorList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="optional" default=""/> + </xsd:complexType> + <xsd:complexType name="CT_BaseStylesOverride"> + <xsd:sequence> + <xsd:element name="clrScheme" type="CT_ColorScheme" minOccurs="0" maxOccurs="1"/> + <xsd:element name="fontScheme" type="CT_FontScheme" minOccurs="0" maxOccurs="1"/> + <xsd:element name="fmtScheme" type="CT_StyleMatrix" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_ClipboardStyleSheet"> + <xsd:sequence> + <xsd:element name="themeElements" type="CT_BaseStyles" minOccurs="1" maxOccurs="1"/> + <xsd:element name="clrMap" type="CT_ColorMapping" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="theme" type="CT_OfficeStyleSheet"/> + <xsd:element name="themeOverride" type="CT_BaseStylesOverride"/> + <xsd:element name="themeManager" type="CT_EmptyElement"/> + <xsd:complexType name="CT_TableCellProperties"> + <xsd:sequence> + <xsd:element name="lnL" type="CT_LineProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="lnR" type="CT_LineProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="lnT" type="CT_LineProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="lnB" type="CT_LineProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="lnTlToBr" type="CT_LineProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="lnBlToTr" type="CT_LineProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="cell3D" type="CT_Cell3D" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_FillProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="headers" type="CT_Headers" minOccurs="0"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="marL" type="ST_Coordinate32" use="optional" default="91440"/> + <xsd:attribute name="marR" type="ST_Coordinate32" use="optional" default="91440"/> + <xsd:attribute name="marT" type="ST_Coordinate32" use="optional" default="45720"/> + <xsd:attribute name="marB" type="ST_Coordinate32" use="optional" default="45720"/> + <xsd:attribute name="vert" type="ST_TextVerticalType" use="optional" default="horz"/> + <xsd:attribute name="anchor" type="ST_TextAnchoringType" use="optional" default="t"/> + <xsd:attribute name="anchorCtr" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="horzOverflow" type="ST_TextHorzOverflowType" use="optional" default="clip" + /> + </xsd:complexType> + <xsd:complexType name="CT_Headers"> + <xsd:sequence minOccurs="0" maxOccurs="unbounded"> + <xsd:element name="header" type="xsd:string"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TableCol"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="w" type="ST_Coordinate" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_TableGrid"> + <xsd:sequence> + <xsd:element name="gridCol" type="CT_TableCol" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TableCell"> + <xsd:sequence> + <xsd:element name="txBody" type="CT_TextBody" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tcPr" type="CT_TableCellProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="rowSpan" type="xsd:int" use="optional" default="1"/> + <xsd:attribute name="gridSpan" type="xsd:int" use="optional" default="1"/> + <xsd:attribute name="hMerge" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="vMerge" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="id" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_TableRow"> + <xsd:sequence> + <xsd:element name="tc" type="CT_TableCell" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="h" type="ST_Coordinate" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_TableProperties"> + <xsd:sequence> + <xsd:group ref="EG_FillProperties" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_EffectProperties" minOccurs="0" maxOccurs="1"/> + <xsd:choice minOccurs="0" maxOccurs="1"> + <xsd:element name="tableStyle" type="CT_TableStyle"/> + <xsd:element name="tableStyleId" type="s:ST_Guid"/> + </xsd:choice> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="rtl" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="firstRow" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="firstCol" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="lastRow" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="lastCol" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="bandRow" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="bandCol" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_Table"> + <xsd:sequence> + <xsd:element name="tblPr" type="CT_TableProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tblGrid" type="CT_TableGrid" minOccurs="1" maxOccurs="1"/> + <xsd:element name="tr" type="CT_TableRow" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="tbl" type="CT_Table"/> + <xsd:complexType name="CT_Cell3D"> + <xsd:sequence> + <xsd:element name="bevel" type="CT_Bevel" minOccurs="1" maxOccurs="1"/> + <xsd:element name="lightRig" type="CT_LightRig" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="prstMaterial" type="ST_PresetMaterialType" use="optional" default="plastic" + /> + </xsd:complexType> + <xsd:group name="EG_ThemeableFillStyle"> + <xsd:choice> + <xsd:element name="fill" type="CT_FillProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="fillRef" type="CT_StyleMatrixReference" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_ThemeableLineStyle"> + <xsd:choice> + <xsd:element name="ln" type="CT_LineProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="lnRef" type="CT_StyleMatrixReference" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:complexType> + <xsd:group name="EG_ThemeableEffectStyle"> + <xsd:choice> + <xsd:element name="effect" type="CT_EffectProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="effectRef" type="CT_StyleMatrixReference" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:group> + <xsd:group name="EG_ThemeableFontStyles"> + <xsd:choice> + <xsd:element name="font" type="CT_FontCollection" minOccurs="1" maxOccurs="1"/> + <xsd:element name="fontRef" type="CT_FontReference" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:group> + <xsd:simpleType name="ST_OnOffStyleType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="on"/> + <xsd:enumeration value="off"/> + <xsd:enumeration value="def"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TableStyleTextStyle"> + <xsd:sequence> + <xsd:group ref="EG_ThemeableFontStyles" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_ColorChoice" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="b" type="ST_OnOffStyleType" use="optional" default="def"/> + <xsd:attribute name="i" type="ST_OnOffStyleType" use="optional" default="def"/> + </xsd:complexType> + <xsd:complexType name="CT_TableCellBorderStyle"> + <xsd:sequence> + <xsd:element name="left" type="CT_ThemeableLineStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="right" type="CT_ThemeableLineStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="top" type="CT_ThemeableLineStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="bottom" type="CT_ThemeableLineStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="insideH" type="CT_ThemeableLineStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="insideV" type="CT_ThemeableLineStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tl2br" type="CT_ThemeableLineStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tr2bl" type="CT_ThemeableLineStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TableBackgroundStyle"> + <xsd:sequence> + <xsd:group ref="EG_ThemeableFillStyle" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_ThemeableEffectStyle" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TableStyleCellStyle"> + <xsd:sequence> + <xsd:element name="tcBdr" type="CT_TableCellBorderStyle" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_ThemeableFillStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="cell3D" type="CT_Cell3D" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TablePartStyle"> + <xsd:sequence> + <xsd:element name="tcTxStyle" type="CT_TableStyleTextStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tcStyle" type="CT_TableStyleCellStyle" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TableStyle"> + <xsd:sequence> + <xsd:element name="tblBg" type="CT_TableBackgroundStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="wholeTbl" type="CT_TablePartStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="band1H" type="CT_TablePartStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="band2H" type="CT_TablePartStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="band1V" type="CT_TablePartStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="band2V" type="CT_TablePartStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="lastCol" type="CT_TablePartStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="firstCol" type="CT_TablePartStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="lastRow" type="CT_TablePartStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="seCell" type="CT_TablePartStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="swCell" type="CT_TablePartStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="firstRow" type="CT_TablePartStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="neCell" type="CT_TablePartStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="nwCell" type="CT_TablePartStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="styleId" type="s:ST_Guid" use="required"/> + <xsd:attribute name="styleName" type="xsd:string" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_TableStyleList"> + <xsd:sequence> + <xsd:element name="tblStyle" type="CT_TableStyle" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="def" type="s:ST_Guid" use="required"/> + </xsd:complexType> + <xsd:element name="tblStyleLst" type="CT_TableStyleList"/> + <xsd:complexType name="CT_TextParagraph"> + <xsd:sequence> + <xsd:element name="pPr" type="CT_TextParagraphProperties" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_TextRun" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="endParaRPr" type="CT_TextCharacterProperties" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_TextAnchoringType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="t"/> + <xsd:enumeration value="ctr"/> + <xsd:enumeration value="b"/> + <xsd:enumeration value="just"/> + <xsd:enumeration value="dist"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TextVertOverflowType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="overflow"/> + <xsd:enumeration value="ellipsis"/> + <xsd:enumeration value="clip"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TextHorzOverflowType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="overflow"/> + <xsd:enumeration value="clip"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TextVerticalType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="horz"/> + <xsd:enumeration value="vert"/> + <xsd:enumeration value="vert270"/> + <xsd:enumeration value="wordArtVert"/> + <xsd:enumeration value="eaVert"/> + <xsd:enumeration value="mongolianVert"/> + <xsd:enumeration value="wordArtVertRtl"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TextWrappingType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="square"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TextColumnCount"> + <xsd:restriction base="xsd:int"> + <xsd:minInclusive value="1"/> + <xsd:maxInclusive value="16"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TextListStyle"> + <xsd:sequence> + <xsd:element name="defPPr" type="CT_TextParagraphProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="lvl1pPr" type="CT_TextParagraphProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="lvl2pPr" type="CT_TextParagraphProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="lvl3pPr" type="CT_TextParagraphProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="lvl4pPr" type="CT_TextParagraphProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="lvl5pPr" type="CT_TextParagraphProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="lvl6pPr" type="CT_TextParagraphProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="lvl7pPr" type="CT_TextParagraphProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="lvl8pPr" type="CT_TextParagraphProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="lvl9pPr" type="CT_TextParagraphProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_TextFontScalePercentOrPercentString"> + <xsd:union memberTypes="ST_TextFontScalePercent s:ST_Percentage"/> + </xsd:simpleType> + <xsd:simpleType name="ST_TextFontScalePercent"> + <xsd:restriction base="ST_PercentageDecimal"> + <xsd:minInclusive value="1000"/> + <xsd:maxInclusive value="100000"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TextNormalAutofit"> + <xsd:attribute name="fontScale" type="ST_TextFontScalePercentOrPercentString" use="optional" + default="100%"/> + <xsd:attribute name="lnSpcReduction" type="ST_TextSpacingPercentOrPercentString" use="optional" + default="0%"/> + </xsd:complexType> + <xsd:complexType name="CT_TextShapeAutofit"/> + <xsd:complexType name="CT_TextNoAutofit"/> + <xsd:group name="EG_TextAutofit"> + <xsd:choice> + <xsd:element name="noAutofit" type="CT_TextNoAutofit"/> + <xsd:element name="normAutofit" type="CT_TextNormalAutofit"/> + <xsd:element name="spAutoFit" type="CT_TextShapeAutofit"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_TextBodyProperties"> + <xsd:sequence> + <xsd:element name="prstTxWarp" type="CT_PresetTextShape" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_TextAutofit" minOccurs="0" maxOccurs="1"/> + <xsd:element name="scene3d" type="CT_Scene3D" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_Text3D" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="rot" type="ST_Angle" use="optional"/> + <xsd:attribute name="spcFirstLastPara" type="xsd:boolean" use="optional"/> + <xsd:attribute name="vertOverflow" type="ST_TextVertOverflowType" use="optional"/> + <xsd:attribute name="horzOverflow" type="ST_TextHorzOverflowType" use="optional"/> + <xsd:attribute name="vert" type="ST_TextVerticalType" use="optional"/> + <xsd:attribute name="wrap" type="ST_TextWrappingType" use="optional"/> + <xsd:attribute name="lIns" type="ST_Coordinate32" use="optional"/> + <xsd:attribute name="tIns" type="ST_Coordinate32" use="optional"/> + <xsd:attribute name="rIns" type="ST_Coordinate32" use="optional"/> + <xsd:attribute name="bIns" type="ST_Coordinate32" use="optional"/> + <xsd:attribute name="numCol" type="ST_TextColumnCount" use="optional"/> + <xsd:attribute name="spcCol" type="ST_PositiveCoordinate32" use="optional"/> + <xsd:attribute name="rtlCol" type="xsd:boolean" use="optional"/> + <xsd:attribute name="fromWordArt" type="xsd:boolean" use="optional"/> + <xsd:attribute name="anchor" type="ST_TextAnchoringType" use="optional"/> + <xsd:attribute name="anchorCtr" type="xsd:boolean" use="optional"/> + <xsd:attribute name="forceAA" type="xsd:boolean" use="optional"/> + <xsd:attribute name="upright" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="compatLnSpc" type="xsd:boolean" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_TextBody"> + <xsd:sequence> + <xsd:element name="bodyPr" type="CT_TextBodyProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="lstStyle" type="CT_TextListStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="p" type="CT_TextParagraph" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_TextBulletStartAtNum"> + <xsd:restriction base="xsd:int"> + <xsd:minInclusive value="1"/> + <xsd:maxInclusive value="32767"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TextAutonumberScheme"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="alphaLcParenBoth"/> + <xsd:enumeration value="alphaUcParenBoth"/> + <xsd:enumeration value="alphaLcParenR"/> + <xsd:enumeration value="alphaUcParenR"/> + <xsd:enumeration value="alphaLcPeriod"/> + <xsd:enumeration value="alphaUcPeriod"/> + <xsd:enumeration value="arabicParenBoth"/> + <xsd:enumeration value="arabicParenR"/> + <xsd:enumeration value="arabicPeriod"/> + <xsd:enumeration value="arabicPlain"/> + <xsd:enumeration value="romanLcParenBoth"/> + <xsd:enumeration value="romanUcParenBoth"/> + <xsd:enumeration value="romanLcParenR"/> + <xsd:enumeration value="romanUcParenR"/> + <xsd:enumeration value="romanLcPeriod"/> + <xsd:enumeration value="romanUcPeriod"/> + <xsd:enumeration value="circleNumDbPlain"/> + <xsd:enumeration value="circleNumWdBlackPlain"/> + <xsd:enumeration value="circleNumWdWhitePlain"/> + <xsd:enumeration value="arabicDbPeriod"/> + <xsd:enumeration value="arabicDbPlain"/> + <xsd:enumeration value="ea1ChsPeriod"/> + <xsd:enumeration value="ea1ChsPlain"/> + <xsd:enumeration value="ea1ChtPeriod"/> + <xsd:enumeration value="ea1ChtPlain"/> + <xsd:enumeration value="ea1JpnChsDbPeriod"/> + <xsd:enumeration value="ea1JpnKorPlain"/> + <xsd:enumeration value="ea1JpnKorPeriod"/> + <xsd:enumeration value="arabic1Minus"/> + <xsd:enumeration value="arabic2Minus"/> + <xsd:enumeration value="hebrew2Minus"/> + <xsd:enumeration value="thaiAlphaPeriod"/> + <xsd:enumeration value="thaiAlphaParenR"/> + <xsd:enumeration value="thaiAlphaParenBoth"/> + <xsd:enumeration value="thaiNumPeriod"/> + <xsd:enumeration value="thaiNumParenR"/> + <xsd:enumeration value="thaiNumParenBoth"/> + <xsd:enumeration value="hindiAlphaPeriod"/> + <xsd:enumeration value="hindiNumPeriod"/> + <xsd:enumeration value="hindiNumParenR"/> + <xsd:enumeration value="hindiAlpha1Period"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TextBulletColorFollowText"/> + <xsd:group name="EG_TextBulletColor"> + <xsd:choice> + <xsd:element name="buClrTx" type="CT_TextBulletColorFollowText" minOccurs="1" maxOccurs="1"/> + <xsd:element name="buClr" type="CT_Color" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:group> + <xsd:simpleType name="ST_TextBulletSize"> + <xsd:union memberTypes="ST_TextBulletSizePercent ST_TextBulletSizeDecimal"/> + </xsd:simpleType> + <xsd:simpleType name="ST_TextBulletSizePercent"> + <xsd:restriction base="xsd:string"> + <xsd:pattern value="0*((2[5-9])|([3-9][0-9])|([1-3][0-9][0-9])|400)%"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TextBulletSizeDecimal"> + <xsd:restriction base="ST_PercentageDecimal"> + <xsd:minInclusive value="25000"/> + <xsd:maxInclusive value="400000"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TextBulletSizeFollowText"/> + <xsd:complexType name="CT_TextBulletSizePercent"> + <xsd:attribute name="val" type="ST_TextBulletSizePercent" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_TextBulletSizePoint"> + <xsd:attribute name="val" type="ST_TextFontSize" use="required"/> + </xsd:complexType> + <xsd:group name="EG_TextBulletSize"> + <xsd:choice> + <xsd:element name="buSzTx" type="CT_TextBulletSizeFollowText"/> + <xsd:element name="buSzPct" type="CT_TextBulletSizePercent"/> + <xsd:element name="buSzPts" type="CT_TextBulletSizePoint"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_TextBulletTypefaceFollowText"/> + <xsd:group name="EG_TextBulletTypeface"> + <xsd:choice> + <xsd:element name="buFontTx" type="CT_TextBulletTypefaceFollowText"/> + <xsd:element name="buFont" type="CT_TextFont"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_TextAutonumberBullet"> + <xsd:attribute name="type" type="ST_TextAutonumberScheme" use="required"/> + <xsd:attribute name="startAt" type="ST_TextBulletStartAtNum" use="optional" default="1"/> + </xsd:complexType> + <xsd:complexType name="CT_TextCharBullet"> + <xsd:attribute name="char" type="xsd:string" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_TextBlipBullet"> + <xsd:sequence> + <xsd:element name="blip" type="CT_Blip" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TextNoBullet"/> + <xsd:group name="EG_TextBullet"> + <xsd:choice> + <xsd:element name="buNone" type="CT_TextNoBullet"/> + <xsd:element name="buAutoNum" type="CT_TextAutonumberBullet"/> + <xsd:element name="buChar" type="CT_TextCharBullet"/> + <xsd:element name="buBlip" type="CT_TextBlipBullet"/> + </xsd:choice> + </xsd:group> + <xsd:simpleType name="ST_TextPoint"> + <xsd:union memberTypes="ST_TextPointUnqualified s:ST_UniversalMeasure"/> + </xsd:simpleType> + <xsd:simpleType name="ST_TextPointUnqualified"> + <xsd:restriction base="xsd:int"> + <xsd:minInclusive value="-400000"/> + <xsd:maxInclusive value="400000"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TextNonNegativePoint"> + <xsd:restriction base="xsd:int"> + <xsd:minInclusive value="0"/> + <xsd:maxInclusive value="400000"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TextFontSize"> + <xsd:restriction base="xsd:int"> + <xsd:minInclusive value="100"/> + <xsd:maxInclusive value="400000"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TextTypeface"> + <xsd:restriction base="xsd:string"/> + </xsd:simpleType> + <xsd:simpleType name="ST_PitchFamily"> + <xsd:restriction base="xsd:byte"> + <xsd:enumeration value="00"/> + <xsd:enumeration value="01"/> + <xsd:enumeration value="02"/> + <xsd:enumeration value="16"/> + <xsd:enumeration value="17"/> + <xsd:enumeration value="18"/> + <xsd:enumeration value="32"/> + <xsd:enumeration value="33"/> + <xsd:enumeration value="34"/> + <xsd:enumeration value="48"/> + <xsd:enumeration value="49"/> + <xsd:enumeration value="50"/> + <xsd:enumeration value="64"/> + <xsd:enumeration value="65"/> + <xsd:enumeration value="66"/> + <xsd:enumeration value="80"/> + <xsd:enumeration value="81"/> + <xsd:enumeration value="82"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TextFont"> + <xsd:attribute name="typeface" type="ST_TextTypeface" use="required"/> + <xsd:attribute name="panose" type="s:ST_Panose" use="optional"/> + <xsd:attribute name="pitchFamily" type="ST_PitchFamily" use="optional" default="0"/> + <xsd:attribute name="charset" type="xsd:byte" use="optional" default="1"/> + </xsd:complexType> + <xsd:simpleType name="ST_TextUnderlineType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="words"/> + <xsd:enumeration value="sng"/> + <xsd:enumeration value="dbl"/> + <xsd:enumeration value="heavy"/> + <xsd:enumeration value="dotted"/> + <xsd:enumeration value="dottedHeavy"/> + <xsd:enumeration value="dash"/> + <xsd:enumeration value="dashHeavy"/> + <xsd:enumeration value="dashLong"/> + <xsd:enumeration value="dashLongHeavy"/> + <xsd:enumeration value="dotDash"/> + <xsd:enumeration value="dotDashHeavy"/> + <xsd:enumeration value="dotDotDash"/> + <xsd:enumeration value="dotDotDashHeavy"/> + <xsd:enumeration value="wavy"/> + <xsd:enumeration value="wavyHeavy"/> + <xsd:enumeration value="wavyDbl"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TextUnderlineLineFollowText"/> + <xsd:complexType name="CT_TextUnderlineFillFollowText"/> + <xsd:complexType name="CT_TextUnderlineFillGroupWrapper"> + <xsd:group ref="EG_FillProperties" minOccurs="1" maxOccurs="1"/> + </xsd:complexType> + <xsd:group name="EG_TextUnderlineLine"> + <xsd:choice> + <xsd:element name="uLnTx" type="CT_TextUnderlineLineFollowText"/> + <xsd:element name="uLn" type="CT_LineProperties" minOccurs="0" maxOccurs="1"/> + </xsd:choice> + </xsd:group> + <xsd:group name="EG_TextUnderlineFill"> + <xsd:choice> + <xsd:element name="uFillTx" type="CT_TextUnderlineFillFollowText"/> + <xsd:element name="uFill" type="CT_TextUnderlineFillGroupWrapper"/> + </xsd:choice> + </xsd:group> + <xsd:simpleType name="ST_TextStrikeType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="noStrike"/> + <xsd:enumeration value="sngStrike"/> + <xsd:enumeration value="dblStrike"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TextCapsType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="small"/> + <xsd:enumeration value="all"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TextCharacterProperties"> + <xsd:sequence> + <xsd:element name="ln" type="CT_LineProperties" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_FillProperties" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_EffectProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="highlight" type="CT_Color" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_TextUnderlineLine" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_TextUnderlineFill" minOccurs="0" maxOccurs="1"/> + <xsd:element name="latin" type="CT_TextFont" minOccurs="0" maxOccurs="1"/> + <xsd:element name="ea" type="CT_TextFont" minOccurs="0" maxOccurs="1"/> + <xsd:element name="cs" type="CT_TextFont" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sym" type="CT_TextFont" minOccurs="0" maxOccurs="1"/> + <xsd:element name="hlinkClick" type="CT_Hyperlink" minOccurs="0" maxOccurs="1"/> + <xsd:element name="hlinkMouseOver" type="CT_Hyperlink" minOccurs="0" maxOccurs="1"/> + <xsd:element name="rtl" type="CT_Boolean" minOccurs="0"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="kumimoji" type="xsd:boolean" use="optional"/> + <xsd:attribute name="lang" type="s:ST_Lang" use="optional"/> + <xsd:attribute name="altLang" type="s:ST_Lang" use="optional"/> + <xsd:attribute name="sz" type="ST_TextFontSize" use="optional"/> + <xsd:attribute name="b" type="xsd:boolean" use="optional"/> + <xsd:attribute name="i" type="xsd:boolean" use="optional"/> + <xsd:attribute name="u" type="ST_TextUnderlineType" use="optional"/> + <xsd:attribute name="strike" type="ST_TextStrikeType" use="optional"/> + <xsd:attribute name="kern" type="ST_TextNonNegativePoint" use="optional"/> + <xsd:attribute name="cap" type="ST_TextCapsType" use="optional" default="none"/> + <xsd:attribute name="spc" type="ST_TextPoint" use="optional"/> + <xsd:attribute name="normalizeH" type="xsd:boolean" use="optional"/> + <xsd:attribute name="baseline" type="ST_Percentage" use="optional"/> + <xsd:attribute name="noProof" type="xsd:boolean" use="optional"/> + <xsd:attribute name="dirty" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="err" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="smtClean" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="smtId" type="xsd:unsignedInt" use="optional" default="0"/> + <xsd:attribute name="bmk" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Boolean"> + <xsd:attribute name="val" type="s:ST_OnOff" default="0"/> + </xsd:complexType> + <xsd:simpleType name="ST_TextSpacingPoint"> + <xsd:restriction base="xsd:int"> + <xsd:minInclusive value="0"/> + <xsd:maxInclusive value="158400"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TextSpacingPercentOrPercentString"> + <xsd:union memberTypes="ST_TextSpacingPercent s:ST_Percentage"/> + </xsd:simpleType> + <xsd:simpleType name="ST_TextSpacingPercent"> + <xsd:restriction base="ST_PercentageDecimal"> + <xsd:minInclusive value="0"/> + <xsd:maxInclusive value="13200000"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TextSpacingPercent"> + <xsd:attribute name="val" type="ST_TextSpacingPercentOrPercentString" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_TextSpacingPoint"> + <xsd:attribute name="val" type="ST_TextSpacingPoint" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_TextMargin"> + <xsd:restriction base="ST_Coordinate32Unqualified"> + <xsd:minInclusive value="0"/> + <xsd:maxInclusive value="51206400"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TextIndent"> + <xsd:restriction base="ST_Coordinate32Unqualified"> + <xsd:minInclusive value="-51206400"/> + <xsd:maxInclusive value="51206400"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TextTabAlignType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="l"/> + <xsd:enumeration value="ctr"/> + <xsd:enumeration value="r"/> + <xsd:enumeration value="dec"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TextTabStop"> + <xsd:attribute name="pos" type="ST_Coordinate32" use="optional"/> + <xsd:attribute name="algn" type="ST_TextTabAlignType" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_TextTabStopList"> + <xsd:sequence> + <xsd:element name="tab" type="CT_TextTabStop" minOccurs="0" maxOccurs="32"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TextLineBreak"> + <xsd:sequence> + <xsd:element name="rPr" type="CT_TextCharacterProperties" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TextSpacing"> + <xsd:choice> + <xsd:element name="spcPct" type="CT_TextSpacingPercent"/> + <xsd:element name="spcPts" type="CT_TextSpacingPoint"/> + </xsd:choice> + </xsd:complexType> + <xsd:simpleType name="ST_TextAlignType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="l"/> + <xsd:enumeration value="ctr"/> + <xsd:enumeration value="r"/> + <xsd:enumeration value="just"/> + <xsd:enumeration value="justLow"/> + <xsd:enumeration value="dist"/> + <xsd:enumeration value="thaiDist"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TextFontAlignType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="auto"/> + <xsd:enumeration value="t"/> + <xsd:enumeration value="ctr"/> + <xsd:enumeration value="base"/> + <xsd:enumeration value="b"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TextIndentLevelType"> + <xsd:restriction base="xsd:int"> + <xsd:minInclusive value="0"/> + <xsd:maxInclusive value="8"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TextParagraphProperties"> + <xsd:sequence> + <xsd:element name="lnSpc" type="CT_TextSpacing" minOccurs="0" maxOccurs="1"/> + <xsd:element name="spcBef" type="CT_TextSpacing" minOccurs="0" maxOccurs="1"/> + <xsd:element name="spcAft" type="CT_TextSpacing" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_TextBulletColor" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_TextBulletSize" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_TextBulletTypeface" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_TextBullet" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tabLst" type="CT_TextTabStopList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="defRPr" type="CT_TextCharacterProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="marL" type="ST_TextMargin" use="optional"/> + <xsd:attribute name="marR" type="ST_TextMargin" use="optional"/> + <xsd:attribute name="lvl" type="ST_TextIndentLevelType" use="optional"/> + <xsd:attribute name="indent" type="ST_TextIndent" use="optional"/> + <xsd:attribute name="algn" type="ST_TextAlignType" use="optional"/> + <xsd:attribute name="defTabSz" type="ST_Coordinate32" use="optional"/> + <xsd:attribute name="rtl" type="xsd:boolean" use="optional"/> + <xsd:attribute name="eaLnBrk" type="xsd:boolean" use="optional"/> + <xsd:attribute name="fontAlgn" type="ST_TextFontAlignType" use="optional"/> + <xsd:attribute name="latinLnBrk" type="xsd:boolean" use="optional"/> + <xsd:attribute name="hangingPunct" type="xsd:boolean" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_TextField"> + <xsd:sequence> + <xsd:element name="rPr" type="CT_TextCharacterProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="pPr" type="CT_TextParagraphProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="t" type="xsd:string" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="id" type="s:ST_Guid" use="required"/> + <xsd:attribute name="type" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:group name="EG_TextRun"> + <xsd:choice> + <xsd:element name="r" type="CT_RegularTextRun"/> + <xsd:element name="br" type="CT_TextLineBreak"/> + <xsd:element name="fld" type="CT_TextField"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_RegularTextRun"> + <xsd:sequence> + <xsd:element name="rPr" type="CT_TextCharacterProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="t" type="xsd:string" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/dml-picture.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/dml-picture.xsd new file mode 100644 index 00000000..1dbf0514 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/dml-picture.xsd @@ -0,0 +1,23 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" + xmlns="http://schemas.openxmlformats.org/drawingml/2006/picture" + xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" elementFormDefault="qualified" + targetNamespace="http://schemas.openxmlformats.org/drawingml/2006/picture"> + <xsd:import namespace="http://schemas.openxmlformats.org/drawingml/2006/main" + schemaLocation="dml-main.xsd"/> + <xsd:complexType name="CT_PictureNonVisual"> + <xsd:sequence> + <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cNvPicPr" type="a:CT_NonVisualPictureProperties" minOccurs="1" + maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Picture"> + <xsd:sequence minOccurs="1" maxOccurs="1"> + <xsd:element name="nvPicPr" type="CT_PictureNonVisual" minOccurs="1" maxOccurs="1"/> + <xsd:element name="blipFill" type="a:CT_BlipFillProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="pic" type="CT_Picture"/> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/dml-spreadsheetDrawing.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/dml-spreadsheetDrawing.xsd new file mode 100644 index 00000000..f1af17db --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/dml-spreadsheetDrawing.xsd @@ -0,0 +1,185 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" + xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" + xmlns="http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing" + xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" + targetNamespace="http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing" + elementFormDefault="qualified"> + <xsd:import namespace="http://schemas.openxmlformats.org/drawingml/2006/main" + schemaLocation="dml-main.xsd"/> + <xsd:import schemaLocation="shared-relationshipReference.xsd" + namespace="http://schemas.openxmlformats.org/officeDocument/2006/relationships"/> + <xsd:element name="from" type="CT_Marker"/> + <xsd:element name="to" type="CT_Marker"/> + <xsd:complexType name="CT_AnchorClientData"> + <xsd:attribute name="fLocksWithSheet" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="fPrintsWithSheet" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_ShapeNonVisual"> + <xsd:sequence> + <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cNvSpPr" type="a:CT_NonVisualDrawingShapeProps" minOccurs="1" maxOccurs="1" + /> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Shape"> + <xsd:sequence> + <xsd:element name="nvSpPr" type="CT_ShapeNonVisual" minOccurs="1" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="style" type="a:CT_ShapeStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="txBody" type="a:CT_TextBody" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="macro" type="xsd:string" use="optional"/> + <xsd:attribute name="textlink" type="xsd:string" use="optional"/> + <xsd:attribute name="fLocksText" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="fPublished" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_ConnectorNonVisual"> + <xsd:sequence> + <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cNvCxnSpPr" type="a:CT_NonVisualConnectorProperties" minOccurs="1" + maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Connector"> + <xsd:sequence> + <xsd:element name="nvCxnSpPr" type="CT_ConnectorNonVisual" minOccurs="1" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="style" type="a:CT_ShapeStyle" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="macro" type="xsd:string" use="optional"/> + <xsd:attribute name="fPublished" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_PictureNonVisual"> + <xsd:sequence> + <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cNvPicPr" type="a:CT_NonVisualPictureProperties" minOccurs="1" + maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Picture"> + <xsd:sequence> + <xsd:element name="nvPicPr" type="CT_PictureNonVisual" minOccurs="1" maxOccurs="1"/> + <xsd:element name="blipFill" type="a:CT_BlipFillProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="style" type="a:CT_ShapeStyle" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="macro" type="xsd:string" use="optional" default=""/> + <xsd:attribute name="fPublished" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_GraphicalObjectFrameNonVisual"> + <xsd:sequence> + <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cNvGraphicFramePr" type="a:CT_NonVisualGraphicFrameProperties" + minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_GraphicalObjectFrame"> + <xsd:sequence> + <xsd:element name="nvGraphicFramePr" type="CT_GraphicalObjectFrameNonVisual" minOccurs="1" + maxOccurs="1"/> + <xsd:element name="xfrm" type="a:CT_Transform2D" minOccurs="1" maxOccurs="1"/> + <xsd:element ref="a:graphic" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="macro" type="xsd:string" use="optional"/> + <xsd:attribute name="fPublished" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_GroupShapeNonVisual"> + <xsd:sequence> + <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cNvGrpSpPr" type="a:CT_NonVisualGroupDrawingShapeProps" minOccurs="1" + maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_GroupShape"> + <xsd:sequence> + <xsd:element name="nvGrpSpPr" type="CT_GroupShapeNonVisual" minOccurs="1" maxOccurs="1"/> + <xsd:element name="grpSpPr" type="a:CT_GroupShapeProperties" minOccurs="1" maxOccurs="1"/> + <xsd:choice minOccurs="0" maxOccurs="unbounded"> + <xsd:element name="sp" type="CT_Shape"/> + <xsd:element name="grpSp" type="CT_GroupShape"/> + <xsd:element name="graphicFrame" type="CT_GraphicalObjectFrame"/> + <xsd:element name="cxnSp" type="CT_Connector"/> + <xsd:element name="pic" type="CT_Picture"/> + </xsd:choice> + </xsd:sequence> + </xsd:complexType> + <xsd:group name="EG_ObjectChoices"> + <xsd:sequence> + <xsd:choice minOccurs="1" maxOccurs="1"> + <xsd:element name="sp" type="CT_Shape"/> + <xsd:element name="grpSp" type="CT_GroupShape"/> + <xsd:element name="graphicFrame" type="CT_GraphicalObjectFrame"/> + <xsd:element name="cxnSp" type="CT_Connector"/> + <xsd:element name="pic" type="CT_Picture"/> + <xsd:element name="contentPart" type="CT_Rel"/> + </xsd:choice> + </xsd:sequence> + </xsd:group> + <xsd:complexType name="CT_Rel"> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_ColID"> + <xsd:restriction base="xsd:int"> + <xsd:minInclusive value="0"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_RowID"> + <xsd:restriction base="xsd:int"> + <xsd:minInclusive value="0"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Marker"> + <xsd:sequence> + <xsd:element name="col" type="ST_ColID"/> + <xsd:element name="colOff" type="a:ST_Coordinate"/> + <xsd:element name="row" type="ST_RowID"/> + <xsd:element name="rowOff" type="a:ST_Coordinate"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_EditAs"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="twoCell"/> + <xsd:enumeration value="oneCell"/> + <xsd:enumeration value="absolute"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TwoCellAnchor"> + <xsd:sequence> + <xsd:element name="from" type="CT_Marker"/> + <xsd:element name="to" type="CT_Marker"/> + <xsd:group ref="EG_ObjectChoices"/> + <xsd:element name="clientData" type="CT_AnchorClientData" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="editAs" type="ST_EditAs" use="optional" default="twoCell"/> + </xsd:complexType> + <xsd:complexType name="CT_OneCellAnchor"> + <xsd:sequence> + <xsd:element name="from" type="CT_Marker"/> + <xsd:element name="ext" type="a:CT_PositiveSize2D"/> + <xsd:group ref="EG_ObjectChoices"/> + <xsd:element name="clientData" type="CT_AnchorClientData" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_AbsoluteAnchor"> + <xsd:sequence> + <xsd:element name="pos" type="a:CT_Point2D"/> + <xsd:element name="ext" type="a:CT_PositiveSize2D"/> + <xsd:group ref="EG_ObjectChoices"/> + <xsd:element name="clientData" type="CT_AnchorClientData" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:group name="EG_Anchor"> + <xsd:choice> + <xsd:element name="twoCellAnchor" type="CT_TwoCellAnchor"/> + <xsd:element name="oneCellAnchor" type="CT_OneCellAnchor"/> + <xsd:element name="absoluteAnchor" type="CT_AbsoluteAnchor"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_Drawing"> + <xsd:sequence> + <xsd:group ref="EG_Anchor" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="wsDr" type="CT_Drawing"/> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/dml-wordprocessingDrawing.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/dml-wordprocessingDrawing.xsd new file mode 100644 index 00000000..0a185ab6 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/dml-wordprocessingDrawing.xsd @@ -0,0 +1,287 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" + xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" + xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" + xmlns:dpct="http://schemas.openxmlformats.org/drawingml/2006/picture" + xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" + xmlns="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" + targetNamespace="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" + elementFormDefault="qualified"> + <xsd:import namespace="http://schemas.openxmlformats.org/drawingml/2006/main" + schemaLocation="dml-main.xsd"/> + <xsd:import schemaLocation="wml.xsd" + namespace="http://schemas.openxmlformats.org/wordprocessingml/2006/main"/> + <xsd:import namespace="http://schemas.openxmlformats.org/drawingml/2006/picture" + schemaLocation="dml-picture.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/relationships" + schemaLocation="shared-relationshipReference.xsd"/> + <xsd:complexType name="CT_EffectExtent"> + <xsd:attribute name="l" type="a:ST_Coordinate" use="required"/> + <xsd:attribute name="t" type="a:ST_Coordinate" use="required"/> + <xsd:attribute name="r" type="a:ST_Coordinate" use="required"/> + <xsd:attribute name="b" type="a:ST_Coordinate" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_WrapDistance"> + <xsd:restriction base="xsd:unsignedInt"/> + </xsd:simpleType> + <xsd:complexType name="CT_Inline"> + <xsd:sequence> + <xsd:element name="extent" type="a:CT_PositiveSize2D"/> + <xsd:element name="effectExtent" type="CT_EffectExtent" minOccurs="0"/> + <xsd:element name="docPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cNvGraphicFramePr" type="a:CT_NonVisualGraphicFrameProperties" + minOccurs="0" maxOccurs="1"/> + <xsd:element ref="a:graphic" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="distT" type="ST_WrapDistance" use="optional"/> + <xsd:attribute name="distB" type="ST_WrapDistance" use="optional"/> + <xsd:attribute name="distL" type="ST_WrapDistance" use="optional"/> + <xsd:attribute name="distR" type="ST_WrapDistance" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_WrapText"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="bothSides"/> + <xsd:enumeration value="left"/> + <xsd:enumeration value="right"/> + <xsd:enumeration value="largest"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_WrapPath"> + <xsd:sequence> + <xsd:element name="start" type="a:CT_Point2D" minOccurs="1" maxOccurs="1"/> + <xsd:element name="lineTo" type="a:CT_Point2D" minOccurs="2" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="edited" type="xsd:boolean" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_WrapNone"/> + <xsd:complexType name="CT_WrapSquare"> + <xsd:sequence> + <xsd:element name="effectExtent" type="CT_EffectExtent" minOccurs="0"/> + </xsd:sequence> + <xsd:attribute name="wrapText" type="ST_WrapText" use="required"/> + <xsd:attribute name="distT" type="ST_WrapDistance" use="optional"/> + <xsd:attribute name="distB" type="ST_WrapDistance" use="optional"/> + <xsd:attribute name="distL" type="ST_WrapDistance" use="optional"/> + <xsd:attribute name="distR" type="ST_WrapDistance" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_WrapTight"> + <xsd:sequence> + <xsd:element name="wrapPolygon" type="CT_WrapPath" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="wrapText" type="ST_WrapText" use="required"/> + <xsd:attribute name="distL" type="ST_WrapDistance" use="optional"/> + <xsd:attribute name="distR" type="ST_WrapDistance" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_WrapThrough"> + <xsd:sequence> + <xsd:element name="wrapPolygon" type="CT_WrapPath" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="wrapText" type="ST_WrapText" use="required"/> + <xsd:attribute name="distL" type="ST_WrapDistance" use="optional"/> + <xsd:attribute name="distR" type="ST_WrapDistance" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_WrapTopBottom"> + <xsd:sequence> + <xsd:element name="effectExtent" type="CT_EffectExtent" minOccurs="0"/> + </xsd:sequence> + <xsd:attribute name="distT" type="ST_WrapDistance" use="optional"/> + <xsd:attribute name="distB" type="ST_WrapDistance" use="optional"/> + </xsd:complexType> + <xsd:group name="EG_WrapType"> + <xsd:sequence> + <xsd:choice minOccurs="1" maxOccurs="1"> + <xsd:element name="wrapNone" type="CT_WrapNone" minOccurs="1" maxOccurs="1"/> + <xsd:element name="wrapSquare" type="CT_WrapSquare" minOccurs="1" maxOccurs="1"/> + <xsd:element name="wrapTight" type="CT_WrapTight" minOccurs="1" maxOccurs="1"/> + <xsd:element name="wrapThrough" type="CT_WrapThrough" minOccurs="1" maxOccurs="1"/> + <xsd:element name="wrapTopAndBottom" type="CT_WrapTopBottom" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:sequence> + </xsd:group> + <xsd:simpleType name="ST_PositionOffset"> + <xsd:restriction base="xsd:int"/> + </xsd:simpleType> + <xsd:simpleType name="ST_AlignH"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="left"/> + <xsd:enumeration value="right"/> + <xsd:enumeration value="center"/> + <xsd:enumeration value="inside"/> + <xsd:enumeration value="outside"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_RelFromH"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="margin"/> + <xsd:enumeration value="page"/> + <xsd:enumeration value="column"/> + <xsd:enumeration value="character"/> + <xsd:enumeration value="leftMargin"/> + <xsd:enumeration value="rightMargin"/> + <xsd:enumeration value="insideMargin"/> + <xsd:enumeration value="outsideMargin"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_PosH"> + <xsd:sequence> + <xsd:choice minOccurs="1" maxOccurs="1"> + <xsd:element name="align" type="ST_AlignH" minOccurs="1" maxOccurs="1"/> + <xsd:element name="posOffset" type="ST_PositionOffset" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:sequence> + <xsd:attribute name="relativeFrom" type="ST_RelFromH" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_AlignV"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="top"/> + <xsd:enumeration value="bottom"/> + <xsd:enumeration value="center"/> + <xsd:enumeration value="inside"/> + <xsd:enumeration value="outside"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_RelFromV"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="margin"/> + <xsd:enumeration value="page"/> + <xsd:enumeration value="paragraph"/> + <xsd:enumeration value="line"/> + <xsd:enumeration value="topMargin"/> + <xsd:enumeration value="bottomMargin"/> + <xsd:enumeration value="insideMargin"/> + <xsd:enumeration value="outsideMargin"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_PosV"> + <xsd:sequence> + <xsd:choice minOccurs="1" maxOccurs="1"> + <xsd:element name="align" type="ST_AlignV" minOccurs="1" maxOccurs="1"/> + <xsd:element name="posOffset" type="ST_PositionOffset" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + </xsd:sequence> + <xsd:attribute name="relativeFrom" type="ST_RelFromV" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Anchor"> + <xsd:sequence> + <xsd:element name="simplePos" type="a:CT_Point2D"/> + <xsd:element name="positionH" type="CT_PosH"/> + <xsd:element name="positionV" type="CT_PosV"/> + <xsd:element name="extent" type="a:CT_PositiveSize2D"/> + <xsd:element name="effectExtent" type="CT_EffectExtent" minOccurs="0"/> + <xsd:group ref="EG_WrapType"/> + <xsd:element name="docPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cNvGraphicFramePr" type="a:CT_NonVisualGraphicFrameProperties" + minOccurs="0" maxOccurs="1"/> + <xsd:element ref="a:graphic" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="distT" type="ST_WrapDistance" use="optional"/> + <xsd:attribute name="distB" type="ST_WrapDistance" use="optional"/> + <xsd:attribute name="distL" type="ST_WrapDistance" use="optional"/> + <xsd:attribute name="distR" type="ST_WrapDistance" use="optional"/> + <xsd:attribute name="simplePos" type="xsd:boolean"/> + <xsd:attribute name="relativeHeight" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="behindDoc" type="xsd:boolean" use="required"/> + <xsd:attribute name="locked" type="xsd:boolean" use="required"/> + <xsd:attribute name="layoutInCell" type="xsd:boolean" use="required"/> + <xsd:attribute name="hidden" type="xsd:boolean" use="optional"/> + <xsd:attribute name="allowOverlap" type="xsd:boolean" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_TxbxContent"> + <xsd:group ref="w:EG_BlockLevelElts" minOccurs="1" maxOccurs="unbounded"/> + </xsd:complexType> + <xsd:complexType name="CT_TextboxInfo"> + <xsd:sequence> + <xsd:element name="txbxContent" type="CT_TxbxContent" minOccurs="1" maxOccurs="1"/> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="id" type="xsd:unsignedShort" use="optional" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_LinkedTextboxInformation"> + <xsd:sequence> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="id" type="xsd:unsignedShort" use="required"/> + <xsd:attribute name="seq" type="xsd:unsignedShort" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_WordprocessingShape"> + <xsd:sequence minOccurs="1" maxOccurs="1"> + <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="0" maxOccurs="1"/> + <xsd:choice minOccurs="1" maxOccurs="1"> + <xsd:element name="cNvSpPr" type="a:CT_NonVisualDrawingShapeProps" minOccurs="1" + maxOccurs="1"/> + <xsd:element name="cNvCnPr" type="a:CT_NonVisualConnectorProperties" minOccurs="1" + maxOccurs="1"/> + </xsd:choice> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="style" type="a:CT_ShapeStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + <xsd:choice minOccurs="0" maxOccurs="1"> + <xsd:element name="txbx" type="CT_TextboxInfo" minOccurs="1" maxOccurs="1"/> + <xsd:element name="linkedTxbx" type="CT_LinkedTextboxInformation" minOccurs="1" + maxOccurs="1"/> + </xsd:choice> + <xsd:element name="bodyPr" type="a:CT_TextBodyProperties" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="normalEastAsianFlow" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_GraphicFrame"> + <xsd:sequence> + <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cNvFrPr" type="a:CT_NonVisualGraphicFrameProperties" minOccurs="1" + maxOccurs="1"/> + <xsd:element name="xfrm" type="a:CT_Transform2D" minOccurs="1" maxOccurs="1"/> + <xsd:element ref="a:graphic" minOccurs="1" maxOccurs="1"/> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_WordprocessingContentPartNonVisual"> + <xsd:sequence> + <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="0" maxOccurs="1"/> + <xsd:element name="cNvContentPartPr" type="a:CT_NonVisualContentPartProperties" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_WordprocessingContentPart"> + <xsd:sequence> + <xsd:element name="nvContentPartPr" type="CT_WordprocessingContentPartNonVisual" minOccurs="0" maxOccurs="1"/> + <xsd:element name="xfrm" type="a:CT_Transform2D" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="bwMode" type="a:ST_BlackWhiteMode" use="optional"/> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_WordprocessingGroup"> + <xsd:sequence minOccurs="1" maxOccurs="1"> + <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="0" maxOccurs="1"/> + <xsd:element name="cNvGrpSpPr" type="a:CT_NonVisualGroupDrawingShapeProps" minOccurs="1" + maxOccurs="1"/> + <xsd:element name="grpSpPr" type="a:CT_GroupShapeProperties" minOccurs="1" maxOccurs="1"/> + <xsd:choice minOccurs="0" maxOccurs="unbounded"> + <xsd:element ref="wsp"/> + <xsd:element name="grpSp" type="CT_WordprocessingGroup"/> + <xsd:element name="graphicFrame" type="CT_GraphicFrame"/> + <xsd:element ref="dpct:pic"/> + <xsd:element name="contentPart" type="CT_WordprocessingContentPart"/> + </xsd:choice> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_WordprocessingCanvas"> + <xsd:sequence minOccurs="1" maxOccurs="1"> + <xsd:element name="bg" type="a:CT_BackgroundFormatting" minOccurs="0" maxOccurs="1"/> + <xsd:element name="whole" type="a:CT_WholeE2oFormatting" minOccurs="0" maxOccurs="1"/> + <xsd:choice minOccurs="0" maxOccurs="unbounded"> + <xsd:element ref="wsp"/> + <xsd:element ref="dpct:pic"/> + <xsd:element name="contentPart" type="CT_WordprocessingContentPart"/> + <xsd:element ref="wgp"/> + <xsd:element name="graphicFrame" type="CT_GraphicFrame"/> + </xsd:choice> + <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="wpc" type="CT_WordprocessingCanvas"/> + <xsd:element name="wgp" type="CT_WordprocessingGroup"/> + <xsd:element name="wsp" type="CT_WordprocessingShape"/> + <xsd:element name="inline" type="CT_Inline"/> + <xsd:element name="anchor" type="CT_Anchor"/> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/pml.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/pml.xsd new file mode 100644 index 00000000..14ef4888 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/pml.xsd @@ -0,0 +1,1676 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" + xmlns="http://schemas.openxmlformats.org/presentationml/2006/main" + xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main" + xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" + xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" + xmlns:s="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + elementFormDefault="qualified" + targetNamespace="http://schemas.openxmlformats.org/presentationml/2006/main"> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/relationships" + schemaLocation="shared-relationshipReference.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/drawingml/2006/main" + schemaLocation="dml-main.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + schemaLocation="shared-commonSimpleTypes.xsd"/> + <xsd:simpleType name="ST_TransitionSideDirectionType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="l"/> + <xsd:enumeration value="u"/> + <xsd:enumeration value="r"/> + <xsd:enumeration value="d"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TransitionCornerDirectionType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="lu"/> + <xsd:enumeration value="ru"/> + <xsd:enumeration value="ld"/> + <xsd:enumeration value="rd"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TransitionInOutDirectionType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="out"/> + <xsd:enumeration value="in"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_SideDirectionTransition"> + <xsd:attribute name="dir" type="ST_TransitionSideDirectionType" use="optional" default="l"/> + </xsd:complexType> + <xsd:complexType name="CT_CornerDirectionTransition"> + <xsd:attribute name="dir" type="ST_TransitionCornerDirectionType" use="optional" default="lu"/> + </xsd:complexType> + <xsd:simpleType name="ST_TransitionEightDirectionType"> + <xsd:union memberTypes="ST_TransitionSideDirectionType ST_TransitionCornerDirectionType"/> + </xsd:simpleType> + <xsd:complexType name="CT_EightDirectionTransition"> + <xsd:attribute name="dir" type="ST_TransitionEightDirectionType" use="optional" default="l"/> + </xsd:complexType> + <xsd:complexType name="CT_OrientationTransition"> + <xsd:attribute name="dir" type="ST_Direction" use="optional" default="horz"/> + </xsd:complexType> + <xsd:complexType name="CT_InOutTransition"> + <xsd:attribute name="dir" type="ST_TransitionInOutDirectionType" use="optional" default="out"/> + </xsd:complexType> + <xsd:complexType name="CT_OptionalBlackTransition"> + <xsd:attribute name="thruBlk" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_SplitTransition"> + <xsd:attribute name="orient" type="ST_Direction" use="optional" default="horz"/> + <xsd:attribute name="dir" type="ST_TransitionInOutDirectionType" use="optional" default="out"/> + </xsd:complexType> + <xsd:complexType name="CT_WheelTransition"> + <xsd:attribute name="spokes" type="xsd:unsignedInt" use="optional" default="4"/> + </xsd:complexType> + <xsd:complexType name="CT_TransitionStartSoundAction"> + <xsd:sequence> + <xsd:element minOccurs="1" maxOccurs="1" name="snd" type="a:CT_EmbeddedWAVAudioFile"/> + </xsd:sequence> + <xsd:attribute name="loop" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_TransitionSoundAction"> + <xsd:choice minOccurs="1" maxOccurs="1"> + <xsd:element name="stSnd" type="CT_TransitionStartSoundAction"/> + <xsd:element name="endSnd" type="CT_Empty"/> + </xsd:choice> + </xsd:complexType> + <xsd:simpleType name="ST_TransitionSpeed"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="slow"/> + <xsd:enumeration value="med"/> + <xsd:enumeration value="fast"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_SlideTransition"> + <xsd:sequence> + <xsd:choice minOccurs="0" maxOccurs="1"> + <xsd:element name="blinds" type="CT_OrientationTransition"/> + <xsd:element name="checker" type="CT_OrientationTransition"/> + <xsd:element name="circle" type="CT_Empty"/> + <xsd:element name="dissolve" type="CT_Empty"/> + <xsd:element name="comb" type="CT_OrientationTransition"/> + <xsd:element name="cover" type="CT_EightDirectionTransition"/> + <xsd:element name="cut" type="CT_OptionalBlackTransition"/> + <xsd:element name="diamond" type="CT_Empty"/> + <xsd:element name="fade" type="CT_OptionalBlackTransition"/> + <xsd:element name="newsflash" type="CT_Empty"/> + <xsd:element name="plus" type="CT_Empty"/> + <xsd:element name="pull" type="CT_EightDirectionTransition"/> + <xsd:element name="push" type="CT_SideDirectionTransition"/> + <xsd:element name="random" type="CT_Empty"/> + <xsd:element name="randomBar" type="CT_OrientationTransition"/> + <xsd:element name="split" type="CT_SplitTransition"/> + <xsd:element name="strips" type="CT_CornerDirectionTransition"/> + <xsd:element name="wedge" type="CT_Empty"/> + <xsd:element name="wheel" type="CT_WheelTransition"/> + <xsd:element name="wipe" type="CT_SideDirectionTransition"/> + <xsd:element name="zoom" type="CT_InOutTransition"/> + </xsd:choice> + <xsd:element name="sndAc" minOccurs="0" maxOccurs="1" type="CT_TransitionSoundAction"/> + <xsd:element name="extLst" type="CT_ExtensionListModify" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="spd" type="ST_TransitionSpeed" use="optional" default="fast"/> + <xsd:attribute name="advClick" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="advTm" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_TLTimeIndefinite"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="indefinite"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TLTime"> + <xsd:union memberTypes="xsd:unsignedInt ST_TLTimeIndefinite"/> + </xsd:simpleType> + <xsd:simpleType name="ST_TLTimeNodeID"> + <xsd:restriction base="xsd:unsignedInt"/> + </xsd:simpleType> + <xsd:complexType name="CT_TLIterateIntervalTime"> + <xsd:attribute name="val" type="ST_TLTime" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_TLIterateIntervalPercentage"> + <xsd:attribute name="val" type="a:ST_PositivePercentage" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_IterateType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="el"/> + <xsd:enumeration value="wd"/> + <xsd:enumeration value="lt"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TLIterateData"> + <xsd:choice minOccurs="1" maxOccurs="1"> + <xsd:element name="tmAbs" type="CT_TLIterateIntervalTime"/> + <xsd:element name="tmPct" type="CT_TLIterateIntervalPercentage"/> + </xsd:choice> + <xsd:attribute name="type" type="ST_IterateType" use="optional" default="el"/> + <xsd:attribute name="backwards" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_TLSubShapeId"> + <xsd:attribute name="spid" type="a:ST_ShapeID" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_TLTextTargetElement"> + <xsd:choice minOccurs="0" maxOccurs="1"> + <xsd:element name="charRg" type="CT_IndexRange"/> + <xsd:element name="pRg" type="CT_IndexRange"/> + </xsd:choice> + </xsd:complexType> + <xsd:simpleType name="ST_TLChartSubelementType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="gridLegend"/> + <xsd:enumeration value="series"/> + <xsd:enumeration value="category"/> + <xsd:enumeration value="ptInSeries"/> + <xsd:enumeration value="ptInCategory"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TLOleChartTargetElement"> + <xsd:attribute name="type" type="ST_TLChartSubelementType" use="required"/> + <xsd:attribute name="lvl" type="xsd:unsignedInt" use="optional" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_TLShapeTargetElement"> + <xsd:choice minOccurs="0" maxOccurs="1"> + <xsd:element name="bg" type="CT_Empty"/> + <xsd:element name="subSp" type="CT_TLSubShapeId"/> + <xsd:element name="oleChartEl" type="CT_TLOleChartTargetElement"/> + <xsd:element name="txEl" type="CT_TLTextTargetElement"/> + <xsd:element name="graphicEl" type="a:CT_AnimationElementChoice"/> + </xsd:choice> + <xsd:attribute name="spid" type="a:ST_DrawingElementId" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_TLTimeTargetElement"> + <xsd:choice minOccurs="1" maxOccurs="1"> + <xsd:element name="sldTgt" type="CT_Empty"/> + <xsd:element name="sndTgt" type="a:CT_EmbeddedWAVAudioFile"/> + <xsd:element name="spTgt" type="CT_TLShapeTargetElement"/> + <xsd:element name="inkTgt" type="CT_TLSubShapeId"/> + </xsd:choice> + </xsd:complexType> + <xsd:complexType name="CT_TLTriggerTimeNodeID"> + <xsd:attribute name="val" type="ST_TLTimeNodeID" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_TLTriggerRuntimeNode"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="first"/> + <xsd:enumeration value="last"/> + <xsd:enumeration value="all"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TLTriggerRuntimeNode"> + <xsd:attribute name="val" type="ST_TLTriggerRuntimeNode" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_TLTriggerEvent"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="onBegin"/> + <xsd:enumeration value="onEnd"/> + <xsd:enumeration value="begin"/> + <xsd:enumeration value="end"/> + <xsd:enumeration value="onClick"/> + <xsd:enumeration value="onDblClick"/> + <xsd:enumeration value="onMouseOver"/> + <xsd:enumeration value="onMouseOut"/> + <xsd:enumeration value="onNext"/> + <xsd:enumeration value="onPrev"/> + <xsd:enumeration value="onStopAudio"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TLTimeCondition"> + <xsd:choice minOccurs="0" maxOccurs="1"> + <xsd:element name="tgtEl" type="CT_TLTimeTargetElement"/> + <xsd:element name="tn" type="CT_TLTriggerTimeNodeID"/> + <xsd:element name="rtn" type="CT_TLTriggerRuntimeNode"/> + </xsd:choice> + <xsd:attribute name="evt" use="optional" type="ST_TLTriggerEvent"/> + <xsd:attribute name="delay" type="ST_TLTime" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_TLTimeConditionList"> + <xsd:sequence> + <xsd:element name="cond" type="CT_TLTimeCondition" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TimeNodeList"> + <xsd:choice minOccurs="1" maxOccurs="unbounded"> + <xsd:element name="par" type="CT_TLTimeNodeParallel"/> + <xsd:element name="seq" type="CT_TLTimeNodeSequence"/> + <xsd:element name="excl" type="CT_TLTimeNodeExclusive"/> + <xsd:element name="anim" type="CT_TLAnimateBehavior"/> + <xsd:element name="animClr" type="CT_TLAnimateColorBehavior"/> + <xsd:element name="animEffect" type="CT_TLAnimateEffectBehavior"/> + <xsd:element name="animMotion" type="CT_TLAnimateMotionBehavior"/> + <xsd:element name="animRot" type="CT_TLAnimateRotationBehavior"/> + <xsd:element name="animScale" type="CT_TLAnimateScaleBehavior"/> + <xsd:element name="cmd" type="CT_TLCommandBehavior"/> + <xsd:element name="set" type="CT_TLSetBehavior"/> + <xsd:element name="audio" type="CT_TLMediaNodeAudio"/> + <xsd:element name="video" type="CT_TLMediaNodeVideo"/> + </xsd:choice> + </xsd:complexType> + <xsd:simpleType name="ST_TLTimeNodePresetClassType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="entr"/> + <xsd:enumeration value="exit"/> + <xsd:enumeration value="emph"/> + <xsd:enumeration value="path"/> + <xsd:enumeration value="verb"/> + <xsd:enumeration value="mediacall"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TLTimeNodeRestartType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="always"/> + <xsd:enumeration value="whenNotActive"/> + <xsd:enumeration value="never"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TLTimeNodeFillType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="remove"/> + <xsd:enumeration value="freeze"/> + <xsd:enumeration value="hold"/> + <xsd:enumeration value="transition"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TLTimeNodeSyncType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="canSlip"/> + <xsd:enumeration value="locked"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TLTimeNodeMasterRelation"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="sameClick"/> + <xsd:enumeration value="lastClick"/> + <xsd:enumeration value="nextClick"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TLTimeNodeType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="clickEffect"/> + <xsd:enumeration value="withEffect"/> + <xsd:enumeration value="afterEffect"/> + <xsd:enumeration value="mainSeq"/> + <xsd:enumeration value="interactiveSeq"/> + <xsd:enumeration value="clickPar"/> + <xsd:enumeration value="withGroup"/> + <xsd:enumeration value="afterGroup"/> + <xsd:enumeration value="tmRoot"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TLCommonTimeNodeData"> + <xsd:sequence> + <xsd:element name="stCondLst" type="CT_TLTimeConditionList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="endCondLst" type="CT_TLTimeConditionList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="endSync" type="CT_TLTimeCondition" minOccurs="0" maxOccurs="1"/> + <xsd:element name="iterate" type="CT_TLIterateData" minOccurs="0" maxOccurs="1"/> + <xsd:element name="childTnLst" type="CT_TimeNodeList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="subTnLst" type="CT_TimeNodeList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="id" type="ST_TLTimeNodeID" use="optional"/> + <xsd:attribute name="presetID" type="xsd:int" use="optional"/> + <xsd:attribute name="presetClass" type="ST_TLTimeNodePresetClassType" use="optional"/> + <xsd:attribute name="presetSubtype" type="xsd:int" use="optional"/> + <xsd:attribute name="dur" type="ST_TLTime" use="optional"/> + <xsd:attribute name="repeatCount" type="ST_TLTime" use="optional" default="1000"/> + <xsd:attribute name="repeatDur" type="ST_TLTime" use="optional"/> + <xsd:attribute name="spd" type="a:ST_Percentage" use="optional" default="100%"/> + <xsd:attribute name="accel" type="a:ST_PositiveFixedPercentage" use="optional" default="0%"/> + <xsd:attribute name="decel" type="a:ST_PositiveFixedPercentage" use="optional" default="0%"/> + <xsd:attribute name="autoRev" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="restart" type="ST_TLTimeNodeRestartType" use="optional"/> + <xsd:attribute name="fill" type="ST_TLTimeNodeFillType" use="optional"/> + <xsd:attribute name="syncBehavior" type="ST_TLTimeNodeSyncType" use="optional"/> + <xsd:attribute name="tmFilter" type="xsd:string" use="optional"/> + <xsd:attribute name="evtFilter" type="xsd:string" use="optional"/> + <xsd:attribute name="display" type="xsd:boolean" use="optional"/> + <xsd:attribute name="masterRel" type="ST_TLTimeNodeMasterRelation" use="optional"/> + <xsd:attribute name="bldLvl" type="xsd:int" use="optional"/> + <xsd:attribute name="grpId" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="afterEffect" type="xsd:boolean" use="optional"/> + <xsd:attribute name="nodeType" type="ST_TLTimeNodeType" use="optional"/> + <xsd:attribute name="nodePh" type="xsd:boolean" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_TLTimeNodeParallel"> + <xsd:sequence> + <xsd:element name="cTn" type="CT_TLCommonTimeNodeData" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_TLNextActionType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="seek"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TLPreviousActionType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="skipTimed"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TLTimeNodeSequence"> + <xsd:sequence> + <xsd:element name="cTn" type="CT_TLCommonTimeNodeData" minOccurs="1" maxOccurs="1"/> + <xsd:element name="prevCondLst" type="CT_TLTimeConditionList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="nextCondLst" type="CT_TLTimeConditionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="concurrent" type="xsd:boolean" use="optional"/> + <xsd:attribute name="prevAc" type="ST_TLPreviousActionType" use="optional"/> + <xsd:attribute name="nextAc" type="ST_TLNextActionType" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_TLTimeNodeExclusive"> + <xsd:sequence> + <xsd:element name="cTn" type="CT_TLCommonTimeNodeData" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TLBehaviorAttributeNameList"> + <xsd:sequence> + <xsd:element name="attrName" type="xsd:string" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_TLBehaviorAdditiveType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="base"/> + <xsd:enumeration value="sum"/> + <xsd:enumeration value="repl"/> + <xsd:enumeration value="mult"/> + <xsd:enumeration value="none"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TLBehaviorAccumulateType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="always"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TLBehaviorTransformType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="pt"/> + <xsd:enumeration value="img"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TLBehaviorOverrideType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="normal"/> + <xsd:enumeration value="childStyle"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TLCommonBehaviorData"> + <xsd:sequence> + <xsd:element name="cTn" type="CT_TLCommonTimeNodeData" minOccurs="1" maxOccurs="1"/> + <xsd:element name="tgtEl" type="CT_TLTimeTargetElement" minOccurs="1" maxOccurs="1"/> + <xsd:element name="attrNameLst" type="CT_TLBehaviorAttributeNameList" minOccurs="0" + maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="additive" type="ST_TLBehaviorAdditiveType" use="optional"/> + <xsd:attribute name="accumulate" type="ST_TLBehaviorAccumulateType" use="optional"/> + <xsd:attribute name="xfrmType" type="ST_TLBehaviorTransformType" use="optional"/> + <xsd:attribute name="from" type="xsd:string" use="optional"/> + <xsd:attribute name="to" type="xsd:string" use="optional"/> + <xsd:attribute name="by" type="xsd:string" use="optional"/> + <xsd:attribute name="rctx" type="xsd:string" use="optional"/> + <xsd:attribute name="override" type="ST_TLBehaviorOverrideType" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_TLAnimVariantBooleanVal"> + <xsd:attribute name="val" type="xsd:boolean" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_TLAnimVariantIntegerVal"> + <xsd:attribute name="val" type="xsd:int" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_TLAnimVariantFloatVal"> + <xsd:attribute name="val" type="xsd:float" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_TLAnimVariantStringVal"> + <xsd:attribute name="val" type="xsd:string" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_TLAnimVariant"> + <xsd:choice minOccurs="1" maxOccurs="1"> + <xsd:element name="boolVal" type="CT_TLAnimVariantBooleanVal"/> + <xsd:element name="intVal" type="CT_TLAnimVariantIntegerVal"/> + <xsd:element name="fltVal" type="CT_TLAnimVariantFloatVal"/> + <xsd:element name="strVal" type="CT_TLAnimVariantStringVal"/> + <xsd:element name="clrVal" type="a:CT_Color"/> + </xsd:choice> + </xsd:complexType> + <xsd:simpleType name="ST_TLTimeAnimateValueTime"> + <xsd:union memberTypes="a:ST_PositiveFixedPercentage ST_TLTimeIndefinite"/> + </xsd:simpleType> + <xsd:complexType name="CT_TLTimeAnimateValue"> + <xsd:sequence> + <xsd:element name="val" type="CT_TLAnimVariant" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="tm" type="ST_TLTimeAnimateValueTime" use="optional" default="indefinite"/> + <xsd:attribute name="fmla" type="xsd:string" use="optional" default=""/> + </xsd:complexType> + <xsd:complexType name="CT_TLTimeAnimateValueList"> + <xsd:sequence> + <xsd:element name="tav" type="CT_TLTimeAnimateValue" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_TLAnimateBehaviorCalcMode"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="discrete"/> + <xsd:enumeration value="lin"/> + <xsd:enumeration value="fmla"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TLAnimateBehaviorValueType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="str"/> + <xsd:enumeration value="num"/> + <xsd:enumeration value="clr"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TLAnimateBehavior"> + <xsd:sequence> + <xsd:element name="cBhvr" type="CT_TLCommonBehaviorData" minOccurs="1" maxOccurs="1"/> + <xsd:element name="tavLst" type="CT_TLTimeAnimateValueList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="by" type="xsd:string" use="optional"/> + <xsd:attribute name="from" type="xsd:string" use="optional"/> + <xsd:attribute name="to" type="xsd:string" use="optional"/> + <xsd:attribute name="calcmode" type="ST_TLAnimateBehaviorCalcMode" use="optional"/> + <xsd:attribute name="valueType" type="ST_TLAnimateBehaviorValueType" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_TLByRgbColorTransform"> + <xsd:attribute name="r" type="a:ST_FixedPercentage" use="required"/> + <xsd:attribute name="g" type="a:ST_FixedPercentage" use="required"/> + <xsd:attribute name="b" type="a:ST_FixedPercentage" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_TLByHslColorTransform"> + <xsd:attribute name="h" type="a:ST_Angle" use="required"/> + <xsd:attribute name="s" type="a:ST_FixedPercentage" use="required"/> + <xsd:attribute name="l" type="a:ST_FixedPercentage" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_TLByAnimateColorTransform"> + <xsd:choice minOccurs="1" maxOccurs="1"> + <xsd:element name="rgb" type="CT_TLByRgbColorTransform"/> + <xsd:element name="hsl" type="CT_TLByHslColorTransform"/> + </xsd:choice> + </xsd:complexType> + <xsd:simpleType name="ST_TLAnimateColorSpace"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="rgb"/> + <xsd:enumeration value="hsl"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TLAnimateColorDirection"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="cw"/> + <xsd:enumeration value="ccw"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TLAnimateColorBehavior"> + <xsd:sequence> + <xsd:element name="cBhvr" type="CT_TLCommonBehaviorData" minOccurs="1" maxOccurs="1"/> + <xsd:element name="by" type="CT_TLByAnimateColorTransform" minOccurs="0" maxOccurs="1"/> + <xsd:element name="from" type="a:CT_Color" minOccurs="0" maxOccurs="1"/> + <xsd:element name="to" type="a:CT_Color" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="clrSpc" type="ST_TLAnimateColorSpace" use="optional"/> + <xsd:attribute name="dir" type="ST_TLAnimateColorDirection" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_TLAnimateEffectTransition"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="in"/> + <xsd:enumeration value="out"/> + <xsd:enumeration value="none"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TLAnimateEffectBehavior"> + <xsd:sequence> + <xsd:element name="cBhvr" type="CT_TLCommonBehaviorData" minOccurs="1" maxOccurs="1"/> + <xsd:element name="progress" type="CT_TLAnimVariant" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="transition" type="ST_TLAnimateEffectTransition" default="in" use="optional"/> + <xsd:attribute name="filter" type="xsd:string" use="optional"/> + <xsd:attribute name="prLst" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_TLAnimateMotionBehaviorOrigin"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="parent"/> + <xsd:enumeration value="layout"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TLAnimateMotionPathEditMode"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="relative"/> + <xsd:enumeration value="fixed"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TLPoint"> + <xsd:attribute name="x" type="a:ST_Percentage" use="required"/> + <xsd:attribute name="y" type="a:ST_Percentage" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_TLAnimateMotionBehavior"> + <xsd:sequence> + <xsd:element name="cBhvr" type="CT_TLCommonBehaviorData" minOccurs="1" maxOccurs="1"/> + <xsd:element name="by" type="CT_TLPoint" minOccurs="0" maxOccurs="1"/> + <xsd:element name="from" type="CT_TLPoint" minOccurs="0" maxOccurs="1"/> + <xsd:element name="to" type="CT_TLPoint" minOccurs="0" maxOccurs="1"/> + <xsd:element name="rCtr" type="CT_TLPoint" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="origin" type="ST_TLAnimateMotionBehaviorOrigin" use="optional"/> + <xsd:attribute name="path" type="xsd:string" use="optional"/> + <xsd:attribute name="pathEditMode" type="ST_TLAnimateMotionPathEditMode" use="optional"/> + <xsd:attribute name="rAng" type="a:ST_Angle" use="optional"/> + <xsd:attribute name="ptsTypes" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_TLAnimateRotationBehavior"> + <xsd:sequence> + <xsd:element name="cBhvr" type="CT_TLCommonBehaviorData" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="by" type="a:ST_Angle" use="optional"/> + <xsd:attribute name="from" type="a:ST_Angle" use="optional"/> + <xsd:attribute name="to" type="a:ST_Angle" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_TLAnimateScaleBehavior"> + <xsd:sequence> + <xsd:element name="cBhvr" type="CT_TLCommonBehaviorData" minOccurs="1" maxOccurs="1"/> + <xsd:element name="by" type="CT_TLPoint" minOccurs="0" maxOccurs="1"/> + <xsd:element name="from" type="CT_TLPoint" minOccurs="0" maxOccurs="1"/> + <xsd:element name="to" type="CT_TLPoint" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="zoomContents" type="xsd:boolean" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_TLCommandType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="evt"/> + <xsd:enumeration value="call"/> + <xsd:enumeration value="verb"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TLCommandBehavior"> + <xsd:sequence> + <xsd:element name="cBhvr" type="CT_TLCommonBehaviorData" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute type="ST_TLCommandType" name="type" use="optional"/> + <xsd:attribute name="cmd" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_TLSetBehavior"> + <xsd:sequence> + <xsd:element name="cBhvr" type="CT_TLCommonBehaviorData" minOccurs="1" maxOccurs="1"/> + <xsd:element name="to" type="CT_TLAnimVariant" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TLCommonMediaNodeData"> + <xsd:sequence> + <xsd:element name="cTn" type="CT_TLCommonTimeNodeData" minOccurs="1" maxOccurs="1"/> + <xsd:element name="tgtEl" type="CT_TLTimeTargetElement" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="vol" type="a:ST_PositiveFixedPercentage" default="50%" use="optional"/> + <xsd:attribute name="mute" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="numSld" type="xsd:unsignedInt" use="optional" default="1"/> + <xsd:attribute name="showWhenStopped" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_TLMediaNodeAudio"> + <xsd:sequence> + <xsd:element name="cMediaNode" type="CT_TLCommonMediaNodeData" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="isNarration" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_TLMediaNodeVideo"> + <xsd:sequence> + <xsd:element name="cMediaNode" type="CT_TLCommonMediaNodeData" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="fullScrn" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:attributeGroup name="AG_TLBuild"> + <xsd:attribute name="spid" type="a:ST_DrawingElementId" use="required"/> + <xsd:attribute name="grpId" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="uiExpand" type="xsd:boolean" use="optional" default="false"/> + </xsd:attributeGroup> + <xsd:complexType name="CT_TLTemplate"> + <xsd:sequence> + <xsd:element name="tnLst" type="CT_TimeNodeList" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="lvl" type="xsd:unsignedInt" use="optional" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_TLTemplateList"> + <xsd:sequence> + <xsd:element name="tmpl" type="CT_TLTemplate" minOccurs="0" maxOccurs="9"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_TLParaBuildType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="allAtOnce"/> + <xsd:enumeration value="p"/> + <xsd:enumeration value="cust"/> + <xsd:enumeration value="whole"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TLBuildParagraph"> + <xsd:sequence> + <xsd:element name="tmplLst" type="CT_TLTemplateList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_TLBuild"/> + <xsd:attribute name="build" type="ST_TLParaBuildType" use="optional" default="whole"/> + <xsd:attribute name="bldLvl" type="xsd:unsignedInt" use="optional" default="1"/> + <xsd:attribute name="animBg" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="autoUpdateAnimBg" type="xsd:boolean" default="true" use="optional"/> + <xsd:attribute name="rev" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="advAuto" type="ST_TLTime" use="optional" default="indefinite"/> + </xsd:complexType> + <xsd:simpleType name="ST_TLDiagramBuildType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="whole"/> + <xsd:enumeration value="depthByNode"/> + <xsd:enumeration value="depthByBranch"/> + <xsd:enumeration value="breadthByNode"/> + <xsd:enumeration value="breadthByLvl"/> + <xsd:enumeration value="cw"/> + <xsd:enumeration value="cwIn"/> + <xsd:enumeration value="cwOut"/> + <xsd:enumeration value="ccw"/> + <xsd:enumeration value="ccwIn"/> + <xsd:enumeration value="ccwOut"/> + <xsd:enumeration value="inByRing"/> + <xsd:enumeration value="outByRing"/> + <xsd:enumeration value="up"/> + <xsd:enumeration value="down"/> + <xsd:enumeration value="allAtOnce"/> + <xsd:enumeration value="cust"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TLBuildDiagram"> + <xsd:attributeGroup ref="AG_TLBuild"/> + <xsd:attribute name="bld" type="ST_TLDiagramBuildType" use="optional" default="whole"/> + </xsd:complexType> + <xsd:simpleType name="ST_TLOleChartBuildType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="allAtOnce"/> + <xsd:enumeration value="series"/> + <xsd:enumeration value="category"/> + <xsd:enumeration value="seriesEl"/> + <xsd:enumeration value="categoryEl"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TLOleBuildChart"> + <xsd:attributeGroup ref="AG_TLBuild"/> + <xsd:attribute name="bld" type="ST_TLOleChartBuildType" use="optional" default="allAtOnce"/> + <xsd:attribute name="animBg" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_TLGraphicalObjectBuild"> + <xsd:choice minOccurs="1" maxOccurs="1"> + <xsd:element name="bldAsOne" type="CT_Empty"/> + <xsd:element name="bldSub" type="a:CT_AnimationGraphicalObjectBuildProperties"/> + </xsd:choice> + <xsd:attributeGroup ref="AG_TLBuild"/> + </xsd:complexType> + <xsd:complexType name="CT_BuildList"> + <xsd:choice minOccurs="1" maxOccurs="unbounded"> + <xsd:element name="bldP" type="CT_TLBuildParagraph"/> + <xsd:element name="bldDgm" type="CT_TLBuildDiagram"/> + <xsd:element name="bldOleChart" type="CT_TLOleBuildChart"/> + <xsd:element name="bldGraphic" type="CT_TLGraphicalObjectBuild"/> + </xsd:choice> + </xsd:complexType> + <xsd:complexType name="CT_SlideTiming"> + <xsd:sequence> + <xsd:element name="tnLst" type="CT_TimeNodeList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="bldLst" type="CT_BuildList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionListModify" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Empty"/> + <xsd:simpleType name="ST_Name"> + <xsd:restriction base="xsd:string"/> + </xsd:simpleType> + <xsd:simpleType name="ST_Direction"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="horz"/> + <xsd:enumeration value="vert"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_Index"> + <xsd:restriction base="xsd:unsignedInt"/> + </xsd:simpleType> + <xsd:complexType name="CT_IndexRange"> + <xsd:attribute name="st" type="ST_Index" use="required"/> + <xsd:attribute name="end" type="ST_Index" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_SlideRelationshipListEntry"> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_SlideRelationshipList"> + <xsd:sequence> + <xsd:element name="sld" type="CT_SlideRelationshipListEntry" minOccurs="0" + maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_CustomShowId"> + <xsd:attribute name="id" type="xsd:unsignedInt" use="required"/> + </xsd:complexType> + <xsd:group name="EG_SlideListChoice"> + <xsd:choice> + <xsd:element name="sldAll" type="CT_Empty"/> + <xsd:element name="sldRg" type="CT_IndexRange"/> + <xsd:element name="custShow" type="CT_CustomShowId"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_CustomerData"> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_TagsData"> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_CustomerDataList"> + <xsd:sequence minOccurs="0" maxOccurs="1"> + <xsd:element name="custData" type="CT_CustomerData" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="tags" type="CT_TagsData" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Extension"> + <xsd:sequence> + <xsd:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="uri" type="xsd:token" use="required"/> + </xsd:complexType> + <xsd:group name="EG_ExtensionList"> + <xsd:sequence> + <xsd:element name="ext" type="CT_Extension" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:group> + <xsd:complexType name="CT_ExtensionList"> + <xsd:sequence> + <xsd:group ref="EG_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_ExtensionListModify"> + <xsd:sequence> + <xsd:group ref="EG_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="mod" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_CommentAuthor"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="id" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="name" type="ST_Name" use="required"/> + <xsd:attribute name="initials" type="ST_Name" use="required"/> + <xsd:attribute name="lastIdx" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="clrIdx" type="xsd:unsignedInt" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_CommentAuthorList"> + <xsd:sequence> + <xsd:element name="cmAuthor" type="CT_CommentAuthor" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="cmAuthorLst" type="CT_CommentAuthorList"/> + <xsd:complexType name="CT_Comment"> + <xsd:sequence> + <xsd:element name="pos" type="a:CT_Point2D" minOccurs="1" maxOccurs="1"/> + <xsd:element name="text" type="xsd:string" minOccurs="1" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionListModify" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="authorId" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="dt" type="xsd:dateTime" use="optional"/> + <xsd:attribute name="idx" type="ST_Index" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_CommentList"> + <xsd:sequence> + <xsd:element name="cm" type="CT_Comment" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="cmLst" type="CT_CommentList"/> + <xsd:attributeGroup name="AG_Ole"> + <xsd:attribute name="spid" type="a:ST_ShapeID" use="optional"/> + <xsd:attribute name="name" type="xsd:string" use="optional" default=""/> + <xsd:attribute name="showAsIcon" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute ref="r:id" use="optional"/> + <xsd:attribute name="imgW" type="a:ST_PositiveCoordinate32" use="optional"/> + <xsd:attribute name="imgH" type="a:ST_PositiveCoordinate32" use="optional"/> + </xsd:attributeGroup> + <xsd:simpleType name="ST_OleObjectFollowColorScheme"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="full"/> + <xsd:enumeration value="textAndBackground"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_OleObjectEmbed"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="followColorScheme" type="ST_OleObjectFollowColorScheme" use="optional" + default="none"/> + </xsd:complexType> + <xsd:complexType name="CT_OleObjectLink"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="updateAutomatic" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_OleObject"> + <xsd:sequence> + <xsd:choice minOccurs="1" maxOccurs="1"> + <xsd:element name="embed" type="CT_OleObjectEmbed"/> + <xsd:element name="link" type="CT_OleObjectLink"/> + </xsd:choice> + <xsd:element name="pic" type="CT_Picture" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_Ole"/> + <xsd:attribute name="progId" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:element name="oleObj" type="CT_OleObject"/> + <xsd:complexType name="CT_Control"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="pic" type="CT_Picture" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_Ole"/> + </xsd:complexType> + <xsd:complexType name="CT_ControlList"> + <xsd:sequence> + <xsd:element name="control" type="CT_Control" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_SlideId"> + <xsd:restriction base="xsd:unsignedInt"> + <xsd:minInclusive value="256"/> + <xsd:maxExclusive value="2147483648"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_SlideIdListEntry"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="id" type="ST_SlideId" use="required"/> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_SlideIdList"> + <xsd:sequence> + <xsd:element name="sldId" type="CT_SlideIdListEntry" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_SlideMasterId"> + <xsd:restriction base="xsd:unsignedInt"> + <xsd:minInclusive value="2147483648"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_SlideMasterIdListEntry"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="id" type="ST_SlideMasterId" use="optional"/> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_SlideMasterIdList"> + <xsd:sequence> + <xsd:element name="sldMasterId" type="CT_SlideMasterIdListEntry" minOccurs="0" + maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_NotesMasterIdListEntry"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_NotesMasterIdList"> + <xsd:sequence> + <xsd:element name="notesMasterId" type="CT_NotesMasterIdListEntry" minOccurs="0" maxOccurs="1" + /> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_HandoutMasterIdListEntry"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_HandoutMasterIdList"> + <xsd:sequence> + <xsd:element name="handoutMasterId" type="CT_HandoutMasterIdListEntry" minOccurs="0" + maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_EmbeddedFontDataId"> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_EmbeddedFontListEntry"> + <xsd:sequence> + <xsd:element name="font" type="a:CT_TextFont" minOccurs="1" maxOccurs="1"/> + <xsd:element name="regular" type="CT_EmbeddedFontDataId" minOccurs="0" maxOccurs="1"/> + <xsd:element name="bold" type="CT_EmbeddedFontDataId" minOccurs="0" maxOccurs="1"/> + <xsd:element name="italic" type="CT_EmbeddedFontDataId" minOccurs="0" maxOccurs="1"/> + <xsd:element name="boldItalic" type="CT_EmbeddedFontDataId" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_EmbeddedFontList"> + <xsd:sequence> + <xsd:element name="embeddedFont" type="CT_EmbeddedFontListEntry" minOccurs="0" + maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SmartTags"> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_CustomShow"> + <xsd:sequence> + <xsd:element name="sldLst" type="CT_SlideRelationshipList" minOccurs="1" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="name" type="ST_Name" use="required"/> + <xsd:attribute name="id" type="xsd:unsignedInt" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_CustomShowList"> + <xsd:sequence> + <xsd:element name="custShow" type="CT_CustomShow" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_PhotoAlbumLayout"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="fitToSlide"/> + <xsd:enumeration value="1pic"/> + <xsd:enumeration value="2pic"/> + <xsd:enumeration value="4pic"/> + <xsd:enumeration value="1picTitle"/> + <xsd:enumeration value="2picTitle"/> + <xsd:enumeration value="4picTitle"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_PhotoAlbumFrameShape"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="frameStyle1"/> + <xsd:enumeration value="frameStyle2"/> + <xsd:enumeration value="frameStyle3"/> + <xsd:enumeration value="frameStyle4"/> + <xsd:enumeration value="frameStyle5"/> + <xsd:enumeration value="frameStyle6"/> + <xsd:enumeration value="frameStyle7"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_PhotoAlbum"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="bw" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="showCaptions" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="layout" type="ST_PhotoAlbumLayout" use="optional" default="fitToSlide"/> + <xsd:attribute name="frame" type="ST_PhotoAlbumFrameShape" use="optional" default="frameStyle1" + /> + </xsd:complexType> + <xsd:simpleType name="ST_SlideSizeCoordinate"> + <xsd:restriction base="a:ST_PositiveCoordinate32"> + <xsd:minInclusive value="914400"/> + <xsd:maxInclusive value="51206400"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_SlideSizeType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="screen4x3"/> + <xsd:enumeration value="letter"/> + <xsd:enumeration value="A4"/> + <xsd:enumeration value="35mm"/> + <xsd:enumeration value="overhead"/> + <xsd:enumeration value="banner"/> + <xsd:enumeration value="custom"/> + <xsd:enumeration value="ledger"/> + <xsd:enumeration value="A3"/> + <xsd:enumeration value="B4ISO"/> + <xsd:enumeration value="B5ISO"/> + <xsd:enumeration value="B4JIS"/> + <xsd:enumeration value="B5JIS"/> + <xsd:enumeration value="hagakiCard"/> + <xsd:enumeration value="screen16x9"/> + <xsd:enumeration value="screen16x10"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_SlideSize"> + <xsd:attribute name="cx" type="ST_SlideSizeCoordinate" use="required"/> + <xsd:attribute name="cy" type="ST_SlideSizeCoordinate" use="required"/> + <xsd:attribute name="type" type="ST_SlideSizeType" use="optional" default="custom"/> + </xsd:complexType> + <xsd:complexType name="CT_Kinsoku"> + <xsd:attribute name="lang" type="xsd:string" use="optional"/> + <xsd:attribute name="invalStChars" type="xsd:string" use="required"/> + <xsd:attribute name="invalEndChars" type="xsd:string" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_BookmarkIdSeed"> + <xsd:restriction base="xsd:unsignedInt"> + <xsd:minInclusive value="1"/> + <xsd:maxExclusive value="2147483648"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_ModifyVerifier"> + <xsd:attribute name="algorithmName" type="xsd:string" use="optional"/> + <xsd:attribute name="hashValue" type="xsd:base64Binary" use="optional"/> + <xsd:attribute name="saltValue" type="xsd:base64Binary" use="optional"/> + <xsd:attribute name="spinValue" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="cryptProviderType" type="s:ST_CryptProv" use="optional"/> + <xsd:attribute name="cryptAlgorithmClass" type="s:ST_AlgClass" use="optional"/> + <xsd:attribute name="cryptAlgorithmType" type="s:ST_AlgType" use="optional"/> + <xsd:attribute name="cryptAlgorithmSid" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="spinCount" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="saltData" type="xsd:base64Binary" use="optional"/> + <xsd:attribute name="hashData" type="xsd:base64Binary" use="optional"/> + <xsd:attribute name="cryptProvider" type="xsd:string" use="optional"/> + <xsd:attribute name="algIdExt" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="algIdExtSource" type="xsd:string" use="optional"/> + <xsd:attribute name="cryptProviderTypeExt" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="cryptProviderTypeExtSource" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Presentation"> + <xsd:sequence> + <xsd:element name="sldMasterIdLst" type="CT_SlideMasterIdList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="notesMasterIdLst" type="CT_NotesMasterIdList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="handoutMasterIdLst" type="CT_HandoutMasterIdList" minOccurs="0" + maxOccurs="1"/> + <xsd:element name="sldIdLst" type="CT_SlideIdList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sldSz" type="CT_SlideSize" minOccurs="0" maxOccurs="1"/> + <xsd:element name="notesSz" type="a:CT_PositiveSize2D" minOccurs="1" maxOccurs="1"/> + <xsd:element name="smartTags" type="CT_SmartTags" minOccurs="0" maxOccurs="1"/> + <xsd:element name="embeddedFontLst" type="CT_EmbeddedFontList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="custShowLst" type="CT_CustomShowList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="photoAlbum" type="CT_PhotoAlbum" minOccurs="0" maxOccurs="1"/> + <xsd:element name="custDataLst" type="CT_CustomerDataList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="kinsoku" type="CT_Kinsoku" minOccurs="0"/> + <xsd:element name="defaultTextStyle" type="a:CT_TextListStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="modifyVerifier" type="CT_ModifyVerifier" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="serverZoom" type="a:ST_Percentage" use="optional" default="50%"/> + <xsd:attribute name="firstSlideNum" type="xsd:int" use="optional" default="1"/> + <xsd:attribute name="showSpecialPlsOnTitleSld" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="rtl" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="removePersonalInfoOnSave" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="compatMode" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="strictFirstAndLastChars" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="embedTrueTypeFonts" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="saveSubsetFonts" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="autoCompressPictures" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="bookmarkIdSeed" type="ST_BookmarkIdSeed" use="optional" default="1"/> + <xsd:attribute name="conformance" type="s:ST_ConformanceClass"/> + </xsd:complexType> + <xsd:element name="presentation" type="CT_Presentation"/> + <xsd:complexType name="CT_HtmlPublishProperties"> + <xsd:sequence> + <xsd:group ref="EG_SlideListChoice" minOccurs="1" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="showSpeakerNotes" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="target" type="xsd:string" use="optional"/> + <xsd:attribute name="title" type="xsd:string" use="optional" default=""/> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_WebColorType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="browser"/> + <xsd:enumeration value="presentationText"/> + <xsd:enumeration value="presentationAccent"/> + <xsd:enumeration value="whiteTextOnBlack"/> + <xsd:enumeration value="blackTextOnWhite"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_WebScreenSize"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="544x376"/> + <xsd:enumeration value="640x480"/> + <xsd:enumeration value="720x512"/> + <xsd:enumeration value="800x600"/> + <xsd:enumeration value="1024x768"/> + <xsd:enumeration value="1152x882"/> + <xsd:enumeration value="1152x900"/> + <xsd:enumeration value="1280x1024"/> + <xsd:enumeration value="1600x1200"/> + <xsd:enumeration value="1800x1400"/> + <xsd:enumeration value="1920x1200"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_WebEncoding"> + <xsd:restriction base="xsd:string"/> + </xsd:simpleType> + <xsd:complexType name="CT_WebProperties"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="showAnimation" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="resizeGraphics" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="allowPng" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="relyOnVml" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="organizeInFolders" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="useLongFilenames" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="imgSz" type="ST_WebScreenSize" use="optional" default="800x600"/> + <xsd:attribute name="encoding" type="ST_WebEncoding" use="optional" default=""/> + <xsd:attribute name="clr" type="ST_WebColorType" use="optional" default="whiteTextOnBlack"/> + </xsd:complexType> + <xsd:simpleType name="ST_PrintWhat"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="slides"/> + <xsd:enumeration value="handouts1"/> + <xsd:enumeration value="handouts2"/> + <xsd:enumeration value="handouts3"/> + <xsd:enumeration value="handouts4"/> + <xsd:enumeration value="handouts6"/> + <xsd:enumeration value="handouts9"/> + <xsd:enumeration value="notes"/> + <xsd:enumeration value="outline"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_PrintColorMode"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="bw"/> + <xsd:enumeration value="gray"/> + <xsd:enumeration value="clr"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_PrintProperties"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="prnWhat" type="ST_PrintWhat" use="optional" default="slides"/> + <xsd:attribute name="clrMode" type="ST_PrintColorMode" use="optional" default="clr"/> + <xsd:attribute name="hiddenSlides" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="scaleToFitPaper" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="frameSlides" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_ShowInfoBrowse"> + <xsd:attribute name="showScrollbar" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_ShowInfoKiosk"> + <xsd:attribute name="restart" type="xsd:unsignedInt" use="optional" default="300000"/> + </xsd:complexType> + <xsd:group name="EG_ShowType"> + <xsd:choice> + <xsd:element name="present" type="CT_Empty"/> + <xsd:element name="browse" type="CT_ShowInfoBrowse"/> + <xsd:element name="kiosk" type="CT_ShowInfoKiosk"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_ShowProperties"> + <xsd:sequence minOccurs="0" maxOccurs="1"> + <xsd:group ref="EG_ShowType" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_SlideListChoice" minOccurs="0" maxOccurs="1"/> + <xsd:element name="penClr" type="a:CT_Color" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="loop" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="showNarration" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="showAnimation" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="useTimings" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_PresentationProperties"> + <xsd:sequence> + <xsd:element name="htmlPubPr" type="CT_HtmlPublishProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="webPr" type="CT_WebProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="prnPr" type="CT_PrintProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="showPr" type="CT_ShowProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="clrMru" type="a:CT_ColorMRU" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="presentationPr" type="CT_PresentationProperties"/> + <xsd:complexType name="CT_HeaderFooter"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_ExtensionListModify" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="sldNum" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="hdr" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="ftr" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="dt" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:simpleType name="ST_PlaceholderType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="title"/> + <xsd:enumeration value="body"/> + <xsd:enumeration value="ctrTitle"/> + <xsd:enumeration value="subTitle"/> + <xsd:enumeration value="dt"/> + <xsd:enumeration value="sldNum"/> + <xsd:enumeration value="ftr"/> + <xsd:enumeration value="hdr"/> + <xsd:enumeration value="obj"/> + <xsd:enumeration value="chart"/> + <xsd:enumeration value="tbl"/> + <xsd:enumeration value="clipArt"/> + <xsd:enumeration value="dgm"/> + <xsd:enumeration value="media"/> + <xsd:enumeration value="sldImg"/> + <xsd:enumeration value="pic"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_PlaceholderSize"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="full"/> + <xsd:enumeration value="half"/> + <xsd:enumeration value="quarter"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Placeholder"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_ExtensionListModify" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="type" type="ST_PlaceholderType" use="optional" default="obj"/> + <xsd:attribute name="orient" type="ST_Direction" use="optional" default="horz"/> + <xsd:attribute name="sz" type="ST_PlaceholderSize" use="optional" default="full"/> + <xsd:attribute name="idx" type="xsd:unsignedInt" use="optional" default="0"/> + <xsd:attribute name="hasCustomPrompt" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_ApplicationNonVisualDrawingProps"> + <xsd:sequence> + <xsd:element name="ph" type="CT_Placeholder" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="a:EG_Media" minOccurs="0" maxOccurs="1"/> + <xsd:element name="custDataLst" type="CT_CustomerDataList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="isPhoto" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="userDrawn" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_ShapeNonVisual"> + <xsd:sequence> + <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cNvSpPr" type="a:CT_NonVisualDrawingShapeProps" minOccurs="1" maxOccurs="1"/> + <xsd:element name="nvPr" type="CT_ApplicationNonVisualDrawingProps" minOccurs="1" + maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Shape"> + <xsd:sequence> + <xsd:element name="nvSpPr" type="CT_ShapeNonVisual" minOccurs="1" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="style" type="a:CT_ShapeStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="txBody" type="a:CT_TextBody" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionListModify" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="useBgFill" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_ConnectorNonVisual"> + <xsd:sequence> + <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cNvCxnSpPr" type="a:CT_NonVisualConnectorProperties" minOccurs="1" + maxOccurs="1"/> + <xsd:element name="nvPr" type="CT_ApplicationNonVisualDrawingProps" minOccurs="1" + maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Connector"> + <xsd:sequence> + <xsd:element name="nvCxnSpPr" type="CT_ConnectorNonVisual" minOccurs="1" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="style" type="a:CT_ShapeStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionListModify" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_PictureNonVisual"> + <xsd:sequence> + <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cNvPicPr" type="a:CT_NonVisualPictureProperties" minOccurs="1" + maxOccurs="1"/> + <xsd:element name="nvPr" type="CT_ApplicationNonVisualDrawingProps" minOccurs="1" + maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Picture"> + <xsd:sequence> + <xsd:element name="nvPicPr" type="CT_PictureNonVisual" minOccurs="1" maxOccurs="1"/> + <xsd:element name="blipFill" type="a:CT_BlipFillProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="style" type="a:CT_ShapeStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionListModify" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_GraphicalObjectFrameNonVisual"> + <xsd:sequence> + <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cNvGraphicFramePr" type="a:CT_NonVisualGraphicFrameProperties" + minOccurs="1" maxOccurs="1"/> + <xsd:element name="nvPr" type="CT_ApplicationNonVisualDrawingProps" minOccurs="1" + maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_GraphicalObjectFrame"> + <xsd:sequence> + <xsd:element name="nvGraphicFramePr" type="CT_GraphicalObjectFrameNonVisual" minOccurs="1" + maxOccurs="1"/> + <xsd:element name="xfrm" type="a:CT_Transform2D" minOccurs="1" maxOccurs="1"/> + <xsd:element ref="a:graphic" minOccurs="1" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionListModify" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="bwMode" type="a:ST_BlackWhiteMode" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_GroupShapeNonVisual"> + <xsd:sequence> + <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cNvGrpSpPr" type="a:CT_NonVisualGroupDrawingShapeProps" minOccurs="1" + maxOccurs="1"/> + <xsd:element name="nvPr" type="CT_ApplicationNonVisualDrawingProps" minOccurs="1" + maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_GroupShape"> + <xsd:sequence> + <xsd:element name="nvGrpSpPr" type="CT_GroupShapeNonVisual" minOccurs="1" maxOccurs="1"/> + <xsd:element name="grpSpPr" type="a:CT_GroupShapeProperties" minOccurs="1" maxOccurs="1"/> + <xsd:choice minOccurs="0" maxOccurs="unbounded"> + <xsd:element name="sp" type="CT_Shape"/> + <xsd:element name="grpSp" type="CT_GroupShape"/> + <xsd:element name="graphicFrame" type="CT_GraphicalObjectFrame"/> + <xsd:element name="cxnSp" type="CT_Connector"/> + <xsd:element name="pic" type="CT_Picture"/> + <xsd:element name="contentPart" type="CT_Rel"/> + </xsd:choice> + <xsd:element name="extLst" type="CT_ExtensionListModify" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Rel"> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:group name="EG_TopLevelSlide"> + <xsd:sequence> + <xsd:element name="clrMap" type="a:CT_ColorMapping" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:group> + <xsd:group name="EG_ChildSlide"> + <xsd:sequence> + <xsd:element name="clrMapOvr" type="a:CT_ColorMappingOverride" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:group> + <xsd:attributeGroup name="AG_ChildSlide"> + <xsd:attribute name="showMasterSp" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="showMasterPhAnim" type="xsd:boolean" use="optional" default="true"/> + </xsd:attributeGroup> + <xsd:complexType name="CT_BackgroundProperties"> + <xsd:sequence> + <xsd:group ref="a:EG_FillProperties" minOccurs="1" maxOccurs="1"/> + <xsd:group ref="a:EG_EffectProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="shadeToTitle" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:group name="EG_Background"> + <xsd:choice> + <xsd:element name="bgPr" type="CT_BackgroundProperties"/> + <xsd:element name="bgRef" type="a:CT_StyleMatrixReference"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_Background"> + <xsd:sequence> + <xsd:group ref="EG_Background"/> + </xsd:sequence> + <xsd:attribute name="bwMode" type="a:ST_BlackWhiteMode" use="optional" default="white"/> + </xsd:complexType> + <xsd:complexType name="CT_CommonSlideData"> + <xsd:sequence> + <xsd:element name="bg" type="CT_Background" minOccurs="0" maxOccurs="1"/> + <xsd:element name="spTree" type="CT_GroupShape" minOccurs="1" maxOccurs="1"/> + <xsd:element name="custDataLst" type="CT_CustomerDataList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="controls" type="CT_ControlList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="optional" default=""/> + </xsd:complexType> + <xsd:complexType name="CT_Slide"> + <xsd:sequence minOccurs="1" maxOccurs="1"> + <xsd:element name="cSld" type="CT_CommonSlideData" minOccurs="1" maxOccurs="1"/> + <xsd:group ref="EG_ChildSlide" minOccurs="0" maxOccurs="1"/> + <xsd:element name="transition" type="CT_SlideTransition" minOccurs="0" maxOccurs="1"/> + <xsd:element name="timing" type="CT_SlideTiming" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionListModify" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_ChildSlide"/> + <xsd:attribute name="show" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:element name="sld" type="CT_Slide"/> + <xsd:simpleType name="ST_SlideLayoutType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="title"/> + <xsd:enumeration value="tx"/> + <xsd:enumeration value="twoColTx"/> + <xsd:enumeration value="tbl"/> + <xsd:enumeration value="txAndChart"/> + <xsd:enumeration value="chartAndTx"/> + <xsd:enumeration value="dgm"/> + <xsd:enumeration value="chart"/> + <xsd:enumeration value="txAndClipArt"/> + <xsd:enumeration value="clipArtAndTx"/> + <xsd:enumeration value="titleOnly"/> + <xsd:enumeration value="blank"/> + <xsd:enumeration value="txAndObj"/> + <xsd:enumeration value="objAndTx"/> + <xsd:enumeration value="objOnly"/> + <xsd:enumeration value="obj"/> + <xsd:enumeration value="txAndMedia"/> + <xsd:enumeration value="mediaAndTx"/> + <xsd:enumeration value="objOverTx"/> + <xsd:enumeration value="txOverObj"/> + <xsd:enumeration value="txAndTwoObj"/> + <xsd:enumeration value="twoObjAndTx"/> + <xsd:enumeration value="twoObjOverTx"/> + <xsd:enumeration value="fourObj"/> + <xsd:enumeration value="vertTx"/> + <xsd:enumeration value="clipArtAndVertTx"/> + <xsd:enumeration value="vertTitleAndTx"/> + <xsd:enumeration value="vertTitleAndTxOverChart"/> + <xsd:enumeration value="twoObj"/> + <xsd:enumeration value="objAndTwoObj"/> + <xsd:enumeration value="twoObjAndObj"/> + <xsd:enumeration value="cust"/> + <xsd:enumeration value="secHead"/> + <xsd:enumeration value="twoTxTwoObj"/> + <xsd:enumeration value="objTx"/> + <xsd:enumeration value="picTx"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_SlideLayout"> + <xsd:sequence minOccurs="1" maxOccurs="1"> + <xsd:element name="cSld" type="CT_CommonSlideData" minOccurs="1" maxOccurs="1"/> + <xsd:group ref="EG_ChildSlide" minOccurs="0" maxOccurs="1"/> + <xsd:element name="transition" type="CT_SlideTransition" minOccurs="0" maxOccurs="1"/> + <xsd:element name="timing" type="CT_SlideTiming" minOccurs="0" maxOccurs="1"/> + <xsd:element name="hf" type="CT_HeaderFooter" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionListModify" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_ChildSlide"/> + <xsd:attribute name="matchingName" type="xsd:string" use="optional" default=""/> + <xsd:attribute name="type" type="ST_SlideLayoutType" use="optional" default="cust"/> + <xsd:attribute name="preserve" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="userDrawn" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:element name="sldLayout" type="CT_SlideLayout"/> + <xsd:complexType name="CT_SlideMasterTextStyles"> + <xsd:sequence> + <xsd:element name="titleStyle" type="a:CT_TextListStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="bodyStyle" type="a:CT_TextListStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="otherStyle" type="a:CT_TextListStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_SlideLayoutId"> + <xsd:restriction base="xsd:unsignedInt"> + <xsd:minInclusive value="2147483648"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_SlideLayoutIdListEntry"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="id" type="ST_SlideLayoutId" use="optional"/> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_SlideLayoutIdList"> + <xsd:sequence> + <xsd:element name="sldLayoutId" type="CT_SlideLayoutIdListEntry" minOccurs="0" + maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SlideMaster"> + <xsd:sequence minOccurs="1" maxOccurs="1"> + <xsd:element name="cSld" type="CT_CommonSlideData" minOccurs="1" maxOccurs="1"/> + <xsd:group ref="EG_TopLevelSlide" minOccurs="1" maxOccurs="1"/> + <xsd:element name="sldLayoutIdLst" type="CT_SlideLayoutIdList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="transition" type="CT_SlideTransition" minOccurs="0" maxOccurs="1"/> + <xsd:element name="timing" type="CT_SlideTiming" minOccurs="0" maxOccurs="1"/> + <xsd:element name="hf" type="CT_HeaderFooter" minOccurs="0" maxOccurs="1"/> + <xsd:element name="txStyles" type="CT_SlideMasterTextStyles" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionListModify" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="preserve" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:element name="sldMaster" type="CT_SlideMaster"/> + <xsd:complexType name="CT_HandoutMaster"> + <xsd:sequence> + <xsd:element name="cSld" type="CT_CommonSlideData" minOccurs="1" maxOccurs="1"/> + <xsd:group ref="EG_TopLevelSlide" minOccurs="1" maxOccurs="1"/> + <xsd:element name="hf" type="CT_HeaderFooter" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionListModify" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="handoutMaster" type="CT_HandoutMaster"/> + <xsd:complexType name="CT_NotesMaster"> + <xsd:sequence> + <xsd:element name="cSld" type="CT_CommonSlideData" minOccurs="1" maxOccurs="1"/> + <xsd:group ref="EG_TopLevelSlide" minOccurs="1" maxOccurs="1"/> + <xsd:element name="hf" type="CT_HeaderFooter" minOccurs="0" maxOccurs="1"/> + <xsd:element name="notesStyle" type="a:CT_TextListStyle" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionListModify" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="notesMaster" type="CT_NotesMaster"/> + <xsd:complexType name="CT_NotesSlide"> + <xsd:sequence minOccurs="1" maxOccurs="1"> + <xsd:element name="cSld" type="CT_CommonSlideData" minOccurs="1" maxOccurs="1"/> + <xsd:group ref="EG_ChildSlide" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionListModify" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_ChildSlide"/> + </xsd:complexType> + <xsd:element name="notes" type="CT_NotesSlide"/> + <xsd:complexType name="CT_SlideSyncProperties"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="serverSldId" type="xsd:string" use="required"/> + <xsd:attribute name="serverSldModifiedTime" type="xsd:dateTime" use="required"/> + <xsd:attribute name="clientInsertedTime" type="xsd:dateTime" use="required"/> + </xsd:complexType> + <xsd:element name="sldSyncPr" type="CT_SlideSyncProperties"/> + <xsd:complexType name="CT_StringTag"> + <xsd:attribute name="name" type="xsd:string" use="required"/> + <xsd:attribute name="val" type="xsd:string" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_TagList"> + <xsd:sequence> + <xsd:element name="tag" type="CT_StringTag" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="tagLst" type="CT_TagList"/> + <xsd:simpleType name="ST_SplitterBarState"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="minimized"/> + <xsd:enumeration value="restored"/> + <xsd:enumeration value="maximized"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ViewType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="sldView"/> + <xsd:enumeration value="sldMasterView"/> + <xsd:enumeration value="notesView"/> + <xsd:enumeration value="handoutView"/> + <xsd:enumeration value="notesMasterView"/> + <xsd:enumeration value="outlineView"/> + <xsd:enumeration value="sldSorterView"/> + <xsd:enumeration value="sldThumbnailView"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_NormalViewPortion"> + <xsd:attribute name="sz" type="a:ST_PositiveFixedPercentage" use="required"/> + <xsd:attribute name="autoAdjust" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_NormalViewProperties"> + <xsd:sequence> + <xsd:element name="restoredLeft" type="CT_NormalViewPortion" minOccurs="1" maxOccurs="1"/> + <xsd:element name="restoredTop" type="CT_NormalViewPortion" minOccurs="1" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="showOutlineIcons" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="snapVertSplitter" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="vertBarState" type="ST_SplitterBarState" use="optional" default="restored"/> + <xsd:attribute name="horzBarState" type="ST_SplitterBarState" use="optional" default="restored"/> + <xsd:attribute name="preferSingleView" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_CommonViewProperties"> + <xsd:sequence> + <xsd:element name="scale" type="a:CT_Scale2D" minOccurs="1" maxOccurs="1"/> + <xsd:element name="origin" type="a:CT_Point2D" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="varScale" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_NotesTextViewProperties"> + <xsd:sequence minOccurs="1" maxOccurs="1"> + <xsd:element name="cViewPr" type="CT_CommonViewProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_OutlineViewSlideEntry"> + <xsd:attribute ref="r:id" use="required"/> + <xsd:attribute name="collapse" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_OutlineViewSlideList"> + <xsd:sequence> + <xsd:element name="sld" type="CT_OutlineViewSlideEntry" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_OutlineViewProperties"> + <xsd:sequence minOccurs="1" maxOccurs="1"> + <xsd:element name="cViewPr" type="CT_CommonViewProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="sldLst" type="CT_OutlineViewSlideList" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SlideSorterViewProperties"> + <xsd:sequence minOccurs="1" maxOccurs="1"> + <xsd:element name="cViewPr" type="CT_CommonViewProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="showFormatting" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_Guide"> + <xsd:attribute name="orient" type="ST_Direction" use="optional" default="vert"/> + <xsd:attribute name="pos" type="a:ST_Coordinate32" use="optional" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_GuideList"> + <xsd:sequence minOccurs="0" maxOccurs="1"> + <xsd:element name="guide" type="CT_Guide" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_CommonSlideViewProperties"> + <xsd:sequence> + <xsd:element name="cViewPr" type="CT_CommonViewProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="guideLst" type="CT_GuideList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="snapToGrid" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="snapToObjects" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="showGuides" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_SlideViewProperties"> + <xsd:sequence> + <xsd:element name="cSldViewPr" type="CT_CommonSlideViewProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_NotesViewProperties"> + <xsd:sequence> + <xsd:element name="cSldViewPr" type="CT_CommonSlideViewProperties" minOccurs="1" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_ViewProperties"> + <xsd:sequence minOccurs="0" maxOccurs="1"> + <xsd:element name="normalViewPr" type="CT_NormalViewProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="slideViewPr" type="CT_SlideViewProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="outlineViewPr" type="CT_OutlineViewProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="notesTextViewPr" type="CT_NotesTextViewProperties" minOccurs="0" + maxOccurs="1"/> + <xsd:element name="sorterViewPr" type="CT_SlideSorterViewProperties" minOccurs="0" + maxOccurs="1"/> + <xsd:element name="notesViewPr" type="CT_NotesViewProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="gridSpacing" type="a:CT_PositiveSize2D" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="lastView" type="ST_ViewType" use="optional" default="sldView"/> + <xsd:attribute name="showComments" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:element name="viewPr" type="CT_ViewProperties"/> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-additionalCharacteristics.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-additionalCharacteristics.xsd new file mode 100644 index 00000000..c20f3bf1 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-additionalCharacteristics.xsd @@ -0,0 +1,28 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" + xmlns="http://schemas.openxmlformats.org/officeDocument/2006/characteristics" + targetNamespace="http://schemas.openxmlformats.org/officeDocument/2006/characteristics" + elementFormDefault="qualified"> + <xsd:complexType name="CT_AdditionalCharacteristics"> + <xsd:sequence> + <xsd:element name="characteristic" type="CT_Characteristic" minOccurs="0" + maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Characteristic"> + <xsd:attribute name="name" type="xsd:string" use="required"/> + <xsd:attribute name="relation" type="ST_Relation" use="required"/> + <xsd:attribute name="val" type="xsd:string" use="required"/> + <xsd:attribute name="vocabulary" type="xsd:anyURI" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_Relation"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="ge"/> + <xsd:enumeration value="le"/> + <xsd:enumeration value="gt"/> + <xsd:enumeration value="lt"/> + <xsd:enumeration value="eq"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:element name="additionalCharacteristics" type="CT_AdditionalCharacteristics"/> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-bibliography.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-bibliography.xsd new file mode 100644 index 00000000..ac602522 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-bibliography.xsd @@ -0,0 +1,144 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" + xmlns="http://schemas.openxmlformats.org/officeDocument/2006/bibliography" + xmlns:s="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + targetNamespace="http://schemas.openxmlformats.org/officeDocument/2006/bibliography" + elementFormDefault="qualified"> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + schemaLocation="shared-commonSimpleTypes.xsd"/> + <xsd:simpleType name="ST_SourceType"> + <xsd:restriction base="s:ST_String"> + <xsd:enumeration value="ArticleInAPeriodical"/> + <xsd:enumeration value="Book"/> + <xsd:enumeration value="BookSection"/> + <xsd:enumeration value="JournalArticle"/> + <xsd:enumeration value="ConferenceProceedings"/> + <xsd:enumeration value="Report"/> + <xsd:enumeration value="SoundRecording"/> + <xsd:enumeration value="Performance"/> + <xsd:enumeration value="Art"/> + <xsd:enumeration value="DocumentFromInternetSite"/> + <xsd:enumeration value="InternetSite"/> + <xsd:enumeration value="Film"/> + <xsd:enumeration value="Interview"/> + <xsd:enumeration value="Patent"/> + <xsd:enumeration value="ElectronicSource"/> + <xsd:enumeration value="Case"/> + <xsd:enumeration value="Misc"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_NameListType"> + <xsd:sequence> + <xsd:element name="Person" type="CT_PersonType" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_PersonType"> + <xsd:sequence> + <xsd:element name="Last" type="s:ST_String" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="First" type="s:ST_String" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="Middle" type="s:ST_String" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_NameType"> + <xsd:sequence> + <xsd:element name="NameList" type="CT_NameListType" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_NameOrCorporateType"> + <xsd:sequence> + <xsd:choice minOccurs="0" maxOccurs="1"> + <xsd:element name="NameList" type="CT_NameListType" minOccurs="1" maxOccurs="1"/> + <xsd:element name="Corporate" minOccurs="1" maxOccurs="1" type="s:ST_String"/> + </xsd:choice> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_AuthorType"> + <xsd:sequence> + <xsd:choice minOccurs="0" maxOccurs="unbounded"> + <xsd:element name="Artist" type="CT_NameType"/> + <xsd:element name="Author" type="CT_NameOrCorporateType"/> + <xsd:element name="BookAuthor" type="CT_NameType"/> + <xsd:element name="Compiler" type="CT_NameType"/> + <xsd:element name="Composer" type="CT_NameType"/> + <xsd:element name="Conductor" type="CT_NameType"/> + <xsd:element name="Counsel" type="CT_NameType"/> + <xsd:element name="Director" type="CT_NameType"/> + <xsd:element name="Editor" type="CT_NameType"/> + <xsd:element name="Interviewee" type="CT_NameType"/> + <xsd:element name="Interviewer" type="CT_NameType"/> + <xsd:element name="Inventor" type="CT_NameType"/> + <xsd:element name="Performer" type="CT_NameOrCorporateType"/> + <xsd:element name="ProducerName" type="CT_NameType"/> + <xsd:element name="Translator" type="CT_NameType"/> + <xsd:element name="Writer" type="CT_NameType"/> + </xsd:choice> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SourceType"> + <xsd:sequence> + <xsd:choice minOccurs="0" maxOccurs="unbounded"> + <xsd:element name="AbbreviatedCaseNumber" type="s:ST_String"/> + <xsd:element name="AlbumTitle" type="s:ST_String"/> + <xsd:element name="Author" type="CT_AuthorType"/> + <xsd:element name="BookTitle" type="s:ST_String"/> + <xsd:element name="Broadcaster" type="s:ST_String"/> + <xsd:element name="BroadcastTitle" type="s:ST_String"/> + <xsd:element name="CaseNumber" type="s:ST_String"/> + <xsd:element name="ChapterNumber" type="s:ST_String"/> + <xsd:element name="City" type="s:ST_String"/> + <xsd:element name="Comments" type="s:ST_String"/> + <xsd:element name="ConferenceName" type="s:ST_String"/> + <xsd:element name="CountryRegion" type="s:ST_String"/> + <xsd:element name="Court" type="s:ST_String"/> + <xsd:element name="Day" type="s:ST_String"/> + <xsd:element name="DayAccessed" type="s:ST_String"/> + <xsd:element name="Department" type="s:ST_String"/> + <xsd:element name="Distributor" type="s:ST_String"/> + <xsd:element name="Edition" type="s:ST_String"/> + <xsd:element name="Guid" type="s:ST_String"/> + <xsd:element name="Institution" type="s:ST_String"/> + <xsd:element name="InternetSiteTitle" type="s:ST_String"/> + <xsd:element name="Issue" type="s:ST_String"/> + <xsd:element name="JournalName" type="s:ST_String"/> + <xsd:element name="LCID" type="s:ST_Lang"/> + <xsd:element name="Medium" type="s:ST_String"/> + <xsd:element name="Month" type="s:ST_String"/> + <xsd:element name="MonthAccessed" type="s:ST_String"/> + <xsd:element name="NumberVolumes" type="s:ST_String"/> + <xsd:element name="Pages" type="s:ST_String"/> + <xsd:element name="PatentNumber" type="s:ST_String"/> + <xsd:element name="PeriodicalTitle" type="s:ST_String"/> + <xsd:element name="ProductionCompany" type="s:ST_String"/> + <xsd:element name="PublicationTitle" type="s:ST_String"/> + <xsd:element name="Publisher" type="s:ST_String"/> + <xsd:element name="RecordingNumber" type="s:ST_String"/> + <xsd:element name="RefOrder" type="s:ST_String"/> + <xsd:element name="Reporter" type="s:ST_String"/> + <xsd:element name="SourceType" type="ST_SourceType"/> + <xsd:element name="ShortTitle" type="s:ST_String"/> + <xsd:element name="StandardNumber" type="s:ST_String"/> + <xsd:element name="StateProvince" type="s:ST_String"/> + <xsd:element name="Station" type="s:ST_String"/> + <xsd:element name="Tag" type="s:ST_String"/> + <xsd:element name="Theater" type="s:ST_String"/> + <xsd:element name="ThesisType" type="s:ST_String"/> + <xsd:element name="Title" type="s:ST_String"/> + <xsd:element name="Type" type="s:ST_String"/> + <xsd:element name="URL" type="s:ST_String"/> + <xsd:element name="Version" type="s:ST_String"/> + <xsd:element name="Volume" type="s:ST_String"/> + <xsd:element name="Year" type="s:ST_String"/> + <xsd:element name="YearAccessed" type="s:ST_String"/> + </xsd:choice> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="Sources" type="CT_Sources"/> + <xsd:complexType name="CT_Sources"> + <xsd:sequence> + <xsd:element name="Source" type="CT_SourceType" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="SelectedStyle" type="s:ST_String"/> + <xsd:attribute name="StyleName" type="s:ST_String"/> + <xsd:attribute name="URI" type="s:ST_String"/> + </xsd:complexType> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-commonSimpleTypes.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-commonSimpleTypes.xsd new file mode 100644 index 00000000..424b8ba8 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-commonSimpleTypes.xsd @@ -0,0 +1,174 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" + xmlns="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + targetNamespace="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + elementFormDefault="qualified"> + <xsd:simpleType name="ST_Lang"> + <xsd:restriction base="xsd:string"/> + </xsd:simpleType> + <xsd:simpleType name="ST_HexColorRGB"> + <xsd:restriction base="xsd:hexBinary"> + <xsd:length value="3" fixed="true"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_Panose"> + <xsd:restriction base="xsd:hexBinary"> + <xsd:length value="10"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_CalendarType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="gregorian"/> + <xsd:enumeration value="gregorianUs"/> + <xsd:enumeration value="gregorianMeFrench"/> + <xsd:enumeration value="gregorianArabic"/> + <xsd:enumeration value="hijri"/> + <xsd:enumeration value="hebrew"/> + <xsd:enumeration value="taiwan"/> + <xsd:enumeration value="japan"/> + <xsd:enumeration value="thai"/> + <xsd:enumeration value="korea"/> + <xsd:enumeration value="saka"/> + <xsd:enumeration value="gregorianXlitEnglish"/> + <xsd:enumeration value="gregorianXlitFrench"/> + <xsd:enumeration value="none"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_AlgClass"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="hash"/> + <xsd:enumeration value="custom"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_CryptProv"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="rsaAES"/> + <xsd:enumeration value="rsaFull"/> + <xsd:enumeration value="custom"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_AlgType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="typeAny"/> + <xsd:enumeration value="custom"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ColorType"> + <xsd:restriction base="xsd:string"/> + </xsd:simpleType> + <xsd:simpleType name="ST_Guid"> + <xsd:restriction base="xsd:token"> + <xsd:pattern value="\{[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}\}"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_OnOff"> + <xsd:union memberTypes="xsd:boolean ST_OnOff1"/> + </xsd:simpleType> + <xsd:simpleType name="ST_OnOff1"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="on"/> + <xsd:enumeration value="off"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_String"> + <xsd:restriction base="xsd:string"/> + </xsd:simpleType> + <xsd:simpleType name="ST_XmlName"> + <xsd:restriction base="xsd:NCName"> + <xsd:minLength value="1"/> + <xsd:maxLength value="255"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TrueFalse"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="t"/> + <xsd:enumeration value="f"/> + <xsd:enumeration value="true"/> + <xsd:enumeration value="false"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TrueFalseBlank"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="t"/> + <xsd:enumeration value="f"/> + <xsd:enumeration value="true"/> + <xsd:enumeration value="false"/> + <xsd:enumeration value=""/> + <xsd:enumeration value="True"/> + <xsd:enumeration value="False"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_UnsignedDecimalNumber"> + <xsd:restriction base="xsd:decimal"> + <xsd:minInclusive value="0"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TwipsMeasure"> + <xsd:union memberTypes="ST_UnsignedDecimalNumber ST_PositiveUniversalMeasure"/> + </xsd:simpleType> + <xsd:simpleType name="ST_VerticalAlignRun"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="baseline"/> + <xsd:enumeration value="superscript"/> + <xsd:enumeration value="subscript"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_Xstring"> + <xsd:restriction base="xsd:string"/> + </xsd:simpleType> + <xsd:simpleType name="ST_XAlign"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="left"/> + <xsd:enumeration value="center"/> + <xsd:enumeration value="right"/> + <xsd:enumeration value="inside"/> + <xsd:enumeration value="outside"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_YAlign"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="inline"/> + <xsd:enumeration value="top"/> + <xsd:enumeration value="center"/> + <xsd:enumeration value="bottom"/> + <xsd:enumeration value="inside"/> + <xsd:enumeration value="outside"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ConformanceClass"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="strict"/> + <xsd:enumeration value="transitional"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_UniversalMeasure"> + <xsd:restriction base="xsd:string"> + <xsd:pattern value="-?[0-9]+(\.[0-9]+)?(mm|cm|in|pt|pc|pi)"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_PositiveUniversalMeasure"> + <xsd:restriction base="ST_UniversalMeasure"> + <xsd:pattern value="[0-9]+(\.[0-9]+)?(mm|cm|in|pt|pc|pi)"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_Percentage"> + <xsd:restriction base="xsd:string"> + <xsd:pattern value="-?[0-9]+(\.[0-9]+)?%"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_FixedPercentage"> + <xsd:restriction base="ST_Percentage"> + <xsd:pattern value="-?((100)|([0-9][0-9]?))(\.[0-9][0-9]?)?%"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_PositivePercentage"> + <xsd:restriction base="ST_Percentage"> + <xsd:pattern value="[0-9]+(\.[0-9]+)?%"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_PositiveFixedPercentage"> + <xsd:restriction base="ST_Percentage"> + <xsd:pattern value="((100)|([0-9][0-9]?))(\.[0-9][0-9]?)?%"/> + </xsd:restriction> + </xsd:simpleType> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-customXmlDataProperties.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-customXmlDataProperties.xsd new file mode 100644 index 00000000..2bddce29 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-customXmlDataProperties.xsd @@ -0,0 +1,25 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" + xmlns="http://schemas.openxmlformats.org/officeDocument/2006/customXml" + xmlns:s="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + targetNamespace="http://schemas.openxmlformats.org/officeDocument/2006/customXml" + elementFormDefault="qualified" attributeFormDefault="qualified" blockDefault="#all"> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + schemaLocation="shared-commonSimpleTypes.xsd"/> + <xsd:complexType name="CT_DatastoreSchemaRef"> + <xsd:attribute name="uri" type="xsd:string" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_DatastoreSchemaRefs"> + <xsd:sequence> + <xsd:element name="schemaRef" type="CT_DatastoreSchemaRef" minOccurs="0" maxOccurs="unbounded" + /> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_DatastoreItem"> + <xsd:sequence> + <xsd:element name="schemaRefs" type="CT_DatastoreSchemaRefs" minOccurs="0"/> + </xsd:sequence> + <xsd:attribute name="itemID" type="s:ST_Guid" use="required"/> + </xsd:complexType> + <xsd:element name="datastoreItem" type="CT_DatastoreItem"/> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-customXmlSchemaProperties.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-customXmlSchemaProperties.xsd new file mode 100644 index 00000000..8a8c18ba --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-customXmlSchemaProperties.xsd @@ -0,0 +1,18 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" + xmlns="http://schemas.openxmlformats.org/schemaLibrary/2006/main" + targetNamespace="http://schemas.openxmlformats.org/schemaLibrary/2006/main" + attributeFormDefault="qualified" elementFormDefault="qualified"> + <xsd:complexType name="CT_Schema"> + <xsd:attribute name="uri" type="xsd:string" default=""/> + <xsd:attribute name="manifestLocation" type="xsd:string"/> + <xsd:attribute name="schemaLocation" type="xsd:string"/> + <xsd:attribute name="schemaLanguage" type="xsd:token"/> + </xsd:complexType> + <xsd:complexType name="CT_SchemaLibrary"> + <xsd:sequence> + <xsd:element name="schema" type="CT_Schema" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="schemaLibrary" type="CT_SchemaLibrary"/> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-documentPropertiesCustom.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-documentPropertiesCustom.xsd new file mode 100644 index 00000000..5c42706a --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-documentPropertiesCustom.xsd @@ -0,0 +1,59 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" + xmlns="http://schemas.openxmlformats.org/officeDocument/2006/custom-properties" + xmlns:vt="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes" + xmlns:s="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + targetNamespace="http://schemas.openxmlformats.org/officeDocument/2006/custom-properties" + blockDefault="#all" elementFormDefault="qualified"> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes" + schemaLocation="shared-documentPropertiesVariantTypes.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + schemaLocation="shared-commonSimpleTypes.xsd"/> + <xsd:element name="Properties" type="CT_Properties"/> + <xsd:complexType name="CT_Properties"> + <xsd:sequence> + <xsd:element name="property" minOccurs="0" maxOccurs="unbounded" type="CT_Property"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Property"> + <xsd:choice minOccurs="1" maxOccurs="1"> + <xsd:element ref="vt:vector"/> + <xsd:element ref="vt:array"/> + <xsd:element ref="vt:blob"/> + <xsd:element ref="vt:oblob"/> + <xsd:element ref="vt:empty"/> + <xsd:element ref="vt:null"/> + <xsd:element ref="vt:i1"/> + <xsd:element ref="vt:i2"/> + <xsd:element ref="vt:i4"/> + <xsd:element ref="vt:i8"/> + <xsd:element ref="vt:int"/> + <xsd:element ref="vt:ui1"/> + <xsd:element ref="vt:ui2"/> + <xsd:element ref="vt:ui4"/> + <xsd:element ref="vt:ui8"/> + <xsd:element ref="vt:uint"/> + <xsd:element ref="vt:r4"/> + <xsd:element ref="vt:r8"/> + <xsd:element ref="vt:decimal"/> + <xsd:element ref="vt:lpstr"/> + <xsd:element ref="vt:lpwstr"/> + <xsd:element ref="vt:bstr"/> + <xsd:element ref="vt:date"/> + <xsd:element ref="vt:filetime"/> + <xsd:element ref="vt:bool"/> + <xsd:element ref="vt:cy"/> + <xsd:element ref="vt:error"/> + <xsd:element ref="vt:stream"/> + <xsd:element ref="vt:ostream"/> + <xsd:element ref="vt:storage"/> + <xsd:element ref="vt:ostorage"/> + <xsd:element ref="vt:vstream"/> + <xsd:element ref="vt:clsid"/> + </xsd:choice> + <xsd:attribute name="fmtid" use="required" type="s:ST_Guid"/> + <xsd:attribute name="pid" use="required" type="xsd:int"/> + <xsd:attribute name="name" use="optional" type="xsd:string"/> + <xsd:attribute name="linkTarget" use="optional" type="xsd:string"/> + </xsd:complexType> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-documentPropertiesExtended.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-documentPropertiesExtended.xsd new file mode 100644 index 00000000..853c341c --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-documentPropertiesExtended.xsd @@ -0,0 +1,56 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" + xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties" + xmlns:vt="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes" + targetNamespace="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties" + elementFormDefault="qualified" blockDefault="#all"> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes" + schemaLocation="shared-documentPropertiesVariantTypes.xsd"/> + <xsd:element name="Properties" type="CT_Properties"/> + <xsd:complexType name="CT_Properties"> + <xsd:all> + <xsd:element name="Template" minOccurs="0" maxOccurs="1" type="xsd:string"/> + <xsd:element name="Manager" minOccurs="0" maxOccurs="1" type="xsd:string"/> + <xsd:element name="Company" minOccurs="0" maxOccurs="1" type="xsd:string"/> + <xsd:element name="Pages" minOccurs="0" maxOccurs="1" type="xsd:int"/> + <xsd:element name="Words" minOccurs="0" maxOccurs="1" type="xsd:int"/> + <xsd:element name="Characters" minOccurs="0" maxOccurs="1" type="xsd:int"/> + <xsd:element name="PresentationFormat" minOccurs="0" maxOccurs="1" type="xsd:string"/> + <xsd:element name="Lines" minOccurs="0" maxOccurs="1" type="xsd:int"/> + <xsd:element name="Paragraphs" minOccurs="0" maxOccurs="1" type="xsd:int"/> + <xsd:element name="Slides" minOccurs="0" maxOccurs="1" type="xsd:int"/> + <xsd:element name="Notes" minOccurs="0" maxOccurs="1" type="xsd:int"/> + <xsd:element name="TotalTime" minOccurs="0" maxOccurs="1" type="xsd:int"/> + <xsd:element name="HiddenSlides" minOccurs="0" maxOccurs="1" type="xsd:int"/> + <xsd:element name="MMClips" minOccurs="0" maxOccurs="1" type="xsd:int"/> + <xsd:element name="ScaleCrop" minOccurs="0" maxOccurs="1" type="xsd:boolean"/> + <xsd:element name="HeadingPairs" minOccurs="0" maxOccurs="1" type="CT_VectorVariant"/> + <xsd:element name="TitlesOfParts" minOccurs="0" maxOccurs="1" type="CT_VectorLpstr"/> + <xsd:element name="LinksUpToDate" minOccurs="0" maxOccurs="1" type="xsd:boolean"/> + <xsd:element name="CharactersWithSpaces" minOccurs="0" maxOccurs="1" type="xsd:int"/> + <xsd:element name="SharedDoc" minOccurs="0" maxOccurs="1" type="xsd:boolean"/> + <xsd:element name="HyperlinkBase" minOccurs="0" maxOccurs="1" type="xsd:string"/> + <xsd:element name="HLinks" minOccurs="0" maxOccurs="1" type="CT_VectorVariant"/> + <xsd:element name="HyperlinksChanged" minOccurs="0" maxOccurs="1" type="xsd:boolean"/> + <xsd:element name="DigSig" minOccurs="0" maxOccurs="1" type="CT_DigSigBlob"/> + <xsd:element name="Application" minOccurs="0" maxOccurs="1" type="xsd:string"/> + <xsd:element name="AppVersion" minOccurs="0" maxOccurs="1" type="xsd:string"/> + <xsd:element name="DocSecurity" minOccurs="0" maxOccurs="1" type="xsd:int"/> + </xsd:all> + </xsd:complexType> + <xsd:complexType name="CT_VectorVariant"> + <xsd:sequence minOccurs="1" maxOccurs="1"> + <xsd:element ref="vt:vector"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_VectorLpstr"> + <xsd:sequence minOccurs="1" maxOccurs="1"> + <xsd:element ref="vt:vector"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_DigSigBlob"> + <xsd:sequence minOccurs="1" maxOccurs="1"> + <xsd:element ref="vt:blob"/> + </xsd:sequence> + </xsd:complexType> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-documentPropertiesVariantTypes.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-documentPropertiesVariantTypes.xsd new file mode 100644 index 00000000..da835ee8 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-documentPropertiesVariantTypes.xsd @@ -0,0 +1,195 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" + xmlns="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes" + xmlns:s="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + targetNamespace="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes" + blockDefault="#all" elementFormDefault="qualified"> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + schemaLocation="shared-commonSimpleTypes.xsd"/> + <xsd:simpleType name="ST_VectorBaseType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="variant"/> + <xsd:enumeration value="i1"/> + <xsd:enumeration value="i2"/> + <xsd:enumeration value="i4"/> + <xsd:enumeration value="i8"/> + <xsd:enumeration value="ui1"/> + <xsd:enumeration value="ui2"/> + <xsd:enumeration value="ui4"/> + <xsd:enumeration value="ui8"/> + <xsd:enumeration value="r4"/> + <xsd:enumeration value="r8"/> + <xsd:enumeration value="lpstr"/> + <xsd:enumeration value="lpwstr"/> + <xsd:enumeration value="bstr"/> + <xsd:enumeration value="date"/> + <xsd:enumeration value="filetime"/> + <xsd:enumeration value="bool"/> + <xsd:enumeration value="cy"/> + <xsd:enumeration value="error"/> + <xsd:enumeration value="clsid"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ArrayBaseType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="variant"/> + <xsd:enumeration value="i1"/> + <xsd:enumeration value="i2"/> + <xsd:enumeration value="i4"/> + <xsd:enumeration value="int"/> + <xsd:enumeration value="ui1"/> + <xsd:enumeration value="ui2"/> + <xsd:enumeration value="ui4"/> + <xsd:enumeration value="uint"/> + <xsd:enumeration value="r4"/> + <xsd:enumeration value="r8"/> + <xsd:enumeration value="decimal"/> + <xsd:enumeration value="bstr"/> + <xsd:enumeration value="date"/> + <xsd:enumeration value="bool"/> + <xsd:enumeration value="cy"/> + <xsd:enumeration value="error"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_Cy"> + <xsd:restriction base="xsd:string"> + <xsd:pattern value="\s*[0-9]*\.[0-9]{4}\s*"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_Error"> + <xsd:restriction base="xsd:string"> + <xsd:pattern value="\s*0x[0-9A-Za-z]{8}\s*"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Empty"/> + <xsd:complexType name="CT_Null"/> + <xsd:complexType name="CT_Vector"> + <xsd:choice minOccurs="1" maxOccurs="unbounded"> + <xsd:element ref="variant"/> + <xsd:element ref="i1"/> + <xsd:element ref="i2"/> + <xsd:element ref="i4"/> + <xsd:element ref="i8"/> + <xsd:element ref="ui1"/> + <xsd:element ref="ui2"/> + <xsd:element ref="ui4"/> + <xsd:element ref="ui8"/> + <xsd:element ref="r4"/> + <xsd:element ref="r8"/> + <xsd:element ref="lpstr"/> + <xsd:element ref="lpwstr"/> + <xsd:element ref="bstr"/> + <xsd:element ref="date"/> + <xsd:element ref="filetime"/> + <xsd:element ref="bool"/> + <xsd:element ref="cy"/> + <xsd:element ref="error"/> + <xsd:element ref="clsid"/> + </xsd:choice> + <xsd:attribute name="baseType" type="ST_VectorBaseType" use="required"/> + <xsd:attribute name="size" type="xsd:unsignedInt" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Array"> + <xsd:choice minOccurs="1" maxOccurs="unbounded"> + <xsd:element ref="variant"/> + <xsd:element ref="i1"/> + <xsd:element ref="i2"/> + <xsd:element ref="i4"/> + <xsd:element ref="int"/> + <xsd:element ref="ui1"/> + <xsd:element ref="ui2"/> + <xsd:element ref="ui4"/> + <xsd:element ref="uint"/> + <xsd:element ref="r4"/> + <xsd:element ref="r8"/> + <xsd:element ref="decimal"/> + <xsd:element ref="bstr"/> + <xsd:element ref="date"/> + <xsd:element ref="bool"/> + <xsd:element ref="error"/> + <xsd:element ref="cy"/> + </xsd:choice> + <xsd:attribute name="lBounds" type="xsd:int" use="required"/> + <xsd:attribute name="uBounds" type="xsd:int" use="required"/> + <xsd:attribute name="baseType" type="ST_ArrayBaseType" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Variant"> + <xsd:choice minOccurs="1" maxOccurs="1"> + <xsd:element ref="variant"/> + <xsd:element ref="vector"/> + <xsd:element ref="array"/> + <xsd:element ref="blob"/> + <xsd:element ref="oblob"/> + <xsd:element ref="empty"/> + <xsd:element ref="null"/> + <xsd:element ref="i1"/> + <xsd:element ref="i2"/> + <xsd:element ref="i4"/> + <xsd:element ref="i8"/> + <xsd:element ref="int"/> + <xsd:element ref="ui1"/> + <xsd:element ref="ui2"/> + <xsd:element ref="ui4"/> + <xsd:element ref="ui8"/> + <xsd:element ref="uint"/> + <xsd:element ref="r4"/> + <xsd:element ref="r8"/> + <xsd:element ref="decimal"/> + <xsd:element ref="lpstr"/> + <xsd:element ref="lpwstr"/> + <xsd:element ref="bstr"/> + <xsd:element ref="date"/> + <xsd:element ref="filetime"/> + <xsd:element ref="bool"/> + <xsd:element ref="cy"/> + <xsd:element ref="error"/> + <xsd:element ref="stream"/> + <xsd:element ref="ostream"/> + <xsd:element ref="storage"/> + <xsd:element ref="ostorage"/> + <xsd:element ref="vstream"/> + <xsd:element ref="clsid"/> + </xsd:choice> + </xsd:complexType> + <xsd:complexType name="CT_Vstream"> + <xsd:simpleContent> + <xsd:extension base="xsd:base64Binary"> + <xsd:attribute name="version" type="s:ST_Guid"/> + </xsd:extension> + </xsd:simpleContent> + </xsd:complexType> + <xsd:element name="variant" type="CT_Variant"/> + <xsd:element name="vector" type="CT_Vector"/> + <xsd:element name="array" type="CT_Array"/> + <xsd:element name="blob" type="xsd:base64Binary"/> + <xsd:element name="oblob" type="xsd:base64Binary"/> + <xsd:element name="empty" type="CT_Empty"/> + <xsd:element name="null" type="CT_Null"/> + <xsd:element name="i1" type="xsd:byte"/> + <xsd:element name="i2" type="xsd:short"/> + <xsd:element name="i4" type="xsd:int"/> + <xsd:element name="i8" type="xsd:long"/> + <xsd:element name="int" type="xsd:int"/> + <xsd:element name="ui1" type="xsd:unsignedByte"/> + <xsd:element name="ui2" type="xsd:unsignedShort"/> + <xsd:element name="ui4" type="xsd:unsignedInt"/> + <xsd:element name="ui8" type="xsd:unsignedLong"/> + <xsd:element name="uint" type="xsd:unsignedInt"/> + <xsd:element name="r4" type="xsd:float"/> + <xsd:element name="r8" type="xsd:double"/> + <xsd:element name="decimal" type="xsd:decimal"/> + <xsd:element name="lpstr" type="xsd:string"/> + <xsd:element name="lpwstr" type="xsd:string"/> + <xsd:element name="bstr" type="xsd:string"/> + <xsd:element name="date" type="xsd:dateTime"/> + <xsd:element name="filetime" type="xsd:dateTime"/> + <xsd:element name="bool" type="xsd:boolean"/> + <xsd:element name="cy" type="ST_Cy"/> + <xsd:element name="error" type="ST_Error"/> + <xsd:element name="stream" type="xsd:base64Binary"/> + <xsd:element name="ostream" type="xsd:base64Binary"/> + <xsd:element name="storage" type="xsd:base64Binary"/> + <xsd:element name="ostorage" type="xsd:base64Binary"/> + <xsd:element name="vstream" type="CT_Vstream"/> + <xsd:element name="clsid" type="s:ST_Guid"/> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-math.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-math.xsd new file mode 100644 index 00000000..87ad2658 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-math.xsd @@ -0,0 +1,582 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" + xmlns="http://schemas.openxmlformats.org/officeDocument/2006/math" + xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math" + xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" + xmlns:s="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + elementFormDefault="qualified" attributeFormDefault="qualified" blockDefault="#all" + targetNamespace="http://schemas.openxmlformats.org/officeDocument/2006/math"> + <xsd:import namespace="http://schemas.openxmlformats.org/wordprocessingml/2006/main" + schemaLocation="wml.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + schemaLocation="shared-commonSimpleTypes.xsd"/> + <xsd:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="xml.xsd"/> + <xsd:simpleType name="ST_Integer255"> + <xsd:restriction base="xsd:integer"> + <xsd:minInclusive value="1"/> + <xsd:maxInclusive value="255"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Integer255"> + <xsd:attribute name="val" type="ST_Integer255" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_Integer2"> + <xsd:restriction base="xsd:integer"> + <xsd:minInclusive value="-2"/> + <xsd:maxInclusive value="2"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Integer2"> + <xsd:attribute name="val" type="ST_Integer2" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_SpacingRule"> + <xsd:restriction base="xsd:integer"> + <xsd:minInclusive value="0"/> + <xsd:maxInclusive value="4"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_SpacingRule"> + <xsd:attribute name="val" type="ST_SpacingRule" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_UnSignedInteger"> + <xsd:restriction base="xsd:unsignedInt"/> + </xsd:simpleType> + <xsd:complexType name="CT_UnSignedInteger"> + <xsd:attribute name="val" type="ST_UnSignedInteger" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_Char"> + <xsd:restriction base="xsd:string"> + <xsd:maxLength value="1"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Char"> + <xsd:attribute name="val" type="ST_Char" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_OnOff"> + <xsd:attribute name="val" type="s:ST_OnOff"/> + </xsd:complexType> + <xsd:complexType name="CT_String"> + <xsd:attribute name="val" type="s:ST_String"/> + </xsd:complexType> + <xsd:complexType name="CT_XAlign"> + <xsd:attribute name="val" type="s:ST_XAlign" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_YAlign"> + <xsd:attribute name="val" type="s:ST_YAlign" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_Shp"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="centered"/> + <xsd:enumeration value="match"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Shp"> + <xsd:attribute name="val" type="ST_Shp" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_FType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="bar"/> + <xsd:enumeration value="skw"/> + <xsd:enumeration value="lin"/> + <xsd:enumeration value="noBar"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_FType"> + <xsd:attribute name="val" type="ST_FType" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_LimLoc"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="undOvr"/> + <xsd:enumeration value="subSup"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_LimLoc"> + <xsd:attribute name="val" type="ST_LimLoc" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_TopBot"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="top"/> + <xsd:enumeration value="bot"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TopBot"> + <xsd:attribute name="val" type="ST_TopBot" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_Script"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="roman"/> + <xsd:enumeration value="script"/> + <xsd:enumeration value="fraktur"/> + <xsd:enumeration value="double-struck"/> + <xsd:enumeration value="sans-serif"/> + <xsd:enumeration value="monospace"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Script"> + <xsd:attribute name="val" type="ST_Script"/> + </xsd:complexType> + <xsd:simpleType name="ST_Style"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="p"/> + <xsd:enumeration value="b"/> + <xsd:enumeration value="i"/> + <xsd:enumeration value="bi"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Style"> + <xsd:attribute name="val" type="ST_Style"/> + </xsd:complexType> + <xsd:complexType name="CT_ManualBreak"> + <xsd:attribute name="alnAt" type="ST_Integer255"/> + </xsd:complexType> + <xsd:group name="EG_ScriptStyle"> + <xsd:sequence> + <xsd:element name="scr" minOccurs="0" type="CT_Script"/> + <xsd:element name="sty" minOccurs="0" type="CT_Style"/> + </xsd:sequence> + </xsd:group> + <xsd:complexType name="CT_RPR"> + <xsd:sequence> + <xsd:element name="lit" minOccurs="0" type="CT_OnOff"/> + <xsd:choice> + <xsd:element name="nor" minOccurs="0" type="CT_OnOff"/> + <xsd:sequence> + <xsd:group ref="EG_ScriptStyle"/> + </xsd:sequence> + </xsd:choice> + <xsd:element name="brk" minOccurs="0" type="CT_ManualBreak"/> + <xsd:element name="aln" minOccurs="0" type="CT_OnOff"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Text"> + <xsd:simpleContent> + <xsd:extension base="s:ST_String"> + <xsd:attribute ref="xml:space" use="optional"/> + </xsd:extension> + </xsd:simpleContent> + </xsd:complexType> + <xsd:complexType name="CT_R"> + <xsd:sequence> + <xsd:element name="rPr" type="CT_RPR" minOccurs="0"/> + <xsd:group ref="w:EG_RPr" minOccurs="0"/> + <xsd:choice minOccurs="0" maxOccurs="unbounded"> + <xsd:group ref="w:EG_RunInnerContent"/> + <xsd:element name="t" type="CT_Text" minOccurs="0"/> + </xsd:choice> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_CtrlPr"> + <xsd:sequence> + <xsd:group ref="w:EG_RPrMath" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_AccPr"> + <xsd:sequence> + <xsd:element name="chr" type="CT_Char" minOccurs="0"/> + <xsd:element name="ctrlPr" type="CT_CtrlPr" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Acc"> + <xsd:sequence> + <xsd:element name="accPr" type="CT_AccPr" minOccurs="0"/> + <xsd:element name="e" type="CT_OMathArg"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_BarPr"> + <xsd:sequence> + <xsd:element name="pos" type="CT_TopBot" minOccurs="0"/> + <xsd:element name="ctrlPr" type="CT_CtrlPr" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Bar"> + <xsd:sequence> + <xsd:element name="barPr" type="CT_BarPr" minOccurs="0"/> + <xsd:element name="e" type="CT_OMathArg"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_BoxPr"> + <xsd:sequence> + <xsd:element name="opEmu" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="noBreak" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="diff" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="brk" type="CT_ManualBreak" minOccurs="0"/> + <xsd:element name="aln" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="ctrlPr" type="CT_CtrlPr" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Box"> + <xsd:sequence> + <xsd:element name="boxPr" type="CT_BoxPr" minOccurs="0"/> + <xsd:element name="e" type="CT_OMathArg"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_BorderBoxPr"> + <xsd:sequence> + <xsd:element name="hideTop" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="hideBot" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="hideLeft" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="hideRight" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="strikeH" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="strikeV" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="strikeBLTR" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="strikeTLBR" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="ctrlPr" type="CT_CtrlPr" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_BorderBox"> + <xsd:sequence> + <xsd:element name="borderBoxPr" type="CT_BorderBoxPr" minOccurs="0"/> + <xsd:element name="e" type="CT_OMathArg"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_DPr"> + <xsd:sequence> + <xsd:element name="begChr" type="CT_Char" minOccurs="0"/> + <xsd:element name="sepChr" type="CT_Char" minOccurs="0"/> + <xsd:element name="endChr" type="CT_Char" minOccurs="0"/> + <xsd:element name="grow" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="shp" type="CT_Shp" minOccurs="0"/> + <xsd:element name="ctrlPr" type="CT_CtrlPr" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_D"> + <xsd:sequence> + <xsd:element name="dPr" type="CT_DPr" minOccurs="0"/> + <xsd:element name="e" type="CT_OMathArg" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_EqArrPr"> + <xsd:sequence> + <xsd:element name="baseJc" type="CT_YAlign" minOccurs="0"/> + <xsd:element name="maxDist" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="objDist" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="rSpRule" type="CT_SpacingRule" minOccurs="0"/> + <xsd:element name="rSp" type="CT_UnSignedInteger" minOccurs="0"/> + <xsd:element name="ctrlPr" type="CT_CtrlPr" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_EqArr"> + <xsd:sequence> + <xsd:element name="eqArrPr" type="CT_EqArrPr" minOccurs="0"/> + <xsd:element name="e" type="CT_OMathArg" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_FPr"> + <xsd:sequence> + <xsd:element name="type" type="CT_FType" minOccurs="0"/> + <xsd:element name="ctrlPr" type="CT_CtrlPr" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_F"> + <xsd:sequence> + <xsd:element name="fPr" type="CT_FPr" minOccurs="0"/> + <xsd:element name="num" type="CT_OMathArg"/> + <xsd:element name="den" type="CT_OMathArg"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_FuncPr"> + <xsd:sequence> + <xsd:element name="ctrlPr" type="CT_CtrlPr" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Func"> + <xsd:sequence> + <xsd:element name="funcPr" type="CT_FuncPr" minOccurs="0"/> + <xsd:element name="fName" type="CT_OMathArg"/> + <xsd:element name="e" type="CT_OMathArg"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_GroupChrPr"> + <xsd:sequence> + <xsd:element name="chr" type="CT_Char" minOccurs="0"/> + <xsd:element name="pos" type="CT_TopBot" minOccurs="0"/> + <xsd:element name="vertJc" type="CT_TopBot" minOccurs="0"/> + <xsd:element name="ctrlPr" type="CT_CtrlPr" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_GroupChr"> + <xsd:sequence> + <xsd:element name="groupChrPr" type="CT_GroupChrPr" minOccurs="0"/> + <xsd:element name="e" type="CT_OMathArg"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_LimLowPr"> + <xsd:sequence> + <xsd:element name="ctrlPr" type="CT_CtrlPr" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_LimLow"> + <xsd:sequence> + <xsd:element name="limLowPr" type="CT_LimLowPr" minOccurs="0"/> + <xsd:element name="e" type="CT_OMathArg"/> + <xsd:element name="lim" type="CT_OMathArg"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_LimUppPr"> + <xsd:sequence> + <xsd:element name="ctrlPr" type="CT_CtrlPr" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_LimUpp"> + <xsd:sequence> + <xsd:element name="limUppPr" type="CT_LimUppPr" minOccurs="0"/> + <xsd:element name="e" type="CT_OMathArg"/> + <xsd:element name="lim" type="CT_OMathArg"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_MCPr"> + <xsd:sequence> + <xsd:element name="count" type="CT_Integer255" minOccurs="0"/> + <xsd:element name="mcJc" type="CT_XAlign" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_MC"> + <xsd:sequence> + <xsd:element name="mcPr" type="CT_MCPr" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_MCS"> + <xsd:sequence> + <xsd:element name="mc" type="CT_MC" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_MPr"> + <xsd:sequence> + <xsd:element name="baseJc" type="CT_YAlign" minOccurs="0"/> + <xsd:element name="plcHide" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="rSpRule" type="CT_SpacingRule" minOccurs="0"/> + <xsd:element name="cGpRule" type="CT_SpacingRule" minOccurs="0"/> + <xsd:element name="rSp" type="CT_UnSignedInteger" minOccurs="0"/> + <xsd:element name="cSp" type="CT_UnSignedInteger" minOccurs="0"/> + <xsd:element name="cGp" type="CT_UnSignedInteger" minOccurs="0"/> + <xsd:element name="mcs" type="CT_MCS" minOccurs="0"/> + <xsd:element name="ctrlPr" type="CT_CtrlPr" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_MR"> + <xsd:sequence> + <xsd:element name="e" type="CT_OMathArg" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_M"> + <xsd:sequence> + <xsd:element name="mPr" type="CT_MPr" minOccurs="0"/> + <xsd:element name="mr" type="CT_MR" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_NaryPr"> + <xsd:sequence> + <xsd:element name="chr" type="CT_Char" minOccurs="0"/> + <xsd:element name="limLoc" type="CT_LimLoc" minOccurs="0"/> + <xsd:element name="grow" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="subHide" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="supHide" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="ctrlPr" type="CT_CtrlPr" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Nary"> + <xsd:sequence> + <xsd:element name="naryPr" type="CT_NaryPr" minOccurs="0"/> + <xsd:element name="sub" type="CT_OMathArg"/> + <xsd:element name="sup" type="CT_OMathArg"/> + <xsd:element name="e" type="CT_OMathArg"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_PhantPr"> + <xsd:sequence> + <xsd:element name="show" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="zeroWid" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="zeroAsc" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="zeroDesc" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="transp" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="ctrlPr" type="CT_CtrlPr" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Phant"> + <xsd:sequence> + <xsd:element name="phantPr" type="CT_PhantPr" minOccurs="0"/> + <xsd:element name="e" type="CT_OMathArg"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_RadPr"> + <xsd:sequence> + <xsd:element name="degHide" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="ctrlPr" type="CT_CtrlPr" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Rad"> + <xsd:sequence> + <xsd:element name="radPr" type="CT_RadPr" minOccurs="0"/> + <xsd:element name="deg" type="CT_OMathArg"/> + <xsd:element name="e" type="CT_OMathArg"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SPrePr"> + <xsd:sequence> + <xsd:element name="ctrlPr" type="CT_CtrlPr" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SPre"> + <xsd:sequence> + <xsd:element name="sPrePr" type="CT_SPrePr" minOccurs="0"/> + <xsd:element name="sub" type="CT_OMathArg"/> + <xsd:element name="sup" type="CT_OMathArg"/> + <xsd:element name="e" type="CT_OMathArg"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SSubPr"> + <xsd:sequence> + <xsd:element name="ctrlPr" type="CT_CtrlPr" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SSub"> + <xsd:sequence> + <xsd:element name="sSubPr" type="CT_SSubPr" minOccurs="0"/> + <xsd:element name="e" type="CT_OMathArg"/> + <xsd:element name="sub" type="CT_OMathArg"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SSubSupPr"> + <xsd:sequence> + <xsd:element name="alnScr" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="ctrlPr" type="CT_CtrlPr" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SSubSup"> + <xsd:sequence> + <xsd:element name="sSubSupPr" type="CT_SSubSupPr" minOccurs="0"/> + <xsd:element name="e" type="CT_OMathArg"/> + <xsd:element name="sub" type="CT_OMathArg"/> + <xsd:element name="sup" type="CT_OMathArg"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SSupPr"> + <xsd:sequence> + <xsd:element name="ctrlPr" type="CT_CtrlPr" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SSup"> + <xsd:sequence> + <xsd:element name="sSupPr" type="CT_SSupPr" minOccurs="0"/> + <xsd:element name="e" type="CT_OMathArg"/> + <xsd:element name="sup" type="CT_OMathArg"/> + </xsd:sequence> + </xsd:complexType> + <xsd:group name="EG_OMathMathElements"> + <xsd:choice> + <xsd:element name="acc" type="CT_Acc"/> + <xsd:element name="bar" type="CT_Bar"/> + <xsd:element name="box" type="CT_Box"/> + <xsd:element name="borderBox" type="CT_BorderBox"/> + <xsd:element name="d" type="CT_D"/> + <xsd:element name="eqArr" type="CT_EqArr"/> + <xsd:element name="f" type="CT_F"/> + <xsd:element name="func" type="CT_Func"/> + <xsd:element name="groupChr" type="CT_GroupChr"/> + <xsd:element name="limLow" type="CT_LimLow"/> + <xsd:element name="limUpp" type="CT_LimUpp"/> + <xsd:element name="m" type="CT_M"/> + <xsd:element name="nary" type="CT_Nary"/> + <xsd:element name="phant" type="CT_Phant"/> + <xsd:element name="rad" type="CT_Rad"/> + <xsd:element name="sPre" type="CT_SPre"/> + <xsd:element name="sSub" type="CT_SSub"/> + <xsd:element name="sSubSup" type="CT_SSubSup"/> + <xsd:element name="sSup" type="CT_SSup"/> + <xsd:element name="r" type="CT_R"/> + </xsd:choice> + </xsd:group> + <xsd:group name="EG_OMathElements"> + <xsd:choice> + <xsd:group ref="EG_OMathMathElements"/> + <xsd:group ref="w:EG_PContentMath"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_OMathArgPr"> + <xsd:sequence> + <xsd:element name="argSz" type="CT_Integer2" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_OMathArg"> + <xsd:sequence> + <xsd:element name="argPr" type="CT_OMathArgPr" minOccurs="0"/> + <xsd:group ref="EG_OMathElements" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="ctrlPr" type="CT_CtrlPr" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_Jc"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="left"/> + <xsd:enumeration value="right"/> + <xsd:enumeration value="center"/> + <xsd:enumeration value="centerGroup"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_OMathJc"> + <xsd:attribute name="val" type="ST_Jc"/> + </xsd:complexType> + <xsd:complexType name="CT_OMathParaPr"> + <xsd:sequence> + <xsd:element name="jc" type="CT_OMathJc" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TwipsMeasure"> + <xsd:attribute name="val" type="s:ST_TwipsMeasure" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_BreakBin"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="before"/> + <xsd:enumeration value="after"/> + <xsd:enumeration value="repeat"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_BreakBin"> + <xsd:attribute name="val" type="ST_BreakBin"/> + </xsd:complexType> + <xsd:simpleType name="ST_BreakBinSub"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="--"/> + <xsd:enumeration value="-+"/> + <xsd:enumeration value="+-"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_BreakBinSub"> + <xsd:attribute name="val" type="ST_BreakBinSub"/> + </xsd:complexType> + <xsd:complexType name="CT_MathPr"> + <xsd:sequence> + <xsd:element name="mathFont" type="CT_String" minOccurs="0"/> + <xsd:element name="brkBin" type="CT_BreakBin" minOccurs="0"/> + <xsd:element name="brkBinSub" type="CT_BreakBinSub" minOccurs="0"/> + <xsd:element name="smallFrac" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="dispDef" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="lMargin" type="CT_TwipsMeasure" minOccurs="0"/> + <xsd:element name="rMargin" type="CT_TwipsMeasure" minOccurs="0"/> + <xsd:element name="defJc" type="CT_OMathJc" minOccurs="0"/> + <xsd:element name="preSp" type="CT_TwipsMeasure" minOccurs="0"/> + <xsd:element name="postSp" type="CT_TwipsMeasure" minOccurs="0"/> + <xsd:element name="interSp" type="CT_TwipsMeasure" minOccurs="0"/> + <xsd:element name="intraSp" type="CT_TwipsMeasure" minOccurs="0"/> + <xsd:choice minOccurs="0"> + <xsd:element name="wrapIndent" type="CT_TwipsMeasure"/> + <xsd:element name="wrapRight" type="CT_OnOff"/> + </xsd:choice> + <xsd:element name="intLim" type="CT_LimLoc" minOccurs="0"/> + <xsd:element name="naryLim" type="CT_LimLoc" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="mathPr" type="CT_MathPr"/> + <xsd:complexType name="CT_OMathPara"> + <xsd:sequence> + <xsd:element name="oMathParaPr" type="CT_OMathParaPr" minOccurs="0"/> + <xsd:element name="oMath" type="CT_OMath" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_OMath"> + <xsd:sequence> + <xsd:group ref="EG_OMathElements" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="oMathPara" type="CT_OMathPara"/> + <xsd:element name="oMath" type="CT_OMath"/> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-relationshipReference.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-relationshipReference.xsd new file mode 100644 index 00000000..9e86f1b2 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/shared-relationshipReference.xsd @@ -0,0 +1,25 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" + xmlns="http://schemas.openxmlformats.org/officeDocument/2006/relationships" + xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" + elementFormDefault="qualified" + targetNamespace="http://schemas.openxmlformats.org/officeDocument/2006/relationships" + blockDefault="#all"> + <xsd:simpleType name="ST_RelationshipId"> + <xsd:restriction base="xsd:string"/> + </xsd:simpleType> + <xsd:attribute name="id" type="ST_RelationshipId"/> + <xsd:attribute name="embed" type="ST_RelationshipId"/> + <xsd:attribute name="link" type="ST_RelationshipId"/> + <xsd:attribute name="dm" type="ST_RelationshipId" default=""/> + <xsd:attribute name="lo" type="ST_RelationshipId" default=""/> + <xsd:attribute name="qs" type="ST_RelationshipId" default=""/> + <xsd:attribute name="cs" type="ST_RelationshipId" default=""/> + <xsd:attribute name="blip" type="ST_RelationshipId" default=""/> + <xsd:attribute name="pict" type="ST_RelationshipId"/> + <xsd:attribute name="href" type="ST_RelationshipId"/> + <xsd:attribute name="topLeft" type="ST_RelationshipId"/> + <xsd:attribute name="topRight" type="ST_RelationshipId"/> + <xsd:attribute name="bottomLeft" type="ST_RelationshipId"/> + <xsd:attribute name="bottomRight" type="ST_RelationshipId"/> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/sml.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/sml.xsd new file mode 100644 index 00000000..d0be42e7 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/sml.xsd @@ -0,0 +1,4439 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" + xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" + xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" + xmlns:xdr="http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing" + xmlns:s="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + targetNamespace="http://schemas.openxmlformats.org/spreadsheetml/2006/main" + elementFormDefault="qualified"> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/relationships" + schemaLocation="shared-relationshipReference.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + schemaLocation="shared-commonSimpleTypes.xsd"/> + <xsd:import + namespace="http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing" + schemaLocation="dml-spreadsheetDrawing.xsd"/> + <xsd:complexType name="CT_AutoFilter"> + <xsd:sequence> + <xsd:element name="filterColumn" minOccurs="0" maxOccurs="unbounded" type="CT_FilterColumn"/> + <xsd:element name="sortState" minOccurs="0" maxOccurs="1" type="CT_SortState"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="ref" type="ST_Ref"/> + </xsd:complexType> + <xsd:complexType name="CT_FilterColumn"> + <xsd:choice minOccurs="0" maxOccurs="1"> + <xsd:element name="filters" type="CT_Filters" minOccurs="0" maxOccurs="1"/> + <xsd:element name="top10" type="CT_Top10" minOccurs="0" maxOccurs="1"/> + <xsd:element name="customFilters" type="CT_CustomFilters" minOccurs="0" maxOccurs="1"/> + <xsd:element name="dynamicFilter" type="CT_DynamicFilter" minOccurs="0" maxOccurs="1"/> + <xsd:element name="colorFilter" type="CT_ColorFilter" minOccurs="0" maxOccurs="1"/> + <xsd:element name="iconFilter" minOccurs="0" maxOccurs="1" type="CT_IconFilter"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:choice> + <xsd:attribute name="colId" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="hiddenButton" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="showButton" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_Filters"> + <xsd:sequence> + <xsd:element name="filter" type="CT_Filter" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="dateGroupItem" type="CT_DateGroupItem" minOccurs="0" maxOccurs="unbounded" + /> + </xsd:sequence> + <xsd:attribute name="blank" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="calendarType" type="s:ST_CalendarType" use="optional" default="none"/> + </xsd:complexType> + <xsd:complexType name="CT_Filter"> + <xsd:attribute name="val" type="s:ST_Xstring"/> + </xsd:complexType> + <xsd:complexType name="CT_CustomFilters"> + <xsd:sequence> + <xsd:element name="customFilter" type="CT_CustomFilter" minOccurs="1" maxOccurs="2"/> + </xsd:sequence> + <xsd:attribute name="and" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_CustomFilter"> + <xsd:attribute name="operator" type="ST_FilterOperator" default="equal" use="optional"/> + <xsd:attribute name="val" type="s:ST_Xstring"/> + </xsd:complexType> + <xsd:complexType name="CT_Top10"> + <xsd:attribute name="top" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="percent" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="val" type="xsd:double" use="required"/> + <xsd:attribute name="filterVal" type="xsd:double" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_ColorFilter"> + <xsd:attribute name="dxfId" type="ST_DxfId" use="optional"/> + <xsd:attribute name="cellColor" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_IconFilter"> + <xsd:attribute name="iconSet" type="ST_IconSetType" use="required"/> + <xsd:attribute name="iconId" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_FilterOperator"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="equal"/> + <xsd:enumeration value="lessThan"/> + <xsd:enumeration value="lessThanOrEqual"/> + <xsd:enumeration value="notEqual"/> + <xsd:enumeration value="greaterThanOrEqual"/> + <xsd:enumeration value="greaterThan"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_DynamicFilter"> + <xsd:attribute name="type" type="ST_DynamicFilterType" use="required"/> + <xsd:attribute name="val" type="xsd:double" use="optional"/> + <xsd:attribute name="valIso" type="xsd:dateTime" use="optional"/> + <xsd:attribute name="maxVal" type="xsd:double" use="optional"/> + <xsd:attribute name="maxValIso" type="xsd:dateTime" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_DynamicFilterType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="null"/> + <xsd:enumeration value="aboveAverage"/> + <xsd:enumeration value="belowAverage"/> + <xsd:enumeration value="tomorrow"/> + <xsd:enumeration value="today"/> + <xsd:enumeration value="yesterday"/> + <xsd:enumeration value="nextWeek"/> + <xsd:enumeration value="thisWeek"/> + <xsd:enumeration value="lastWeek"/> + <xsd:enumeration value="nextMonth"/> + <xsd:enumeration value="thisMonth"/> + <xsd:enumeration value="lastMonth"/> + <xsd:enumeration value="nextQuarter"/> + <xsd:enumeration value="thisQuarter"/> + <xsd:enumeration value="lastQuarter"/> + <xsd:enumeration value="nextYear"/> + <xsd:enumeration value="thisYear"/> + <xsd:enumeration value="lastYear"/> + <xsd:enumeration value="yearToDate"/> + <xsd:enumeration value="Q1"/> + <xsd:enumeration value="Q2"/> + <xsd:enumeration value="Q3"/> + <xsd:enumeration value="Q4"/> + <xsd:enumeration value="M1"/> + <xsd:enumeration value="M2"/> + <xsd:enumeration value="M3"/> + <xsd:enumeration value="M4"/> + <xsd:enumeration value="M5"/> + <xsd:enumeration value="M6"/> + <xsd:enumeration value="M7"/> + <xsd:enumeration value="M8"/> + <xsd:enumeration value="M9"/> + <xsd:enumeration value="M10"/> + <xsd:enumeration value="M11"/> + <xsd:enumeration value="M12"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_IconSetType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="3Arrows"/> + <xsd:enumeration value="3ArrowsGray"/> + <xsd:enumeration value="3Flags"/> + <xsd:enumeration value="3TrafficLights1"/> + <xsd:enumeration value="3TrafficLights2"/> + <xsd:enumeration value="3Signs"/> + <xsd:enumeration value="3Symbols"/> + <xsd:enumeration value="3Symbols2"/> + <xsd:enumeration value="4Arrows"/> + <xsd:enumeration value="4ArrowsGray"/> + <xsd:enumeration value="4RedToBlack"/> + <xsd:enumeration value="4Rating"/> + <xsd:enumeration value="4TrafficLights"/> + <xsd:enumeration value="5Arrows"/> + <xsd:enumeration value="5ArrowsGray"/> + <xsd:enumeration value="5Rating"/> + <xsd:enumeration value="5Quarters"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_SortState"> + <xsd:sequence> + <xsd:element name="sortCondition" minOccurs="0" maxOccurs="64" type="CT_SortCondition"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="columnSort" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="caseSensitive" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="sortMethod" type="ST_SortMethod" use="optional" default="none"/> + <xsd:attribute name="ref" type="ST_Ref" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_SortCondition"> + <xsd:attribute name="descending" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="sortBy" type="ST_SortBy" use="optional" default="value"/> + <xsd:attribute name="ref" type="ST_Ref" use="required"/> + <xsd:attribute name="customList" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="dxfId" type="ST_DxfId" use="optional"/> + <xsd:attribute name="iconSet" type="ST_IconSetType" use="optional" default="3Arrows"/> + <xsd:attribute name="iconId" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_SortBy"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="value"/> + <xsd:enumeration value="cellColor"/> + <xsd:enumeration value="fontColor"/> + <xsd:enumeration value="icon"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_SortMethod"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="stroke"/> + <xsd:enumeration value="pinYin"/> + <xsd:enumeration value="none"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_DateGroupItem"> + <xsd:attribute name="year" type="xsd:unsignedShort" use="required"/> + <xsd:attribute name="month" type="xsd:unsignedShort" use="optional"/> + <xsd:attribute name="day" type="xsd:unsignedShort" use="optional"/> + <xsd:attribute name="hour" type="xsd:unsignedShort" use="optional"/> + <xsd:attribute name="minute" type="xsd:unsignedShort" use="optional"/> + <xsd:attribute name="second" type="xsd:unsignedShort" use="optional"/> + <xsd:attribute name="dateTimeGrouping" type="ST_DateTimeGrouping" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_DateTimeGrouping"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="year"/> + <xsd:enumeration value="month"/> + <xsd:enumeration value="day"/> + <xsd:enumeration value="hour"/> + <xsd:enumeration value="minute"/> + <xsd:enumeration value="second"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_CellRef"> + <xsd:restriction base="xsd:string"/> + </xsd:simpleType> + <xsd:simpleType name="ST_Ref"> + <xsd:restriction base="xsd:string"/> + </xsd:simpleType> + <xsd:simpleType name="ST_RefA"> + <xsd:restriction base="xsd:string"/> + </xsd:simpleType> + <xsd:simpleType name="ST_Sqref"> + <xsd:list itemType="ST_Ref"/> + </xsd:simpleType> + <xsd:simpleType name="ST_Formula"> + <xsd:restriction base="s:ST_Xstring"/> + </xsd:simpleType> + <xsd:simpleType name="ST_UnsignedIntHex"> + <xsd:restriction base="xsd:hexBinary"> + <xsd:length value="4"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_UnsignedShortHex"> + <xsd:restriction base="xsd:hexBinary"> + <xsd:length value="2"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_XStringElement"> + <xsd:attribute name="v" type="s:ST_Xstring" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Extension"> + <xsd:sequence> + <xsd:any processContents="lax"/> + </xsd:sequence> + <xsd:attribute name="uri" type="xsd:token"/> + </xsd:complexType> + <xsd:complexType name="CT_ObjectAnchor"> + <xsd:sequence> + <xsd:element ref="xdr:from" minOccurs="1" maxOccurs="1"/> + <xsd:element ref="xdr:to" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="moveWithCells" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="sizeWithCells" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:group name="EG_ExtensionList"> + <xsd:sequence> + <xsd:element name="ext" type="CT_Extension" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:group> + <xsd:complexType name="CT_ExtensionList"> + <xsd:sequence> + <xsd:group ref="EG_ExtensionList" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="calcChain" type="CT_CalcChain"/> + <xsd:complexType name="CT_CalcChain"> + <xsd:sequence> + <xsd:element name="c" type="CT_CalcCell" minOccurs="1" maxOccurs="unbounded"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_CalcCell"> + <xsd:attribute name="r" type="ST_CellRef" use="optional"/> + <xsd:attribute name="ref" type="ST_CellRef" use="optional"/> + <xsd:attribute name="i" type="xsd:int" use="optional" default="0"/> + <xsd:attribute name="s" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="l" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="t" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="a" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:element name="comments" type="CT_Comments"/> + <xsd:complexType name="CT_Comments"> + <xsd:sequence> + <xsd:element name="authors" type="CT_Authors" minOccurs="1" maxOccurs="1"/> + <xsd:element name="commentList" type="CT_CommentList" minOccurs="1" maxOccurs="1"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Authors"> + <xsd:sequence> + <xsd:element name="author" type="s:ST_Xstring" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_CommentList"> + <xsd:sequence> + <xsd:element name="comment" type="CT_Comment" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Comment"> + <xsd:sequence> + <xsd:element name="text" type="CT_Rst" minOccurs="1" maxOccurs="1"/> + <xsd:element name="commentPr" type="CT_CommentPr" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="ref" type="ST_Ref" use="required"/> + <xsd:attribute name="authorId" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="guid" type="s:ST_Guid" use="optional"/> + <xsd:attribute name="shapeId" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_CommentPr"> + <xsd:sequence> + <xsd:element name="anchor" type="CT_ObjectAnchor" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="locked" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="defaultSize" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="print" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="disabled" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="autoFill" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="autoLine" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="altText" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="textHAlign" type="ST_TextHAlign" use="optional" default="left"/> + <xsd:attribute name="textVAlign" type="ST_TextVAlign" use="optional" default="top"/> + <xsd:attribute name="lockText" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="justLastX" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="autoScale" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:simpleType name="ST_TextHAlign"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="left"/> + <xsd:enumeration value="center"/> + <xsd:enumeration value="right"/> + <xsd:enumeration value="justify"/> + <xsd:enumeration value="distributed"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TextVAlign"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="top"/> + <xsd:enumeration value="center"/> + <xsd:enumeration value="bottom"/> + <xsd:enumeration value="justify"/> + <xsd:enumeration value="distributed"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:element name="MapInfo" type="CT_MapInfo"/> + <xsd:complexType name="CT_MapInfo"> + <xsd:sequence> + <xsd:element name="Schema" type="CT_Schema" minOccurs="1" maxOccurs="unbounded"/> + <xsd:element name="Map" type="CT_Map" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="SelectionNamespaces" type="xsd:string" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Schema" mixed="true"> + <xsd:sequence> + <xsd:any/> + </xsd:sequence> + <xsd:attribute name="ID" type="xsd:string" use="required"/> + <xsd:attribute name="SchemaRef" type="xsd:string" use="optional"/> + <xsd:attribute name="Namespace" type="xsd:string" use="optional"/> + <xsd:attribute name="SchemaLanguage" type="xsd:token" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Map"> + <xsd:sequence> + <xsd:element name="DataBinding" type="CT_DataBinding" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="ID" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="Name" type="xsd:string" use="required"/> + <xsd:attribute name="RootElement" type="xsd:string" use="required"/> + <xsd:attribute name="SchemaID" type="xsd:string" use="required"/> + <xsd:attribute name="ShowImportExportValidationErrors" type="xsd:boolean" use="required"/> + <xsd:attribute name="AutoFit" type="xsd:boolean" use="required"/> + <xsd:attribute name="Append" type="xsd:boolean" use="required"/> + <xsd:attribute name="PreserveSortAFLayout" type="xsd:boolean" use="required"/> + <xsd:attribute name="PreserveFormat" type="xsd:boolean" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_DataBinding"> + <xsd:sequence> + <xsd:any/> + </xsd:sequence> + <xsd:attribute name="DataBindingName" type="xsd:string" use="optional"/> + <xsd:attribute name="FileBinding" type="xsd:boolean" use="optional"/> + <xsd:attribute name="ConnectionID" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="FileBindingName" type="xsd:string" use="optional"/> + <xsd:attribute name="DataBindingLoadMode" type="xsd:unsignedInt" use="required"/> + </xsd:complexType> + <xsd:element name="connections" type="CT_Connections"/> + <xsd:complexType name="CT_Connections"> + <xsd:sequence> + <xsd:element name="connection" minOccurs="1" maxOccurs="unbounded" type="CT_Connection"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Connection"> + <xsd:sequence> + <xsd:element name="dbPr" minOccurs="0" maxOccurs="1" type="CT_DbPr"/> + <xsd:element name="olapPr" minOccurs="0" maxOccurs="1" type="CT_OlapPr"/> + <xsd:element name="webPr" minOccurs="0" maxOccurs="1" type="CT_WebPr"/> + <xsd:element name="textPr" minOccurs="0" maxOccurs="1" type="CT_TextPr"/> + <xsd:element name="parameters" minOccurs="0" maxOccurs="1" type="CT_Parameters"/> + <xsd:element name="extLst" minOccurs="0" maxOccurs="1" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="id" use="required" type="xsd:unsignedInt"/> + <xsd:attribute name="sourceFile" use="optional" type="s:ST_Xstring"/> + <xsd:attribute name="odcFile" use="optional" type="s:ST_Xstring"/> + <xsd:attribute name="keepAlive" use="optional" type="xsd:boolean" default="false"/> + <xsd:attribute name="interval" use="optional" type="xsd:unsignedInt" default="0"/> + <xsd:attribute name="name" use="optional" type="s:ST_Xstring"/> + <xsd:attribute name="description" use="optional" type="s:ST_Xstring"/> + <xsd:attribute name="type" use="optional" type="xsd:unsignedInt"/> + <xsd:attribute name="reconnectionMethod" use="optional" type="xsd:unsignedInt" default="1"/> + <xsd:attribute name="refreshedVersion" use="required" type="xsd:unsignedByte"/> + <xsd:attribute name="minRefreshableVersion" use="optional" type="xsd:unsignedByte" default="0"/> + <xsd:attribute name="savePassword" use="optional" type="xsd:boolean" default="false"/> + <xsd:attribute name="new" use="optional" type="xsd:boolean" default="false"/> + <xsd:attribute name="deleted" use="optional" type="xsd:boolean" default="false"/> + <xsd:attribute name="onlyUseConnectionFile" use="optional" type="xsd:boolean" default="false"/> + <xsd:attribute name="background" use="optional" type="xsd:boolean" default="false"/> + <xsd:attribute name="refreshOnLoad" use="optional" type="xsd:boolean" default="false"/> + <xsd:attribute name="saveData" use="optional" type="xsd:boolean" default="false"/> + <xsd:attribute name="credentials" use="optional" type="ST_CredMethod" default="integrated"/> + <xsd:attribute name="singleSignOnId" use="optional" type="s:ST_Xstring"/> + </xsd:complexType> + <xsd:simpleType name="ST_CredMethod"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="integrated"/> + <xsd:enumeration value="none"/> + <xsd:enumeration value="stored"/> + <xsd:enumeration value="prompt"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_DbPr"> + <xsd:attribute name="connection" use="required" type="s:ST_Xstring"/> + <xsd:attribute name="command" use="optional" type="s:ST_Xstring"/> + <xsd:attribute name="serverCommand" use="optional" type="s:ST_Xstring"/> + <xsd:attribute name="commandType" use="optional" type="xsd:unsignedInt" default="2"/> + </xsd:complexType> + <xsd:complexType name="CT_OlapPr"> + <xsd:attribute name="local" use="optional" type="xsd:boolean" default="false"/> + <xsd:attribute name="localConnection" use="optional" type="s:ST_Xstring"/> + <xsd:attribute name="localRefresh" use="optional" type="xsd:boolean" default="true"/> + <xsd:attribute name="sendLocale" use="optional" type="xsd:boolean" default="false"/> + <xsd:attribute name="rowDrillCount" use="optional" type="xsd:unsignedInt"/> + <xsd:attribute name="serverFill" use="optional" type="xsd:boolean" default="true"/> + <xsd:attribute name="serverNumberFormat" use="optional" type="xsd:boolean" default="true"/> + <xsd:attribute name="serverFont" use="optional" type="xsd:boolean" default="true"/> + <xsd:attribute name="serverFontColor" use="optional" type="xsd:boolean" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_WebPr"> + <xsd:sequence> + <xsd:element name="tables" minOccurs="0" maxOccurs="1" type="CT_Tables"/> + </xsd:sequence> + <xsd:attribute name="xml" use="optional" type="xsd:boolean" default="false"/> + <xsd:attribute name="sourceData" use="optional" type="xsd:boolean" default="false"/> + <xsd:attribute name="parsePre" use="optional" type="xsd:boolean" default="false"/> + <xsd:attribute name="consecutive" use="optional" type="xsd:boolean" default="false"/> + <xsd:attribute name="firstRow" use="optional" type="xsd:boolean" default="false"/> + <xsd:attribute name="xl97" use="optional" type="xsd:boolean" default="false"/> + <xsd:attribute name="textDates" use="optional" type="xsd:boolean" default="false"/> + <xsd:attribute name="xl2000" use="optional" type="xsd:boolean" default="false"/> + <xsd:attribute name="url" use="optional" type="s:ST_Xstring"/> + <xsd:attribute name="post" use="optional" type="s:ST_Xstring"/> + <xsd:attribute name="htmlTables" use="optional" type="xsd:boolean" default="false"/> + <xsd:attribute name="htmlFormat" use="optional" type="ST_HtmlFmt" default="none"/> + <xsd:attribute name="editPage" use="optional" type="s:ST_Xstring"/> + </xsd:complexType> + <xsd:simpleType name="ST_HtmlFmt"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="rtf"/> + <xsd:enumeration value="all"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Parameters"> + <xsd:sequence> + <xsd:element name="parameter" minOccurs="1" maxOccurs="unbounded" type="CT_Parameter"/> + </xsd:sequence> + <xsd:attribute name="count" use="optional" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_Parameter"> + <xsd:attribute name="name" use="optional" type="s:ST_Xstring"/> + <xsd:attribute name="sqlType" use="optional" type="xsd:int" default="0"/> + <xsd:attribute name="parameterType" use="optional" type="ST_ParameterType" default="prompt"/> + <xsd:attribute name="refreshOnChange" use="optional" type="xsd:boolean" default="false"/> + <xsd:attribute name="prompt" use="optional" type="s:ST_Xstring"/> + <xsd:attribute name="boolean" use="optional" type="xsd:boolean"/> + <xsd:attribute name="double" use="optional" type="xsd:double"/> + <xsd:attribute name="integer" use="optional" type="xsd:int"/> + <xsd:attribute name="string" use="optional" type="s:ST_Xstring"/> + <xsd:attribute name="cell" use="optional" type="s:ST_Xstring"/> + </xsd:complexType> + <xsd:simpleType name="ST_ParameterType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="prompt"/> + <xsd:enumeration value="value"/> + <xsd:enumeration value="cell"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Tables"> + <xsd:choice minOccurs="1" maxOccurs="unbounded"> + <xsd:element name="m" type="CT_TableMissing"/> + <xsd:element name="s" type="CT_XStringElement"/> + <xsd:element name="x" type="CT_Index"/> + </xsd:choice> + <xsd:attribute name="count" use="optional" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_TableMissing"/> + <xsd:complexType name="CT_TextPr"> + <xsd:sequence> + <xsd:element name="textFields" minOccurs="0" maxOccurs="1" type="CT_TextFields"/> + </xsd:sequence> + <xsd:attribute name="prompt" use="optional" type="xsd:boolean" default="true"/> + <xsd:attribute name="fileType" use="optional" type="ST_FileType" default="win"/> + <xsd:attribute name="codePage" use="optional" type="xsd:unsignedInt" default="1252"/> + <xsd:attribute name="characterSet" use="optional" type="xsd:string"/> + <xsd:attribute name="firstRow" use="optional" type="xsd:unsignedInt" default="1"/> + <xsd:attribute name="sourceFile" use="optional" type="s:ST_Xstring" default=""/> + <xsd:attribute name="delimited" use="optional" type="xsd:boolean" default="true"/> + <xsd:attribute name="decimal" use="optional" type="s:ST_Xstring" default="."/> + <xsd:attribute name="thousands" use="optional" type="s:ST_Xstring" default=","/> + <xsd:attribute name="tab" use="optional" type="xsd:boolean" default="true"/> + <xsd:attribute name="space" use="optional" type="xsd:boolean" default="false"/> + <xsd:attribute name="comma" use="optional" type="xsd:boolean" default="false"/> + <xsd:attribute name="semicolon" use="optional" type="xsd:boolean" default="false"/> + <xsd:attribute name="consecutive" use="optional" type="xsd:boolean" default="false"/> + <xsd:attribute name="qualifier" use="optional" type="ST_Qualifier" default="doubleQuote"/> + <xsd:attribute name="delimiter" use="optional" type="s:ST_Xstring"/> + </xsd:complexType> + <xsd:simpleType name="ST_FileType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="mac"/> + <xsd:enumeration value="win"/> + <xsd:enumeration value="dos"/> + <xsd:enumeration value="lin"/> + <xsd:enumeration value="other"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_Qualifier"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="doubleQuote"/> + <xsd:enumeration value="singleQuote"/> + <xsd:enumeration value="none"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TextFields"> + <xsd:sequence> + <xsd:element name="textField" minOccurs="1" maxOccurs="unbounded" type="CT_TextField"/> + </xsd:sequence> + <xsd:attribute name="count" use="optional" type="xsd:unsignedInt" default="1"/> + </xsd:complexType> + <xsd:complexType name="CT_TextField"> + <xsd:attribute name="type" use="optional" type="ST_ExternalConnectionType" default="general"/> + <xsd:attribute name="position" use="optional" type="xsd:unsignedInt" default="0"/> + </xsd:complexType> + <xsd:simpleType name="ST_ExternalConnectionType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="general"/> + <xsd:enumeration value="text"/> + <xsd:enumeration value="MDY"/> + <xsd:enumeration value="DMY"/> + <xsd:enumeration value="YMD"/> + <xsd:enumeration value="MYD"/> + <xsd:enumeration value="DYM"/> + <xsd:enumeration value="YDM"/> + <xsd:enumeration value="skip"/> + <xsd:enumeration value="EMD"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:element name="pivotCacheDefinition" type="CT_PivotCacheDefinition"/> + <xsd:element name="pivotCacheRecords" type="CT_PivotCacheRecords"/> + <xsd:element name="pivotTableDefinition" type="CT_pivotTableDefinition"/> + <xsd:complexType name="CT_PivotCacheDefinition"> + <xsd:sequence> + <xsd:element name="cacheSource" type="CT_CacheSource" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cacheFields" type="CT_CacheFields" minOccurs="1" maxOccurs="1"/> + <xsd:element name="cacheHierarchies" minOccurs="0" type="CT_CacheHierarchies"/> + <xsd:element name="kpis" minOccurs="0" type="CT_PCDKPIs"/> + <xsd:element name="tupleCache" minOccurs="0" type="CT_TupleCache"/> + <xsd:element name="calculatedItems" minOccurs="0" type="CT_CalculatedItems"/> + <xsd:element name="calculatedMembers" type="CT_CalculatedMembers" minOccurs="0"/> + <xsd:element name="dimensions" type="CT_Dimensions" minOccurs="0"/> + <xsd:element name="measureGroups" type="CT_MeasureGroups" minOccurs="0"/> + <xsd:element name="maps" type="CT_MeasureDimensionMaps" minOccurs="0"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute ref="r:id" use="optional"/> + <xsd:attribute name="invalid" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="saveData" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="refreshOnLoad" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="optimizeMemory" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="enableRefresh" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="refreshedBy" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="refreshedDate" type="xsd:double" use="optional"/> + <xsd:attribute name="refreshedDateIso" type="xsd:dateTime" use="optional"/> + <xsd:attribute name="backgroundQuery" type="xsd:boolean" default="false"/> + <xsd:attribute name="missingItemsLimit" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="createdVersion" type="xsd:unsignedByte" use="optional" default="0"/> + <xsd:attribute name="refreshedVersion" type="xsd:unsignedByte" use="optional" default="0"/> + <xsd:attribute name="minRefreshableVersion" type="xsd:unsignedByte" use="optional" default="0"/> + <xsd:attribute name="recordCount" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="upgradeOnRefresh" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="tupleCache" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="supportSubquery" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="supportAdvancedDrill" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_CacheFields"> + <xsd:sequence> + <xsd:element name="cacheField" type="CT_CacheField" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_CacheField"> + <xsd:sequence> + <xsd:element name="sharedItems" type="CT_SharedItems" minOccurs="0" maxOccurs="1"/> + <xsd:element name="fieldGroup" minOccurs="0" type="CT_FieldGroup"/> + <xsd:element name="mpMap" minOccurs="0" maxOccurs="unbounded" type="CT_X"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="name" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="caption" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="propertyName" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="serverField" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="uniqueList" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="numFmtId" type="ST_NumFmtId" use="optional"/> + <xsd:attribute name="formula" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="sqlType" type="xsd:int" use="optional" default="0"/> + <xsd:attribute name="hierarchy" type="xsd:int" use="optional" default="0"/> + <xsd:attribute name="level" type="xsd:unsignedInt" use="optional" default="0"/> + <xsd:attribute name="databaseField" type="xsd:boolean" default="true"/> + <xsd:attribute name="mappingCount" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="memberPropertyField" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_CacheSource"> + <xsd:choice minOccurs="0" maxOccurs="1"> + <xsd:element name="worksheetSource" type="CT_WorksheetSource" minOccurs="1" maxOccurs="1"/> + <xsd:element name="consolidation" type="CT_Consolidation" minOccurs="1" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0"/> + </xsd:choice> + <xsd:attribute name="type" type="ST_SourceType" use="required"/> + <xsd:attribute name="connectionId" type="xsd:unsignedInt" default="0" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_SourceType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="worksheet"/> + <xsd:enumeration value="external"/> + <xsd:enumeration value="consolidation"/> + <xsd:enumeration value="scenario"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_WorksheetSource"> + <xsd:attribute name="ref" type="ST_Ref" use="optional"/> + <xsd:attribute name="name" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="sheet" type="s:ST_Xstring" use="optional"/> + <xsd:attribute ref="r:id" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Consolidation"> + <xsd:sequence> + <xsd:element name="pages" type="CT_Pages" minOccurs="0" maxOccurs="1"/> + <xsd:element name="rangeSets" type="CT_RangeSets" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="autoPage" type="xsd:boolean" default="true" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Pages"> + <xsd:sequence> + <xsd:element name="page" type="CT_PCDSCPage" minOccurs="1" maxOccurs="4"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_PCDSCPage"> + <xsd:sequence> + <xsd:element name="pageItem" type="CT_PageItem" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_PageItem"> + <xsd:attribute name="name" type="s:ST_Xstring" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_RangeSets"> + <xsd:sequence> + <xsd:element name="rangeSet" type="CT_RangeSet" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_RangeSet"> + <xsd:attribute name="i1" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="i2" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="i3" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="i4" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="ref" type="ST_Ref" use="optional"/> + <xsd:attribute name="name" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="sheet" type="s:ST_Xstring" use="optional"/> + <xsd:attribute ref="r:id" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_SharedItems"> + <xsd:choice minOccurs="0" maxOccurs="unbounded"> + <xsd:element name="m" type="CT_Missing" minOccurs="1" maxOccurs="1"/> + <xsd:element name="n" type="CT_Number" minOccurs="1" maxOccurs="1"/> + <xsd:element name="b" type="CT_Boolean" minOccurs="1" maxOccurs="1"/> + <xsd:element name="e" type="CT_Error" minOccurs="1" maxOccurs="1"/> + <xsd:element name="s" type="CT_String" minOccurs="1" maxOccurs="1"/> + <xsd:element name="d" type="CT_DateTime" minOccurs="1" maxOccurs="1"/> + </xsd:choice> + <xsd:attribute name="containsSemiMixedTypes" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="containsNonDate" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="containsDate" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="containsString" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="containsBlank" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="containsMixedTypes" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="containsNumber" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="containsInteger" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="minValue" type="xsd:double" use="optional"/> + <xsd:attribute name="maxValue" type="xsd:double" use="optional"/> + <xsd:attribute name="minDate" type="xsd:dateTime" use="optional"/> + <xsd:attribute name="maxDate" type="xsd:dateTime" use="optional"/> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="longText" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_Missing"> + <xsd:sequence> + <xsd:element name="tpls" minOccurs="0" maxOccurs="unbounded" type="CT_Tuples"/> + <xsd:element name="x" minOccurs="0" maxOccurs="unbounded" type="CT_X"/> + </xsd:sequence> + <xsd:attribute name="u" type="xsd:boolean"/> + <xsd:attribute name="f" type="xsd:boolean"/> + <xsd:attribute name="c" type="s:ST_Xstring"/> + <xsd:attribute name="cp" type="xsd:unsignedInt"/> + <xsd:attribute name="in" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="bc" type="ST_UnsignedIntHex" use="optional"/> + <xsd:attribute name="fc" type="ST_UnsignedIntHex" use="optional"/> + <xsd:attribute name="i" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="un" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="st" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="b" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_Number"> + <xsd:sequence> + <xsd:element name="tpls" minOccurs="0" maxOccurs="unbounded" type="CT_Tuples"/> + <xsd:element name="x" minOccurs="0" maxOccurs="unbounded" type="CT_X"/> + </xsd:sequence> + <xsd:attribute name="v" use="required" type="xsd:double"/> + <xsd:attribute name="u" type="xsd:boolean"/> + <xsd:attribute name="f" type="xsd:boolean"/> + <xsd:attribute name="c" type="s:ST_Xstring"/> + <xsd:attribute name="cp" type="xsd:unsignedInt"/> + <xsd:attribute name="in" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="bc" type="ST_UnsignedIntHex" use="optional"/> + <xsd:attribute name="fc" type="ST_UnsignedIntHex" use="optional"/> + <xsd:attribute name="i" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="un" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="st" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="b" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_Boolean"> + <xsd:sequence> + <xsd:element name="x" minOccurs="0" maxOccurs="unbounded" type="CT_X"/> + </xsd:sequence> + <xsd:attribute name="v" use="required" type="xsd:boolean"/> + <xsd:attribute name="u" type="xsd:boolean"/> + <xsd:attribute name="f" type="xsd:boolean"/> + <xsd:attribute name="c" type="s:ST_Xstring"/> + <xsd:attribute name="cp" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_Error"> + <xsd:sequence> + <xsd:element name="tpls" minOccurs="0" type="CT_Tuples"/> + <xsd:element name="x" minOccurs="0" maxOccurs="unbounded" type="CT_X"/> + </xsd:sequence> + <xsd:attribute name="v" use="required" type="s:ST_Xstring"/> + <xsd:attribute name="u" type="xsd:boolean"/> + <xsd:attribute name="f" type="xsd:boolean"/> + <xsd:attribute name="c" type="s:ST_Xstring"/> + <xsd:attribute name="cp" type="xsd:unsignedInt"/> + <xsd:attribute name="in" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="bc" type="ST_UnsignedIntHex" use="optional"/> + <xsd:attribute name="fc" type="ST_UnsignedIntHex" use="optional"/> + <xsd:attribute name="i" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="un" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="st" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="b" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_String"> + <xsd:sequence> + <xsd:element name="tpls" minOccurs="0" maxOccurs="unbounded" type="CT_Tuples"/> + <xsd:element name="x" minOccurs="0" maxOccurs="unbounded" type="CT_X"/> + </xsd:sequence> + <xsd:attribute name="v" use="required" type="s:ST_Xstring"/> + <xsd:attribute name="u" type="xsd:boolean"/> + <xsd:attribute name="f" type="xsd:boolean"/> + <xsd:attribute name="c" type="s:ST_Xstring"/> + <xsd:attribute name="cp" type="xsd:unsignedInt"/> + <xsd:attribute name="in" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="bc" type="ST_UnsignedIntHex" use="optional"/> + <xsd:attribute name="fc" type="ST_UnsignedIntHex" use="optional"/> + <xsd:attribute name="i" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="un" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="st" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="b" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_DateTime"> + <xsd:sequence> + <xsd:element name="x" minOccurs="0" maxOccurs="unbounded" type="CT_X"/> + </xsd:sequence> + <xsd:attribute name="v" use="required" type="xsd:dateTime"/> + <xsd:attribute name="u" type="xsd:boolean"/> + <xsd:attribute name="f" type="xsd:boolean"/> + <xsd:attribute name="c" type="s:ST_Xstring"/> + <xsd:attribute name="cp" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_FieldGroup"> + <xsd:sequence> + <xsd:element name="rangePr" minOccurs="0" type="CT_RangePr"/> + <xsd:element name="discretePr" minOccurs="0" type="CT_DiscretePr"/> + <xsd:element name="groupItems" minOccurs="0" type="CT_GroupItems"/> + </xsd:sequence> + <xsd:attribute name="par" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="base" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_RangePr"> + <xsd:attribute name="autoStart" type="xsd:boolean" default="true"/> + <xsd:attribute name="autoEnd" type="xsd:boolean" default="true"/> + <xsd:attribute name="groupBy" type="ST_GroupBy" default="range"/> + <xsd:attribute name="startNum" type="xsd:double"/> + <xsd:attribute name="endNum" type="xsd:double"/> + <xsd:attribute name="startDate" type="xsd:dateTime"/> + <xsd:attribute name="endDate" type="xsd:dateTime"/> + <xsd:attribute name="groupInterval" type="xsd:double" default="1"/> + </xsd:complexType> + <xsd:simpleType name="ST_GroupBy"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="range"/> + <xsd:enumeration value="seconds"/> + <xsd:enumeration value="minutes"/> + <xsd:enumeration value="hours"/> + <xsd:enumeration value="days"/> + <xsd:enumeration value="months"/> + <xsd:enumeration value="quarters"/> + <xsd:enumeration value="years"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_DiscretePr"> + <xsd:sequence> + <xsd:element name="x" maxOccurs="unbounded" type="CT_Index"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_GroupItems"> + <xsd:choice maxOccurs="unbounded"> + <xsd:element name="m" type="CT_Missing"/> + <xsd:element name="n" type="CT_Number"/> + <xsd:element name="b" type="CT_Boolean"/> + <xsd:element name="e" type="CT_Error"/> + <xsd:element name="s" type="CT_String"/> + <xsd:element name="d" type="CT_DateTime"/> + </xsd:choice> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_PivotCacheRecords"> + <xsd:sequence> + <xsd:element name="r" minOccurs="0" maxOccurs="unbounded" type="CT_Record"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_Record"> + <xsd:choice maxOccurs="unbounded"> + <xsd:element name="m" type="CT_Missing"/> + <xsd:element name="n" type="CT_Number"/> + <xsd:element name="b" type="CT_Boolean"/> + <xsd:element name="e" type="CT_Error"/> + <xsd:element name="s" type="CT_String"/> + <xsd:element name="d" type="CT_DateTime"/> + <xsd:element name="x" type="CT_Index"/> + </xsd:choice> + </xsd:complexType> + <xsd:complexType name="CT_PCDKPIs"> + <xsd:sequence> + <xsd:element name="kpi" minOccurs="0" maxOccurs="unbounded" type="CT_PCDKPI"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_PCDKPI"> + <xsd:attribute name="uniqueName" use="required" type="s:ST_Xstring"/> + <xsd:attribute name="caption" use="optional" type="s:ST_Xstring"/> + <xsd:attribute name="displayFolder" type="s:ST_Xstring"/> + <xsd:attribute name="measureGroup" type="s:ST_Xstring"/> + <xsd:attribute name="parent" type="s:ST_Xstring"/> + <xsd:attribute name="value" use="required" type="s:ST_Xstring"/> + <xsd:attribute name="goal" type="s:ST_Xstring"/> + <xsd:attribute name="status" type="s:ST_Xstring"/> + <xsd:attribute name="trend" type="s:ST_Xstring"/> + <xsd:attribute name="weight" type="s:ST_Xstring"/> + <xsd:attribute name="time" type="s:ST_Xstring"/> + </xsd:complexType> + <xsd:complexType name="CT_CacheHierarchies"> + <xsd:sequence> + <xsd:element name="cacheHierarchy" minOccurs="0" maxOccurs="unbounded" + type="CT_CacheHierarchy"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_CacheHierarchy"> + <xsd:sequence> + <xsd:element name="fieldsUsage" minOccurs="0" type="CT_FieldsUsage"/> + <xsd:element name="groupLevels" minOccurs="0" type="CT_GroupLevels"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="uniqueName" use="required" type="s:ST_Xstring"/> + <xsd:attribute name="caption" use="optional" type="s:ST_Xstring"/> + <xsd:attribute name="measure" type="xsd:boolean" default="false"/> + <xsd:attribute name="set" type="xsd:boolean" default="false"/> + <xsd:attribute name="parentSet" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="iconSet" type="xsd:int" default="0"/> + <xsd:attribute name="attribute" type="xsd:boolean" default="false"/> + <xsd:attribute name="time" type="xsd:boolean" default="false"/> + <xsd:attribute name="keyAttribute" type="xsd:boolean" default="false"/> + <xsd:attribute name="defaultMemberUniqueName" type="s:ST_Xstring"/> + <xsd:attribute name="allUniqueName" type="s:ST_Xstring"/> + <xsd:attribute name="allCaption" type="s:ST_Xstring"/> + <xsd:attribute name="dimensionUniqueName" type="s:ST_Xstring"/> + <xsd:attribute name="displayFolder" type="s:ST_Xstring"/> + <xsd:attribute name="measureGroup" type="s:ST_Xstring"/> + <xsd:attribute name="measures" type="xsd:boolean" default="false"/> + <xsd:attribute name="count" use="required" type="xsd:unsignedInt"/> + <xsd:attribute name="oneField" type="xsd:boolean" default="false"/> + <xsd:attribute name="memberValueDatatype" use="optional" type="xsd:unsignedShort"/> + <xsd:attribute name="unbalanced" use="optional" type="xsd:boolean"/> + <xsd:attribute name="unbalancedGroup" use="optional" type="xsd:boolean"/> + <xsd:attribute name="hidden" type="xsd:boolean" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_FieldsUsage"> + <xsd:sequence> + <xsd:element name="fieldUsage" minOccurs="0" maxOccurs="unbounded" type="CT_FieldUsage"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_FieldUsage"> + <xsd:attribute name="x" use="required" type="xsd:int"/> + </xsd:complexType> + <xsd:complexType name="CT_GroupLevels"> + <xsd:sequence> + <xsd:element name="groupLevel" maxOccurs="unbounded" type="CT_GroupLevel"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_GroupLevel"> + <xsd:sequence> + <xsd:element name="groups" minOccurs="0" type="CT_Groups"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="uniqueName" use="required" type="s:ST_Xstring"/> + <xsd:attribute name="caption" use="required" type="s:ST_Xstring"/> + <xsd:attribute name="user" type="xsd:boolean" default="false"/> + <xsd:attribute name="customRollUp" type="xsd:boolean" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_Groups"> + <xsd:sequence> + <xsd:element name="group" maxOccurs="unbounded" type="CT_LevelGroup"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_LevelGroup"> + <xsd:sequence> + <xsd:element name="groupMembers" type="CT_GroupMembers"/> + </xsd:sequence> + <xsd:attribute name="name" use="required" type="s:ST_Xstring"/> + <xsd:attribute name="uniqueName" use="required" type="s:ST_Xstring"/> + <xsd:attribute name="caption" use="required" type="s:ST_Xstring"/> + <xsd:attribute name="uniqueParent" type="s:ST_Xstring"/> + <xsd:attribute name="id" type="xsd:int"/> + </xsd:complexType> + <xsd:complexType name="CT_GroupMembers"> + <xsd:sequence> + <xsd:element name="groupMember" maxOccurs="unbounded" type="CT_GroupMember"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_GroupMember"> + <xsd:attribute name="uniqueName" use="required" type="s:ST_Xstring"/> + <xsd:attribute name="group" type="xsd:boolean" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_TupleCache"> + <xsd:sequence> + <xsd:element name="entries" minOccurs="0" type="CT_PCDSDTCEntries"/> + <xsd:element name="sets" minOccurs="0" type="CT_Sets"/> + <xsd:element name="queryCache" minOccurs="0" type="CT_QueryCache"/> + <xsd:element name="serverFormats" minOccurs="0" maxOccurs="1" type="CT_ServerFormats"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_ServerFormat"> + <xsd:attribute name="culture" use="optional" type="s:ST_Xstring"/> + <xsd:attribute name="format" use="optional" type="s:ST_Xstring"/> + </xsd:complexType> + <xsd:complexType name="CT_ServerFormats"> + <xsd:sequence> + <xsd:element name="serverFormat" type="CT_ServerFormat" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_PCDSDTCEntries"> + <xsd:choice maxOccurs="unbounded"> + <xsd:element name="m" type="CT_Missing"/> + <xsd:element name="n" type="CT_Number"/> + <xsd:element name="e" type="CT_Error"/> + <xsd:element name="s" type="CT_String"/> + </xsd:choice> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_Tuples"> + <xsd:sequence> + <xsd:element name="tpl" type="CT_Tuple" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="c" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Tuple"> + <xsd:attribute name="fld" type="xsd:unsignedInt"/> + <xsd:attribute name="hier" type="xsd:unsignedInt"/> + <xsd:attribute name="item" type="xsd:unsignedInt" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Sets"> + <xsd:sequence> + <xsd:element name="set" maxOccurs="unbounded" type="CT_Set"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_Set"> + <xsd:sequence> + <xsd:element name="tpls" minOccurs="0" maxOccurs="unbounded" type="CT_Tuples"/> + <xsd:element name="sortByTuple" minOccurs="0" type="CT_Tuples"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + <xsd:attribute name="maxRank" use="required" type="xsd:int"/> + <xsd:attribute name="setDefinition" use="required" type="s:ST_Xstring"/> + <xsd:attribute name="sortType" type="ST_SortType" default="none"/> + <xsd:attribute name="queryFailed" type="xsd:boolean" default="false"/> + </xsd:complexType> + <xsd:simpleType name="ST_SortType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="ascending"/> + <xsd:enumeration value="descending"/> + <xsd:enumeration value="ascendingAlpha"/> + <xsd:enumeration value="descendingAlpha"/> + <xsd:enumeration value="ascendingNatural"/> + <xsd:enumeration value="descendingNatural"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_QueryCache"> + <xsd:sequence> + <xsd:element name="query" maxOccurs="unbounded" type="CT_Query"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_Query"> + <xsd:sequence> + <xsd:element name="tpls" minOccurs="0" type="CT_Tuples"/> + </xsd:sequence> + <xsd:attribute name="mdx" use="required" type="s:ST_Xstring"/> + </xsd:complexType> + <xsd:complexType name="CT_CalculatedItems"> + <xsd:sequence> + <xsd:element name="calculatedItem" maxOccurs="unbounded" type="CT_CalculatedItem"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_CalculatedItem"> + <xsd:sequence> + <xsd:element name="pivotArea" type="CT_PivotArea"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="field" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="formula" type="s:ST_Xstring"/> + </xsd:complexType> + <xsd:complexType name="CT_CalculatedMembers"> + <xsd:sequence> + <xsd:element name="calculatedMember" maxOccurs="unbounded" type="CT_CalculatedMember"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_CalculatedMember"> + <xsd:sequence minOccurs="0"> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="name" use="required" type="s:ST_Xstring"/> + <xsd:attribute name="mdx" use="required" type="s:ST_Xstring"/> + <xsd:attribute name="memberName" type="s:ST_Xstring"/> + <xsd:attribute name="hierarchy" type="s:ST_Xstring"/> + <xsd:attribute name="parent" type="s:ST_Xstring"/> + <xsd:attribute name="solveOrder" type="xsd:int" default="0"/> + <xsd:attribute name="set" type="xsd:boolean" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_pivotTableDefinition"> + <xsd:sequence> + <xsd:element name="location" type="CT_Location"/> + <xsd:element name="pivotFields" type="CT_PivotFields" minOccurs="0"/> + <xsd:element name="rowFields" type="CT_RowFields" minOccurs="0"/> + <xsd:element name="rowItems" type="CT_rowItems" minOccurs="0"/> + <xsd:element name="colFields" type="CT_ColFields" minOccurs="0"/> + <xsd:element name="colItems" type="CT_colItems" minOccurs="0"/> + <xsd:element name="pageFields" type="CT_PageFields" minOccurs="0"/> + <xsd:element name="dataFields" type="CT_DataFields" minOccurs="0"/> + <xsd:element name="formats" type="CT_Formats" minOccurs="0"/> + <xsd:element name="conditionalFormats" type="CT_ConditionalFormats" minOccurs="0"/> + <xsd:element name="chartFormats" type="CT_ChartFormats" minOccurs="0"/> + <xsd:element name="pivotHierarchies" type="CT_PivotHierarchies" minOccurs="0"/> + <xsd:element name="pivotTableStyleInfo" minOccurs="0" maxOccurs="1" type="CT_PivotTableStyle"/> + <xsd:element name="filters" minOccurs="0" maxOccurs="1" type="CT_PivotFilters"/> + <xsd:element name="rowHierarchiesUsage" type="CT_RowHierarchiesUsage" minOccurs="0" + maxOccurs="1"/> + <xsd:element name="colHierarchiesUsage" type="CT_ColHierarchiesUsage" minOccurs="0" + maxOccurs="1"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="name" use="required" type="s:ST_Xstring"/> + <xsd:attribute name="cacheId" use="required" type="xsd:unsignedInt"/> + <xsd:attribute name="dataOnRows" type="xsd:boolean" default="false"/> + <xsd:attribute name="dataPosition" type="xsd:unsignedInt" use="optional"/> + <xsd:attributeGroup ref="AG_AutoFormat"/> + <xsd:attribute name="dataCaption" use="required" type="s:ST_Xstring"/> + <xsd:attribute name="grandTotalCaption" type="s:ST_Xstring"/> + <xsd:attribute name="errorCaption" type="s:ST_Xstring"/> + <xsd:attribute name="showError" type="xsd:boolean" default="false"/> + <xsd:attribute name="missingCaption" type="s:ST_Xstring"/> + <xsd:attribute name="showMissing" type="xsd:boolean" default="true"/> + <xsd:attribute name="pageStyle" type="s:ST_Xstring"/> + <xsd:attribute name="pivotTableStyle" type="s:ST_Xstring"/> + <xsd:attribute name="vacatedStyle" type="s:ST_Xstring"/> + <xsd:attribute name="tag" type="s:ST_Xstring"/> + <xsd:attribute name="updatedVersion" type="xsd:unsignedByte" default="0"/> + <xsd:attribute name="minRefreshableVersion" type="xsd:unsignedByte" default="0"/> + <xsd:attribute name="asteriskTotals" type="xsd:boolean" default="false"/> + <xsd:attribute name="showItems" type="xsd:boolean" default="true"/> + <xsd:attribute name="editData" type="xsd:boolean" default="false"/> + <xsd:attribute name="disableFieldList" type="xsd:boolean" default="false"/> + <xsd:attribute name="showCalcMbrs" type="xsd:boolean" default="true"/> + <xsd:attribute name="visualTotals" type="xsd:boolean" default="true"/> + <xsd:attribute name="showMultipleLabel" type="xsd:boolean" default="true"/> + <xsd:attribute name="showDataDropDown" type="xsd:boolean" default="true"/> + <xsd:attribute name="showDrill" type="xsd:boolean" default="true"/> + <xsd:attribute name="printDrill" type="xsd:boolean" default="false"/> + <xsd:attribute name="showMemberPropertyTips" type="xsd:boolean" default="true"/> + <xsd:attribute name="showDataTips" type="xsd:boolean" default="true"/> + <xsd:attribute name="enableWizard" type="xsd:boolean" default="true"/> + <xsd:attribute name="enableDrill" type="xsd:boolean" default="true"/> + <xsd:attribute name="enableFieldProperties" type="xsd:boolean" default="true"/> + <xsd:attribute name="preserveFormatting" type="xsd:boolean" default="true"/> + <xsd:attribute name="useAutoFormatting" type="xsd:boolean" default="false"/> + <xsd:attribute name="pageWrap" type="xsd:unsignedInt" default="0"/> + <xsd:attribute name="pageOverThenDown" type="xsd:boolean" default="false"/> + <xsd:attribute name="subtotalHiddenItems" type="xsd:boolean" default="false"/> + <xsd:attribute name="rowGrandTotals" type="xsd:boolean" default="true"/> + <xsd:attribute name="colGrandTotals" type="xsd:boolean" default="true"/> + <xsd:attribute name="fieldPrintTitles" type="xsd:boolean" default="false"/> + <xsd:attribute name="itemPrintTitles" type="xsd:boolean" default="false"/> + <xsd:attribute name="mergeItem" type="xsd:boolean" default="false"/> + <xsd:attribute name="showDropZones" type="xsd:boolean" default="true"/> + <xsd:attribute name="createdVersion" type="xsd:unsignedByte" default="0"/> + <xsd:attribute name="indent" type="xsd:unsignedInt" default="1"/> + <xsd:attribute name="showEmptyRow" type="xsd:boolean" default="false"/> + <xsd:attribute name="showEmptyCol" type="xsd:boolean" default="false"/> + <xsd:attribute name="showHeaders" type="xsd:boolean" default="true"/> + <xsd:attribute name="compact" type="xsd:boolean" default="true"/> + <xsd:attribute name="outline" type="xsd:boolean" default="false"/> + <xsd:attribute name="outlineData" type="xsd:boolean" default="false"/> + <xsd:attribute name="compactData" type="xsd:boolean" default="true"/> + <xsd:attribute name="published" type="xsd:boolean" default="false"/> + <xsd:attribute name="gridDropZones" type="xsd:boolean" default="false"/> + <xsd:attribute name="immersive" type="xsd:boolean" default="true"/> + <xsd:attribute name="multipleFieldFilters" type="xsd:boolean" default="true"/> + <xsd:attribute name="chartFormat" type="xsd:unsignedInt" default="0"/> + <xsd:attribute name="rowHeaderCaption" type="s:ST_Xstring"/> + <xsd:attribute name="colHeaderCaption" type="s:ST_Xstring"/> + <xsd:attribute name="fieldListSortAscending" type="xsd:boolean" default="false"/> + <xsd:attribute name="mdxSubqueries" type="xsd:boolean" default="false"/> + <xsd:attribute name="customListSort" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_Location"> + <xsd:attribute name="ref" use="required" type="ST_Ref"/> + <xsd:attribute name="firstHeaderRow" use="required" type="xsd:unsignedInt"/> + <xsd:attribute name="firstDataRow" use="required" type="xsd:unsignedInt"/> + <xsd:attribute name="firstDataCol" use="required" type="xsd:unsignedInt"/> + <xsd:attribute name="rowPageCount" type="xsd:unsignedInt" default="0"/> + <xsd:attribute name="colPageCount" type="xsd:unsignedInt" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_PivotFields"> + <xsd:sequence> + <xsd:element name="pivotField" maxOccurs="unbounded" type="CT_PivotField"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_PivotField"> + <xsd:sequence> + <xsd:element name="items" minOccurs="0" type="CT_Items"/> + <xsd:element name="autoSortScope" minOccurs="0" type="CT_AutoSortScope"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="name" type="s:ST_Xstring"/> + <xsd:attribute name="axis" use="optional" type="ST_Axis"/> + <xsd:attribute name="dataField" type="xsd:boolean" default="false"/> + <xsd:attribute name="subtotalCaption" type="s:ST_Xstring"/> + <xsd:attribute name="showDropDowns" type="xsd:boolean" default="true"/> + <xsd:attribute name="hiddenLevel" type="xsd:boolean" default="false"/> + <xsd:attribute name="uniqueMemberProperty" type="s:ST_Xstring"/> + <xsd:attribute name="compact" type="xsd:boolean" default="true"/> + <xsd:attribute name="allDrilled" type="xsd:boolean" default="false"/> + <xsd:attribute name="numFmtId" type="ST_NumFmtId" use="optional"/> + <xsd:attribute name="outline" type="xsd:boolean" default="true"/> + <xsd:attribute name="subtotalTop" type="xsd:boolean" default="true"/> + <xsd:attribute name="dragToRow" type="xsd:boolean" default="true"/> + <xsd:attribute name="dragToCol" type="xsd:boolean" default="true"/> + <xsd:attribute name="multipleItemSelectionAllowed" type="xsd:boolean" default="false"/> + <xsd:attribute name="dragToPage" type="xsd:boolean" default="true"/> + <xsd:attribute name="dragToData" type="xsd:boolean" default="true"/> + <xsd:attribute name="dragOff" type="xsd:boolean" default="true"/> + <xsd:attribute name="showAll" type="xsd:boolean" default="true"/> + <xsd:attribute name="insertBlankRow" type="xsd:boolean" default="false"/> + <xsd:attribute name="serverField" type="xsd:boolean" default="false"/> + <xsd:attribute name="insertPageBreak" type="xsd:boolean" default="false"/> + <xsd:attribute name="autoShow" type="xsd:boolean" default="false"/> + <xsd:attribute name="topAutoShow" type="xsd:boolean" default="true"/> + <xsd:attribute name="hideNewItems" type="xsd:boolean" default="false"/> + <xsd:attribute name="measureFilter" type="xsd:boolean" default="false"/> + <xsd:attribute name="includeNewItemsInFilter" type="xsd:boolean" default="false"/> + <xsd:attribute name="itemPageCount" type="xsd:unsignedInt" default="10"/> + <xsd:attribute name="sortType" type="ST_FieldSortType" default="manual"/> + <xsd:attribute name="dataSourceSort" type="xsd:boolean" use="optional"/> + <xsd:attribute name="nonAutoSortDefault" type="xsd:boolean" default="false"/> + <xsd:attribute name="rankBy" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="defaultSubtotal" type="xsd:boolean" default="true"/> + <xsd:attribute name="sumSubtotal" type="xsd:boolean" default="false"/> + <xsd:attribute name="countASubtotal" type="xsd:boolean" default="false"/> + <xsd:attribute name="avgSubtotal" type="xsd:boolean" default="false"/> + <xsd:attribute name="maxSubtotal" type="xsd:boolean" default="false"/> + <xsd:attribute name="minSubtotal" type="xsd:boolean" default="false"/> + <xsd:attribute name="productSubtotal" type="xsd:boolean" default="false"/> + <xsd:attribute name="countSubtotal" type="xsd:boolean" default="false"/> + <xsd:attribute name="stdDevSubtotal" type="xsd:boolean" default="false"/> + <xsd:attribute name="stdDevPSubtotal" type="xsd:boolean" default="false"/> + <xsd:attribute name="varSubtotal" type="xsd:boolean" default="false"/> + <xsd:attribute name="varPSubtotal" type="xsd:boolean" default="false"/> + <xsd:attribute name="showPropCell" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="showPropTip" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="showPropAsCaption" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="defaultAttributeDrillState" type="xsd:boolean" use="optional" + default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_AutoSortScope"> + <xsd:sequence> + <xsd:element name="pivotArea" type="CT_PivotArea"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Items"> + <xsd:sequence> + <xsd:element name="item" maxOccurs="unbounded" type="CT_Item"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_Item"> + <xsd:attribute name="n" type="s:ST_Xstring"/> + <xsd:attribute name="t" type="ST_ItemType" default="data"/> + <xsd:attribute name="h" type="xsd:boolean" default="false"/> + <xsd:attribute name="s" type="xsd:boolean" default="false"/> + <xsd:attribute name="sd" type="xsd:boolean" default="true"/> + <xsd:attribute name="f" type="xsd:boolean" default="false"/> + <xsd:attribute name="m" type="xsd:boolean" default="false"/> + <xsd:attribute name="c" type="xsd:boolean" default="false"/> + <xsd:attribute name="x" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="d" type="xsd:boolean" default="false"/> + <xsd:attribute name="e" type="xsd:boolean" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_PageFields"> + <xsd:sequence> + <xsd:element name="pageField" maxOccurs="unbounded" type="CT_PageField"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_PageField"> + <xsd:sequence minOccurs="0"> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="fld" use="required" type="xsd:int"/> + <xsd:attribute name="item" use="optional" type="xsd:unsignedInt"/> + <xsd:attribute name="hier" type="xsd:int"/> + <xsd:attribute name="name" type="s:ST_Xstring"/> + <xsd:attribute name="cap" type="s:ST_Xstring"/> + </xsd:complexType> + <xsd:complexType name="CT_DataFields"> + <xsd:sequence> + <xsd:element name="dataField" maxOccurs="unbounded" type="CT_DataField"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_DataField"> + <xsd:sequence> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="name" use="optional" type="s:ST_Xstring"/> + <xsd:attribute name="fld" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="subtotal" type="ST_DataConsolidateFunction" default="sum"/> + <xsd:attribute name="showDataAs" type="ST_ShowDataAs" default="normal"/> + <xsd:attribute name="baseField" type="xsd:int" default="-1"/> + <xsd:attribute name="baseItem" type="xsd:unsignedInt" default="1048832"/> + <xsd:attribute name="numFmtId" type="ST_NumFmtId" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_rowItems"> + <xsd:sequence> + <xsd:element name="i" maxOccurs="unbounded" type="CT_I"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_colItems"> + <xsd:sequence> + <xsd:element name="i" maxOccurs="unbounded" type="CT_I"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_I"> + <xsd:sequence> + <xsd:element name="x" minOccurs="0" maxOccurs="unbounded" type="CT_X"/> + </xsd:sequence> + <xsd:attribute name="t" type="ST_ItemType" default="data"/> + <xsd:attribute name="r" type="xsd:unsignedInt" default="0"/> + <xsd:attribute name="i" type="xsd:unsignedInt" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_X"> + <xsd:attribute name="v" type="xsd:int" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_RowFields"> + <xsd:sequence> + <xsd:element name="field" maxOccurs="unbounded" type="CT_Field"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_ColFields"> + <xsd:sequence> + <xsd:element name="field" maxOccurs="unbounded" type="CT_Field"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_Field"> + <xsd:attribute name="x" type="xsd:int" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Formats"> + <xsd:sequence> + <xsd:element name="format" maxOccurs="unbounded" type="CT_Format"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_Format"> + <xsd:sequence> + <xsd:element name="pivotArea" type="CT_PivotArea"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="action" type="ST_FormatAction" default="formatting"/> + <xsd:attribute name="dxfId" type="ST_DxfId" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_ConditionalFormats"> + <xsd:sequence> + <xsd:element name="conditionalFormat" maxOccurs="unbounded" type="CT_ConditionalFormat"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_ConditionalFormat"> + <xsd:sequence> + <xsd:element name="pivotAreas" type="CT_PivotAreas"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="scope" type="ST_Scope" default="selection"/> + <xsd:attribute name="type" type="ST_Type" default="none"/> + <xsd:attribute name="priority" use="required" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_PivotAreas"> + <xsd:sequence> + <xsd:element name="pivotArea" minOccurs="0" maxOccurs="unbounded" type="CT_PivotArea"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:simpleType name="ST_Scope"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="selection"/> + <xsd:enumeration value="data"/> + <xsd:enumeration value="field"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_Type"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="all"/> + <xsd:enumeration value="row"/> + <xsd:enumeration value="column"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_ChartFormats"> + <xsd:sequence> + <xsd:element name="chartFormat" maxOccurs="unbounded" type="CT_ChartFormat"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_ChartFormat"> + <xsd:sequence> + <xsd:element name="pivotArea" type="CT_PivotArea"/> + </xsd:sequence> + <xsd:attribute name="chart" use="required" type="xsd:unsignedInt"/> + <xsd:attribute name="format" use="required" type="xsd:unsignedInt"/> + <xsd:attribute name="series" type="xsd:boolean" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_PivotHierarchies"> + <xsd:sequence> + <xsd:element name="pivotHierarchy" maxOccurs="unbounded" type="CT_PivotHierarchy"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_PivotHierarchy"> + <xsd:sequence> + <xsd:element name="mps" minOccurs="0" type="CT_MemberProperties"/> + <xsd:element name="members" minOccurs="0" maxOccurs="unbounded" type="CT_Members"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="outline" type="xsd:boolean" default="false"/> + <xsd:attribute name="multipleItemSelectionAllowed" type="xsd:boolean" default="false"/> + <xsd:attribute name="subtotalTop" type="xsd:boolean" default="false"/> + <xsd:attribute name="showInFieldList" type="xsd:boolean" default="true"/> + <xsd:attribute name="dragToRow" type="xsd:boolean" default="true"/> + <xsd:attribute name="dragToCol" type="xsd:boolean" default="true"/> + <xsd:attribute name="dragToPage" type="xsd:boolean" default="true"/> + <xsd:attribute name="dragToData" type="xsd:boolean" default="false"/> + <xsd:attribute name="dragOff" type="xsd:boolean" default="true"/> + <xsd:attribute name="includeNewItemsInFilter" type="xsd:boolean" default="false"/> + <xsd:attribute name="caption" type="s:ST_Xstring" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_RowHierarchiesUsage"> + <xsd:sequence> + <xsd:element name="rowHierarchyUsage" minOccurs="1" maxOccurs="unbounded" + type="CT_HierarchyUsage"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_ColHierarchiesUsage"> + <xsd:sequence> + <xsd:element name="colHierarchyUsage" minOccurs="1" maxOccurs="unbounded" + type="CT_HierarchyUsage"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_HierarchyUsage"> + <xsd:attribute name="hierarchyUsage" type="xsd:int" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_MemberProperties"> + <xsd:sequence> + <xsd:element name="mp" maxOccurs="unbounded" type="CT_MemberProperty"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_MemberProperty"> + <xsd:attribute name="name" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="showCell" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="showTip" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="showAsCaption" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="nameLen" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="pPos" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="pLen" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="level" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="field" use="required" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_Members"> + <xsd:sequence> + <xsd:element name="member" maxOccurs="unbounded" type="CT_Member"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + <xsd:attribute name="level" use="optional" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_Member"> + <xsd:attribute name="name" use="required" type="s:ST_Xstring"/> + </xsd:complexType> + <xsd:complexType name="CT_Dimensions"> + <xsd:sequence> + <xsd:element name="dimension" minOccurs="0" maxOccurs="unbounded" type="CT_PivotDimension"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_PivotDimension"> + <xsd:attribute name="measure" type="xsd:boolean" default="false"/> + <xsd:attribute name="name" use="required" type="s:ST_Xstring"/> + <xsd:attribute name="uniqueName" use="required" type="s:ST_Xstring"/> + <xsd:attribute name="caption" use="required" type="s:ST_Xstring"/> + </xsd:complexType> + <xsd:complexType name="CT_MeasureGroups"> + <xsd:sequence> + <xsd:element name="measureGroup" minOccurs="0" maxOccurs="unbounded" type="CT_MeasureGroup"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_MeasureDimensionMaps"> + <xsd:sequence> + <xsd:element name="map" minOccurs="0" maxOccurs="unbounded" type="CT_MeasureDimensionMap"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_MeasureGroup"> + <xsd:attribute name="name" use="required" type="s:ST_Xstring"/> + <xsd:attribute name="caption" use="required" type="s:ST_Xstring"/> + </xsd:complexType> + <xsd:complexType name="CT_MeasureDimensionMap"> + <xsd:attribute name="measureGroup" use="optional" type="xsd:unsignedInt"/> + <xsd:attribute name="dimension" use="optional" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_PivotTableStyle"> + <xsd:attribute name="name" type="xsd:string"/> + <xsd:attribute name="showRowHeaders" type="xsd:boolean"/> + <xsd:attribute name="showColHeaders" type="xsd:boolean"/> + <xsd:attribute name="showRowStripes" type="xsd:boolean"/> + <xsd:attribute name="showColStripes" type="xsd:boolean"/> + <xsd:attribute name="showLastColumn" type="xsd:boolean" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_PivotFilters"> + <xsd:sequence> + <xsd:element name="filter" minOccurs="0" maxOccurs="unbounded" type="CT_PivotFilter"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_PivotFilter"> + <xsd:sequence> + <xsd:element name="autoFilter" minOccurs="1" maxOccurs="1" type="CT_AutoFilter"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="fld" use="required" type="xsd:unsignedInt"/> + <xsd:attribute name="mpFld" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="type" use="required" type="ST_PivotFilterType"/> + <xsd:attribute name="evalOrder" use="optional" type="xsd:int" default="0"/> + <xsd:attribute name="id" use="required" type="xsd:unsignedInt"/> + <xsd:attribute name="iMeasureHier" use="optional" type="xsd:unsignedInt"/> + <xsd:attribute name="iMeasureFld" use="optional" type="xsd:unsignedInt"/> + <xsd:attribute name="name" type="s:ST_Xstring"/> + <xsd:attribute name="description" type="s:ST_Xstring"/> + <xsd:attribute name="stringValue1" type="s:ST_Xstring"/> + <xsd:attribute name="stringValue2" type="s:ST_Xstring"/> + </xsd:complexType> + <xsd:simpleType name="ST_ShowDataAs"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="normal"/> + <xsd:enumeration value="difference"/> + <xsd:enumeration value="percent"/> + <xsd:enumeration value="percentDiff"/> + <xsd:enumeration value="runTotal"/> + <xsd:enumeration value="percentOfRow"/> + <xsd:enumeration value="percentOfCol"/> + <xsd:enumeration value="percentOfTotal"/> + <xsd:enumeration value="index"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ItemType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="data"/> + <xsd:enumeration value="default"/> + <xsd:enumeration value="sum"/> + <xsd:enumeration value="countA"/> + <xsd:enumeration value="avg"/> + <xsd:enumeration value="max"/> + <xsd:enumeration value="min"/> + <xsd:enumeration value="product"/> + <xsd:enumeration value="count"/> + <xsd:enumeration value="stdDev"/> + <xsd:enumeration value="stdDevP"/> + <xsd:enumeration value="var"/> + <xsd:enumeration value="varP"/> + <xsd:enumeration value="grand"/> + <xsd:enumeration value="blank"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_FormatAction"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="blank"/> + <xsd:enumeration value="formatting"/> + <xsd:enumeration value="drill"/> + <xsd:enumeration value="formula"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_FieldSortType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="manual"/> + <xsd:enumeration value="ascending"/> + <xsd:enumeration value="descending"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_PivotFilterType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="unknown"/> + <xsd:enumeration value="count"/> + <xsd:enumeration value="percent"/> + <xsd:enumeration value="sum"/> + <xsd:enumeration value="captionEqual"/> + <xsd:enumeration value="captionNotEqual"/> + <xsd:enumeration value="captionBeginsWith"/> + <xsd:enumeration value="captionNotBeginsWith"/> + <xsd:enumeration value="captionEndsWith"/> + <xsd:enumeration value="captionNotEndsWith"/> + <xsd:enumeration value="captionContains"/> + <xsd:enumeration value="captionNotContains"/> + <xsd:enumeration value="captionGreaterThan"/> + <xsd:enumeration value="captionGreaterThanOrEqual"/> + <xsd:enumeration value="captionLessThan"/> + <xsd:enumeration value="captionLessThanOrEqual"/> + <xsd:enumeration value="captionBetween"/> + <xsd:enumeration value="captionNotBetween"/> + <xsd:enumeration value="valueEqual"/> + <xsd:enumeration value="valueNotEqual"/> + <xsd:enumeration value="valueGreaterThan"/> + <xsd:enumeration value="valueGreaterThanOrEqual"/> + <xsd:enumeration value="valueLessThan"/> + <xsd:enumeration value="valueLessThanOrEqual"/> + <xsd:enumeration value="valueBetween"/> + <xsd:enumeration value="valueNotBetween"/> + <xsd:enumeration value="dateEqual"/> + <xsd:enumeration value="dateNotEqual"/> + <xsd:enumeration value="dateOlderThan"/> + <xsd:enumeration value="dateOlderThanOrEqual"/> + <xsd:enumeration value="dateNewerThan"/> + <xsd:enumeration value="dateNewerThanOrEqual"/> + <xsd:enumeration value="dateBetween"/> + <xsd:enumeration value="dateNotBetween"/> + <xsd:enumeration value="tomorrow"/> + <xsd:enumeration value="today"/> + <xsd:enumeration value="yesterday"/> + <xsd:enumeration value="nextWeek"/> + <xsd:enumeration value="thisWeek"/> + <xsd:enumeration value="lastWeek"/> + <xsd:enumeration value="nextMonth"/> + <xsd:enumeration value="thisMonth"/> + <xsd:enumeration value="lastMonth"/> + <xsd:enumeration value="nextQuarter"/> + <xsd:enumeration value="thisQuarter"/> + <xsd:enumeration value="lastQuarter"/> + <xsd:enumeration value="nextYear"/> + <xsd:enumeration value="thisYear"/> + <xsd:enumeration value="lastYear"/> + <xsd:enumeration value="yearToDate"/> + <xsd:enumeration value="Q1"/> + <xsd:enumeration value="Q2"/> + <xsd:enumeration value="Q3"/> + <xsd:enumeration value="Q4"/> + <xsd:enumeration value="M1"/> + <xsd:enumeration value="M2"/> + <xsd:enumeration value="M3"/> + <xsd:enumeration value="M4"/> + <xsd:enumeration value="M5"/> + <xsd:enumeration value="M6"/> + <xsd:enumeration value="M7"/> + <xsd:enumeration value="M8"/> + <xsd:enumeration value="M9"/> + <xsd:enumeration value="M10"/> + <xsd:enumeration value="M11"/> + <xsd:enumeration value="M12"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_PivotArea"> + <xsd:sequence> + <xsd:element name="references" minOccurs="0" type="CT_PivotAreaReferences"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="field" use="optional" type="xsd:int"/> + <xsd:attribute name="type" type="ST_PivotAreaType" default="normal"/> + <xsd:attribute name="dataOnly" type="xsd:boolean" default="true"/> + <xsd:attribute name="labelOnly" type="xsd:boolean" default="false"/> + <xsd:attribute name="grandRow" type="xsd:boolean" default="false"/> + <xsd:attribute name="grandCol" type="xsd:boolean" default="false"/> + <xsd:attribute name="cacheIndex" type="xsd:boolean" default="false"/> + <xsd:attribute name="outline" type="xsd:boolean" default="true"/> + <xsd:attribute name="offset" type="ST_Ref"/> + <xsd:attribute name="collapsedLevelsAreSubtotals" type="xsd:boolean" default="false"/> + <xsd:attribute name="axis" type="ST_Axis" use="optional"/> + <xsd:attribute name="fieldPosition" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_PivotAreaType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="normal"/> + <xsd:enumeration value="data"/> + <xsd:enumeration value="all"/> + <xsd:enumeration value="origin"/> + <xsd:enumeration value="button"/> + <xsd:enumeration value="topEnd"/> + <xsd:enumeration value="topRight"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_PivotAreaReferences"> + <xsd:sequence> + <xsd:element name="reference" maxOccurs="unbounded" type="CT_PivotAreaReference"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:complexType name="CT_PivotAreaReference"> + <xsd:sequence> + <xsd:element name="x" minOccurs="0" maxOccurs="unbounded" type="CT_Index"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="field" use="optional" type="xsd:unsignedInt"/> + <xsd:attribute name="count" type="xsd:unsignedInt"/> + <xsd:attribute name="selected" type="xsd:boolean" default="true"/> + <xsd:attribute name="byPosition" type="xsd:boolean" default="false"/> + <xsd:attribute name="relative" type="xsd:boolean" default="false"/> + <xsd:attribute name="defaultSubtotal" type="xsd:boolean" default="false"/> + <xsd:attribute name="sumSubtotal" type="xsd:boolean" default="false"/> + <xsd:attribute name="countASubtotal" type="xsd:boolean" default="false"/> + <xsd:attribute name="avgSubtotal" type="xsd:boolean" default="false"/> + <xsd:attribute name="maxSubtotal" type="xsd:boolean" default="false"/> + <xsd:attribute name="minSubtotal" type="xsd:boolean" default="false"/> + <xsd:attribute name="productSubtotal" type="xsd:boolean" default="false"/> + <xsd:attribute name="countSubtotal" type="xsd:boolean" default="false"/> + <xsd:attribute name="stdDevSubtotal" type="xsd:boolean" default="false"/> + <xsd:attribute name="stdDevPSubtotal" type="xsd:boolean" default="false"/> + <xsd:attribute name="varSubtotal" type="xsd:boolean" default="false"/> + <xsd:attribute name="varPSubtotal" type="xsd:boolean" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_Index"> + <xsd:attribute name="v" use="required" type="xsd:unsignedInt"/> + </xsd:complexType> + <xsd:simpleType name="ST_Axis"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="axisRow"/> + <xsd:enumeration value="axisCol"/> + <xsd:enumeration value="axisPage"/> + <xsd:enumeration value="axisValues"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:element name="queryTable" type="CT_QueryTable"/> + <xsd:complexType name="CT_QueryTable"> + <xsd:sequence> + <xsd:element name="queryTableRefresh" type="CT_QueryTableRefresh" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="name" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="headers" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="rowNumbers" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="disableRefresh" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="backgroundRefresh" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="firstBackgroundRefresh" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="refreshOnLoad" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="growShrinkType" type="ST_GrowShrinkType" use="optional" + default="insertDelete"/> + <xsd:attribute name="fillFormulas" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="removeDataOnSave" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="disableEdit" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="preserveFormatting" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="adjustColumnWidth" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="intermediate" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="connectionId" type="xsd:unsignedInt" use="required"/> + <xsd:attributeGroup ref="AG_AutoFormat"/> + </xsd:complexType> + <xsd:complexType name="CT_QueryTableRefresh"> + <xsd:sequence> + <xsd:element name="queryTableFields" type="CT_QueryTableFields" minOccurs="1" maxOccurs="1"/> + <xsd:element name="queryTableDeletedFields" type="CT_QueryTableDeletedFields" minOccurs="0" + maxOccurs="1"/> + <xsd:element name="sortState" minOccurs="0" maxOccurs="1" type="CT_SortState"/> + <xsd:element name="extLst" minOccurs="0" maxOccurs="1" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="preserveSortFilterLayout" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="fieldIdWrapped" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="headersInLastRefresh" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="minimumVersion" type="xsd:unsignedByte" use="optional" default="0"/> + <xsd:attribute name="nextId" type="xsd:unsignedInt" use="optional" default="1"/> + <xsd:attribute name="unboundColumnsLeft" type="xsd:unsignedInt" use="optional" default="0"/> + <xsd:attribute name="unboundColumnsRight" type="xsd:unsignedInt" use="optional" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_QueryTableDeletedFields"> + <xsd:sequence> + <xsd:element name="deletedField" type="CT_DeletedField" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_DeletedField"> + <xsd:attribute name="name" type="s:ST_Xstring" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_QueryTableFields"> + <xsd:sequence> + <xsd:element name="queryTableField" type="CT_QueryTableField" minOccurs="0" + maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_QueryTableField"> + <xsd:sequence minOccurs="0"> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="id" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="name" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="dataBound" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="rowNumbers" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="fillFormulas" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="clipped" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="tableColumnId" type="xsd:unsignedInt" default="0"/> + </xsd:complexType> + <xsd:simpleType name="ST_GrowShrinkType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="insertDelete"/> + <xsd:enumeration value="insertClear"/> + <xsd:enumeration value="overwriteClear"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:element name="sst" type="CT_Sst"/> + <xsd:complexType name="CT_Sst"> + <xsd:sequence> + <xsd:element name="si" type="CT_Rst" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="uniqueCount" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_PhoneticType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="halfwidthKatakana"/> + <xsd:enumeration value="fullwidthKatakana"/> + <xsd:enumeration value="Hiragana"/> + <xsd:enumeration value="noConversion"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_PhoneticAlignment"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="noControl"/> + <xsd:enumeration value="left"/> + <xsd:enumeration value="center"/> + <xsd:enumeration value="distributed"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_PhoneticRun"> + <xsd:sequence> + <xsd:element name="t" type="s:ST_Xstring" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="sb" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="eb" type="xsd:unsignedInt" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_RElt"> + <xsd:sequence> + <xsd:element name="rPr" type="CT_RPrElt" minOccurs="0" maxOccurs="1"/> + <xsd:element name="t" type="s:ST_Xstring" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_RPrElt"> + <xsd:choice maxOccurs="unbounded"> + <xsd:element name="rFont" type="CT_FontName" minOccurs="0" maxOccurs="1"/> + <xsd:element name="charset" type="CT_IntProperty" minOccurs="0" maxOccurs="1"/> + <xsd:element name="family" type="CT_IntProperty" minOccurs="0" maxOccurs="1"/> + <xsd:element name="b" type="CT_BooleanProperty" minOccurs="0" maxOccurs="1"/> + <xsd:element name="i" type="CT_BooleanProperty" minOccurs="0" maxOccurs="1"/> + <xsd:element name="strike" type="CT_BooleanProperty" minOccurs="0" maxOccurs="1"/> + <xsd:element name="outline" type="CT_BooleanProperty" minOccurs="0" maxOccurs="1"/> + <xsd:element name="shadow" type="CT_BooleanProperty" minOccurs="0" maxOccurs="1"/> + <xsd:element name="condense" type="CT_BooleanProperty" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extend" type="CT_BooleanProperty" minOccurs="0" maxOccurs="1"/> + <xsd:element name="color" type="CT_Color" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sz" type="CT_FontSize" minOccurs="0" maxOccurs="1"/> + <xsd:element name="u" type="CT_UnderlineProperty" minOccurs="0" maxOccurs="1"/> + <xsd:element name="vertAlign" type="CT_VerticalAlignFontProperty" minOccurs="0" maxOccurs="1"/> + <xsd:element name="scheme" type="CT_FontScheme" minOccurs="0" maxOccurs="1"/> + </xsd:choice> + </xsd:complexType> + <xsd:complexType name="CT_Rst"> + <xsd:sequence> + <xsd:element name="t" type="s:ST_Xstring" minOccurs="0" maxOccurs="1"/> + <xsd:element name="r" type="CT_RElt" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="rPh" type="CT_PhoneticRun" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="phoneticPr" minOccurs="0" maxOccurs="1" type="CT_PhoneticPr"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_PhoneticPr"> + <xsd:attribute name="fontId" type="ST_FontId" use="required"/> + <xsd:attribute name="type" type="ST_PhoneticType" use="optional" default="fullwidthKatakana"/> + <xsd:attribute name="alignment" type="ST_PhoneticAlignment" use="optional" default="left"/> + </xsd:complexType> + <xsd:element name="headers" type="CT_RevisionHeaders"/> + <xsd:element name="revisions" type="CT_Revisions"/> + <xsd:complexType name="CT_RevisionHeaders"> + <xsd:sequence> + <xsd:element name="header" type="CT_RevisionHeader" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="guid" type="s:ST_Guid" use="required"/> + <xsd:attribute name="lastGuid" type="s:ST_Guid" use="optional"/> + <xsd:attribute name="shared" type="xsd:boolean" default="true"/> + <xsd:attribute name="diskRevisions" type="xsd:boolean" default="false"/> + <xsd:attribute name="history" type="xsd:boolean" default="true"/> + <xsd:attribute name="trackRevisions" type="xsd:boolean" default="true"/> + <xsd:attribute name="exclusive" type="xsd:boolean" default="false"/> + <xsd:attribute name="revisionId" type="xsd:unsignedInt" default="0"/> + <xsd:attribute name="version" type="xsd:int" default="1"/> + <xsd:attribute name="keepChangeHistory" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="protected" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="preserveHistory" type="xsd:unsignedInt" default="30"/> + </xsd:complexType> + <xsd:complexType name="CT_Revisions"> + <xsd:choice maxOccurs="unbounded"> + <xsd:element name="rrc" type="CT_RevisionRowColumn" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="rm" type="CT_RevisionMove" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="rcv" type="CT_RevisionCustomView" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="rsnm" type="CT_RevisionSheetRename" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="ris" type="CT_RevisionInsertSheet" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="rcc" type="CT_RevisionCellChange" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="rfmt" type="CT_RevisionFormatting" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="raf" type="CT_RevisionAutoFormatting" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="rdn" type="CT_RevisionDefinedName" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="rcmt" type="CT_RevisionComment" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="rqt" type="CT_RevisionQueryTableField" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="rcft" type="CT_RevisionConflict" minOccurs="0" maxOccurs="unbounded"/> + </xsd:choice> + </xsd:complexType> + <xsd:attributeGroup name="AG_RevData"> + <xsd:attribute name="rId" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="ua" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="ra" type="xsd:boolean" use="optional" default="false"/> + </xsd:attributeGroup> + <xsd:complexType name="CT_RevisionHeader"> + <xsd:sequence> + <xsd:element name="sheetIdMap" minOccurs="1" maxOccurs="1" type="CT_SheetIdMap"/> + <xsd:element name="reviewedList" minOccurs="0" maxOccurs="1" type="CT_ReviewedRevisions"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="guid" type="s:ST_Guid" use="required"/> + <xsd:attribute name="dateTime" type="xsd:dateTime" use="required"/> + <xsd:attribute name="maxSheetId" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="userName" type="s:ST_Xstring" use="required"/> + <xsd:attribute ref="r:id" use="required"/> + <xsd:attribute name="minRId" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="maxRId" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_SheetIdMap"> + <xsd:sequence> + <xsd:element name="sheetId" type="CT_SheetId" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_SheetId"> + <xsd:attribute name="val" type="xsd:unsignedInt" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_ReviewedRevisions"> + <xsd:sequence> + <xsd:element name="reviewed" type="CT_Reviewed" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Reviewed"> + <xsd:attribute name="rId" type="xsd:unsignedInt" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_UndoInfo"> + <xsd:attribute name="index" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="exp" type="ST_FormulaExpression" use="required"/> + <xsd:attribute name="ref3D" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="array" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="v" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="nf" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="cs" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="dr" type="ST_RefA" use="required"/> + <xsd:attribute name="dn" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="r" type="ST_CellRef" use="optional"/> + <xsd:attribute name="sId" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_RevisionRowColumn"> + <xsd:choice minOccurs="0" maxOccurs="unbounded"> + <xsd:element name="undo" type="CT_UndoInfo" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="rcc" type="CT_RevisionCellChange" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="rfmt" type="CT_RevisionFormatting" minOccurs="0" maxOccurs="unbounded"/> + </xsd:choice> + <xsd:attributeGroup ref="AG_RevData"/> + <xsd:attribute name="sId" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="eol" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="ref" type="ST_Ref" use="required"/> + <xsd:attribute name="action" type="ST_rwColActionType" use="required"/> + <xsd:attribute name="edge" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_RevisionMove"> + <xsd:choice minOccurs="0" maxOccurs="unbounded"> + <xsd:element name="undo" type="CT_UndoInfo" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="rcc" type="CT_RevisionCellChange" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="rfmt" type="CT_RevisionFormatting" minOccurs="0" maxOccurs="unbounded"/> + </xsd:choice> + <xsd:attributeGroup ref="AG_RevData"/> + <xsd:attribute name="sheetId" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="source" type="ST_Ref" use="required"/> + <xsd:attribute name="destination" type="ST_Ref" use="required"/> + <xsd:attribute name="sourceSheetId" type="xsd:unsignedInt" use="optional" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_RevisionCustomView"> + <xsd:attribute name="guid" type="s:ST_Guid" use="required"/> + <xsd:attribute name="action" type="ST_RevisionAction" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_RevisionSheetRename"> + <xsd:sequence> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_RevData"/> + <xsd:attribute name="sheetId" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="oldName" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="newName" type="s:ST_Xstring" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_RevisionInsertSheet"> + <xsd:attributeGroup ref="AG_RevData"/> + <xsd:attribute name="sheetId" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="name" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="sheetPosition" type="xsd:unsignedInt" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_RevisionCellChange"> + <xsd:sequence> + <xsd:element name="oc" type="CT_Cell" minOccurs="0" maxOccurs="1"/> + <xsd:element name="nc" type="CT_Cell" minOccurs="1" maxOccurs="1"/> + <xsd:element name="odxf" type="CT_Dxf" minOccurs="0" maxOccurs="1"/> + <xsd:element name="ndxf" type="CT_Dxf" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_RevData"/> + <xsd:attribute name="sId" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="odxf" type="xsd:boolean" default="false"/> + <xsd:attribute name="xfDxf" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="s" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="dxf" type="xsd:boolean" default="false"/> + <xsd:attribute name="numFmtId" type="ST_NumFmtId" use="optional"/> + <xsd:attribute name="quotePrefix" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="oldQuotePrefix" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="ph" type="xsd:boolean" default="false"/> + <xsd:attribute name="oldPh" type="xsd:boolean" default="false"/> + <xsd:attribute name="endOfListFormulaUpdate" type="xsd:boolean" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_RevisionFormatting"> + <xsd:sequence> + <xsd:element name="dxf" type="CT_Dxf" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="sheetId" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="xfDxf" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="s" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="sqref" type="ST_Sqref" use="required"/> + <xsd:attribute name="start" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="length" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_RevisionAutoFormatting"> + <xsd:attribute name="sheetId" type="xsd:unsignedInt" use="required"/> + <xsd:attributeGroup ref="AG_AutoFormat"/> + <xsd:attribute name="ref" type="ST_Ref" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_RevisionComment"> + <xsd:attribute name="sheetId" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="cell" type="ST_CellRef" use="required"/> + <xsd:attribute name="guid" type="s:ST_Guid" use="required"/> + <xsd:attribute name="action" type="ST_RevisionAction" default="add"/> + <xsd:attribute name="alwaysShow" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="old" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="hiddenRow" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="hiddenColumn" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="author" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="oldLength" type="xsd:unsignedInt" default="0"/> + <xsd:attribute name="newLength" type="xsd:unsignedInt" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_RevisionDefinedName"> + <xsd:sequence> + <xsd:element name="formula" type="ST_Formula" minOccurs="0" maxOccurs="1"/> + <xsd:element name="oldFormula" type="ST_Formula" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_RevData"/> + <xsd:attribute name="localSheetId" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="customView" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="name" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="function" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="oldFunction" type="xsd:boolean" default="false"/> + <xsd:attribute name="functionGroupId" type="xsd:unsignedByte" use="optional"/> + <xsd:attribute name="oldFunctionGroupId" type="xsd:unsignedByte" use="optional"/> + <xsd:attribute name="shortcutKey" type="xsd:unsignedByte" use="optional"/> + <xsd:attribute name="oldShortcutKey" type="xsd:unsignedByte" use="optional"/> + <xsd:attribute name="hidden" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="oldHidden" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="customMenu" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="oldCustomMenu" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="description" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="oldDescription" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="help" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="oldHelp" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="statusBar" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="oldStatusBar" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="comment" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="oldComment" type="s:ST_Xstring" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_RevisionConflict"> + <xsd:attributeGroup ref="AG_RevData"/> + <xsd:attribute name="sheetId" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_RevisionQueryTableField"> + <xsd:attribute name="sheetId" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="ref" type="ST_Ref" use="required"/> + <xsd:attribute name="fieldId" type="xsd:unsignedInt" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_rwColActionType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="insertRow"/> + <xsd:enumeration value="deleteRow"/> + <xsd:enumeration value="insertCol"/> + <xsd:enumeration value="deleteCol"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_RevisionAction"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="add"/> + <xsd:enumeration value="delete"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_FormulaExpression"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="ref"/> + <xsd:enumeration value="refError"/> + <xsd:enumeration value="area"/> + <xsd:enumeration value="areaError"/> + <xsd:enumeration value="computedArea"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:element name="users" type="CT_Users"/> + <xsd:complexType name="CT_Users"> + <xsd:sequence> + <xsd:element name="userInfo" minOccurs="0" maxOccurs="256" type="CT_SharedUser"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_SharedUser"> + <xsd:sequence> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="guid" type="s:ST_Guid" use="required"/> + <xsd:attribute name="name" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="id" type="xsd:int" use="required"/> + <xsd:attribute name="dateTime" type="xsd:dateTime" use="required"/> + </xsd:complexType> + <xsd:element name="worksheet" type="CT_Worksheet"/> + <xsd:element name="chartsheet" type="CT_Chartsheet"/> + <xsd:element name="dialogsheet" type="CT_Dialogsheet"/> + <xsd:complexType name="CT_Macrosheet"> + <xsd:sequence> + <xsd:element name="sheetPr" type="CT_SheetPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="dimension" type="CT_SheetDimension" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sheetViews" type="CT_SheetViews" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sheetFormatPr" type="CT_SheetFormatPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="cols" type="CT_Cols" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="sheetData" type="CT_SheetData" minOccurs="1" maxOccurs="1"/> + <xsd:element name="sheetProtection" type="CT_SheetProtection" minOccurs="0" maxOccurs="1"/> + <xsd:element name="autoFilter" type="CT_AutoFilter" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sortState" type="CT_SortState" minOccurs="0" maxOccurs="1"/> + <xsd:element name="dataConsolidate" type="CT_DataConsolidate" minOccurs="0" maxOccurs="1"/> + <xsd:element name="customSheetViews" type="CT_CustomSheetViews" minOccurs="0" maxOccurs="1"/> + <xsd:element name="phoneticPr" type="CT_PhoneticPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="conditionalFormatting" type="CT_ConditionalFormatting" minOccurs="0" + maxOccurs="unbounded"/> + <xsd:element name="printOptions" type="CT_PrintOptions" minOccurs="0" maxOccurs="1"/> + <xsd:element name="pageMargins" type="CT_PageMargins" minOccurs="0" maxOccurs="1"/> + <xsd:element name="pageSetup" type="CT_PageSetup" minOccurs="0" maxOccurs="1"/> + <xsd:element name="headerFooter" type="CT_HeaderFooter" minOccurs="0" maxOccurs="1"/> + <xsd:element name="rowBreaks" type="CT_PageBreak" minOccurs="0" maxOccurs="1"/> + <xsd:element name="colBreaks" type="CT_PageBreak" minOccurs="0" maxOccurs="1"/> + <xsd:element name="customProperties" type="CT_CustomProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="drawing" type="CT_Drawing" minOccurs="0" maxOccurs="1"/> + <xsd:element name="legacyDrawing" type="CT_LegacyDrawing" minOccurs="0" maxOccurs="1"/> + <xsd:element name="legacyDrawingHF" type="CT_LegacyDrawing" minOccurs="0" maxOccurs="1"/> + <xsd:element name="drawingHF" type="CT_DrawingHF" minOccurs="0" maxOccurs="1"/> + <xsd:element name="picture" type="CT_SheetBackgroundPicture" minOccurs="0" maxOccurs="1"/> + <xsd:element name="oleObjects" type="CT_OleObjects" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Dialogsheet"> + <xsd:sequence> + <xsd:element name="sheetPr" minOccurs="0" type="CT_SheetPr"/> + <xsd:element name="sheetViews" minOccurs="0" type="CT_SheetViews"/> + <xsd:element name="sheetFormatPr" minOccurs="0" type="CT_SheetFormatPr"/> + <xsd:element name="sheetProtection" type="CT_SheetProtection" minOccurs="0" maxOccurs="1"/> + <xsd:element name="customSheetViews" minOccurs="0" type="CT_CustomSheetViews"/> + <xsd:element name="printOptions" minOccurs="0" type="CT_PrintOptions"/> + <xsd:element name="pageMargins" minOccurs="0" type="CT_PageMargins"/> + <xsd:element name="pageSetup" minOccurs="0" type="CT_PageSetup"/> + <xsd:element name="headerFooter" minOccurs="0" type="CT_HeaderFooter"/> + <xsd:element name="drawing" minOccurs="0" type="CT_Drawing"/> + <xsd:element name="legacyDrawing" minOccurs="0" type="CT_LegacyDrawing"/> + <xsd:element name="legacyDrawingHF" type="CT_LegacyDrawing" minOccurs="0" maxOccurs="1"/> + <xsd:element name="drawingHF" type="CT_DrawingHF" minOccurs="0" maxOccurs="1"/> + <xsd:element name="oleObjects" type="CT_OleObjects" minOccurs="0" maxOccurs="1"/> + <xsd:element name="controls" type="CT_Controls" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Worksheet"> + <xsd:sequence> + <xsd:element name="sheetPr" type="CT_SheetPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="dimension" type="CT_SheetDimension" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sheetViews" type="CT_SheetViews" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sheetFormatPr" type="CT_SheetFormatPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="cols" type="CT_Cols" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="sheetData" type="CT_SheetData" minOccurs="1" maxOccurs="1"/> + <xsd:element name="sheetCalcPr" type="CT_SheetCalcPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sheetProtection" type="CT_SheetProtection" minOccurs="0" maxOccurs="1"/> + <xsd:element name="protectedRanges" type="CT_ProtectedRanges" minOccurs="0" maxOccurs="1"/> + <xsd:element name="scenarios" type="CT_Scenarios" minOccurs="0" maxOccurs="1"/> + <xsd:element name="autoFilter" type="CT_AutoFilter" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sortState" type="CT_SortState" minOccurs="0" maxOccurs="1"/> + <xsd:element name="dataConsolidate" type="CT_DataConsolidate" minOccurs="0" maxOccurs="1"/> + <xsd:element name="customSheetViews" type="CT_CustomSheetViews" minOccurs="0" maxOccurs="1"/> + <xsd:element name="mergeCells" type="CT_MergeCells" minOccurs="0" maxOccurs="1"/> + <xsd:element name="phoneticPr" type="CT_PhoneticPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="conditionalFormatting" type="CT_ConditionalFormatting" minOccurs="0" + maxOccurs="unbounded"/> + <xsd:element name="dataValidations" type="CT_DataValidations" minOccurs="0" maxOccurs="1"/> + <xsd:element name="hyperlinks" type="CT_Hyperlinks" minOccurs="0" maxOccurs="1"/> + <xsd:element name="printOptions" type="CT_PrintOptions" minOccurs="0" maxOccurs="1"/> + <xsd:element name="pageMargins" type="CT_PageMargins" minOccurs="0" maxOccurs="1"/> + <xsd:element name="pageSetup" type="CT_PageSetup" minOccurs="0" maxOccurs="1"/> + <xsd:element name="headerFooter" type="CT_HeaderFooter" minOccurs="0" maxOccurs="1"/> + <xsd:element name="rowBreaks" type="CT_PageBreak" minOccurs="0" maxOccurs="1"/> + <xsd:element name="colBreaks" type="CT_PageBreak" minOccurs="0" maxOccurs="1"/> + <xsd:element name="customProperties" type="CT_CustomProperties" minOccurs="0" maxOccurs="1"/> + <xsd:element name="cellWatches" type="CT_CellWatches" minOccurs="0" maxOccurs="1"/> + <xsd:element name="ignoredErrors" type="CT_IgnoredErrors" minOccurs="0" maxOccurs="1"/> + <xsd:element name="smartTags" type="CT_SmartTags" minOccurs="0" maxOccurs="1"/> + <xsd:element name="drawing" type="CT_Drawing" minOccurs="0" maxOccurs="1"/> + <xsd:element name="legacyDrawing" type="CT_LegacyDrawing" minOccurs="0" maxOccurs="1"/> + <xsd:element name="legacyDrawingHF" type="CT_LegacyDrawing" minOccurs="0" maxOccurs="1"/> + <xsd:element name="drawingHF" type="CT_DrawingHF" minOccurs="0" maxOccurs="1"/> + <xsd:element name="picture" type="CT_SheetBackgroundPicture" minOccurs="0" maxOccurs="1"/> + <xsd:element name="oleObjects" type="CT_OleObjects" minOccurs="0" maxOccurs="1"/> + <xsd:element name="controls" type="CT_Controls" minOccurs="0" maxOccurs="1"/> + <xsd:element name="webPublishItems" type="CT_WebPublishItems" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tableParts" type="CT_TableParts" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SheetData"> + <xsd:sequence> + <xsd:element name="row" type="CT_Row" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SheetCalcPr"> + <xsd:attribute name="fullCalcOnLoad" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_SheetFormatPr"> + <xsd:attribute name="baseColWidth" type="xsd:unsignedInt" use="optional" default="8"/> + <xsd:attribute name="defaultColWidth" type="xsd:double" use="optional"/> + <xsd:attribute name="defaultRowHeight" type="xsd:double" use="required"/> + <xsd:attribute name="customHeight" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="zeroHeight" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="thickTop" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="thickBottom" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="outlineLevelRow" type="xsd:unsignedByte" use="optional" default="0"/> + <xsd:attribute name="outlineLevelCol" type="xsd:unsignedByte" use="optional" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_Cols"> + <xsd:sequence> + <xsd:element name="col" type="CT_Col" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Col"> + <xsd:attribute name="min" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="max" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="width" type="xsd:double" use="optional"/> + <xsd:attribute name="style" type="xsd:unsignedInt" use="optional" default="0"/> + <xsd:attribute name="hidden" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="bestFit" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="customWidth" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="phonetic" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="outlineLevel" type="xsd:unsignedByte" use="optional" default="0"/> + <xsd:attribute name="collapsed" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:simpleType name="ST_CellSpan"> + <xsd:restriction base="xsd:string"/> + </xsd:simpleType> + <xsd:simpleType name="ST_CellSpans"> + <xsd:list itemType="ST_CellSpan"/> + </xsd:simpleType> + <xsd:complexType name="CT_Row"> + <xsd:sequence> + <xsd:element name="c" type="CT_Cell" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="r" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="spans" type="ST_CellSpans" use="optional"/> + <xsd:attribute name="s" type="xsd:unsignedInt" use="optional" default="0"/> + <xsd:attribute name="customFormat" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="ht" type="xsd:double" use="optional"/> + <xsd:attribute name="hidden" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="customHeight" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="outlineLevel" type="xsd:unsignedByte" use="optional" default="0"/> + <xsd:attribute name="collapsed" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="thickTop" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="thickBot" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="ph" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_Cell"> + <xsd:sequence> + <xsd:element name="f" type="CT_CellFormula" minOccurs="0" maxOccurs="1"/> + <xsd:element name="v" type="s:ST_Xstring" minOccurs="0" maxOccurs="1"/> + <xsd:element name="is" type="CT_Rst" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="r" type="ST_CellRef" use="optional"/> + <xsd:attribute name="s" type="xsd:unsignedInt" use="optional" default="0"/> + <xsd:attribute name="t" type="ST_CellType" use="optional" default="n"/> + <xsd:attribute name="cm" type="xsd:unsignedInt" use="optional" default="0"/> + <xsd:attribute name="vm" type="xsd:unsignedInt" use="optional" default="0"/> + <xsd:attribute name="ph" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:simpleType name="ST_CellType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="b"/> + <xsd:enumeration value="n"/> + <xsd:enumeration value="e"/> + <xsd:enumeration value="s"/> + <xsd:enumeration value="str"/> + <xsd:enumeration value="inlineStr"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_CellFormulaType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="normal"/> + <xsd:enumeration value="array"/> + <xsd:enumeration value="dataTable"/> + <xsd:enumeration value="shared"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_SheetPr"> + <xsd:sequence> + <xsd:element name="tabColor" type="CT_Color" minOccurs="0" maxOccurs="1"/> + <xsd:element name="outlinePr" type="CT_OutlinePr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="pageSetUpPr" type="CT_PageSetUpPr" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="syncHorizontal" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="syncVertical" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="syncRef" type="ST_Ref" use="optional"/> + <xsd:attribute name="transitionEvaluation" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="transitionEntry" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="published" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="codeName" type="xsd:string" use="optional"/> + <xsd:attribute name="filterMode" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="enableFormatConditionsCalculation" type="xsd:boolean" use="optional" + default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_SheetDimension"> + <xsd:attribute name="ref" type="ST_Ref" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_SheetViews"> + <xsd:sequence> + <xsd:element name="sheetView" type="CT_SheetView" minOccurs="1" maxOccurs="unbounded"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SheetView"> + <xsd:sequence> + <xsd:element name="pane" type="CT_Pane" minOccurs="0" maxOccurs="1"/> + <xsd:element name="selection" type="CT_Selection" minOccurs="0" maxOccurs="4"/> + <xsd:element name="pivotSelection" type="CT_PivotSelection" minOccurs="0" maxOccurs="4"/> + <xsd:element name="extLst" minOccurs="0" maxOccurs="1" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="windowProtection" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="showFormulas" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="showGridLines" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="showRowColHeaders" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="showZeros" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="rightToLeft" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="tabSelected" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="showRuler" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="showOutlineSymbols" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="defaultGridColor" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="showWhiteSpace" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="view" type="ST_SheetViewType" use="optional" default="normal"/> + <xsd:attribute name="topLeftCell" type="ST_CellRef" use="optional"/> + <xsd:attribute name="colorId" type="xsd:unsignedInt" use="optional" default="64"/> + <xsd:attribute name="zoomScale" type="xsd:unsignedInt" use="optional" default="100"/> + <xsd:attribute name="zoomScaleNormal" type="xsd:unsignedInt" use="optional" default="0"/> + <xsd:attribute name="zoomScaleSheetLayoutView" type="xsd:unsignedInt" use="optional" default="0"/> + <xsd:attribute name="zoomScalePageLayoutView" type="xsd:unsignedInt" use="optional" default="0"/> + <xsd:attribute name="workbookViewId" type="xsd:unsignedInt" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Pane"> + <xsd:attribute name="xSplit" type="xsd:double" use="optional" default="0"/> + <xsd:attribute name="ySplit" type="xsd:double" use="optional" default="0"/> + <xsd:attribute name="topLeftCell" type="ST_CellRef" use="optional"/> + <xsd:attribute name="activePane" type="ST_Pane" use="optional" default="topLeft"/> + <xsd:attribute name="state" type="ST_PaneState" use="optional" default="split"/> + </xsd:complexType> + <xsd:complexType name="CT_PivotSelection"> + <xsd:sequence> + <xsd:element name="pivotArea" type="CT_PivotArea"/> + </xsd:sequence> + <xsd:attribute name="pane" type="ST_Pane" use="optional" default="topLeft"/> + <xsd:attribute name="showHeader" type="xsd:boolean" default="false"/> + <xsd:attribute name="label" type="xsd:boolean" default="false"/> + <xsd:attribute name="data" type="xsd:boolean" default="false"/> + <xsd:attribute name="extendable" type="xsd:boolean" default="false"/> + <xsd:attribute name="count" type="xsd:unsignedInt" default="0"/> + <xsd:attribute name="axis" type="ST_Axis" use="optional"/> + <xsd:attribute name="dimension" type="xsd:unsignedInt" default="0"/> + <xsd:attribute name="start" type="xsd:unsignedInt" default="0"/> + <xsd:attribute name="min" type="xsd:unsignedInt" default="0"/> + <xsd:attribute name="max" type="xsd:unsignedInt" default="0"/> + <xsd:attribute name="activeRow" type="xsd:unsignedInt" default="0"/> + <xsd:attribute name="activeCol" type="xsd:unsignedInt" default="0"/> + <xsd:attribute name="previousRow" type="xsd:unsignedInt" default="0"/> + <xsd:attribute name="previousCol" type="xsd:unsignedInt" default="0"/> + <xsd:attribute name="click" type="xsd:unsignedInt" default="0"/> + <xsd:attribute ref="r:id" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Selection"> + <xsd:attribute name="pane" type="ST_Pane" use="optional" default="topLeft"/> + <xsd:attribute name="activeCell" type="ST_CellRef" use="optional"/> + <xsd:attribute name="activeCellId" type="xsd:unsignedInt" use="optional" default="0"/> + <xsd:attribute name="sqref" type="ST_Sqref" use="optional" default="A1"/> + </xsd:complexType> + <xsd:simpleType name="ST_Pane"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="bottomRight"/> + <xsd:enumeration value="topRight"/> + <xsd:enumeration value="bottomLeft"/> + <xsd:enumeration value="topLeft"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_PageBreak"> + <xsd:sequence> + <xsd:element name="brk" type="CT_Break" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional" default="0"/> + <xsd:attribute name="manualBreakCount" type="xsd:unsignedInt" use="optional" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_Break"> + <xsd:attribute name="id" type="xsd:unsignedInt" use="optional" default="0"/> + <xsd:attribute name="min" type="xsd:unsignedInt" use="optional" default="0"/> + <xsd:attribute name="max" type="xsd:unsignedInt" use="optional" default="0"/> + <xsd:attribute name="man" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="pt" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:simpleType name="ST_SheetViewType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="normal"/> + <xsd:enumeration value="pageBreakPreview"/> + <xsd:enumeration value="pageLayout"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_OutlinePr"> + <xsd:attribute name="applyStyles" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="summaryBelow" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="summaryRight" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="showOutlineSymbols" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_PageSetUpPr"> + <xsd:attribute name="autoPageBreaks" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="fitToPage" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_DataConsolidate"> + <xsd:sequence> + <xsd:element name="dataRefs" type="CT_DataRefs" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="function" type="ST_DataConsolidateFunction" use="optional" default="sum"/> + <xsd:attribute name="startLabels" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="leftLabels" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="topLabels" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="link" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:simpleType name="ST_DataConsolidateFunction"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="average"/> + <xsd:enumeration value="count"/> + <xsd:enumeration value="countNums"/> + <xsd:enumeration value="max"/> + <xsd:enumeration value="min"/> + <xsd:enumeration value="product"/> + <xsd:enumeration value="stdDev"/> + <xsd:enumeration value="stdDevp"/> + <xsd:enumeration value="sum"/> + <xsd:enumeration value="var"/> + <xsd:enumeration value="varp"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_DataRefs"> + <xsd:sequence> + <xsd:element name="dataRef" type="CT_DataRef" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_DataRef"> + <xsd:attribute name="ref" type="ST_Ref" use="optional"/> + <xsd:attribute name="name" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="sheet" type="s:ST_Xstring" use="optional"/> + <xsd:attribute ref="r:id" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_MergeCells"> + <xsd:sequence> + <xsd:element name="mergeCell" type="CT_MergeCell" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_MergeCell"> + <xsd:attribute name="ref" type="ST_Ref" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_SmartTags"> + <xsd:sequence> + <xsd:element name="cellSmartTags" type="CT_CellSmartTags" minOccurs="1" maxOccurs="unbounded" + /> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_CellSmartTags"> + <xsd:sequence> + <xsd:element name="cellSmartTag" type="CT_CellSmartTag" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="r" type="ST_CellRef" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_CellSmartTag"> + <xsd:sequence> + <xsd:element name="cellSmartTagPr" minOccurs="0" maxOccurs="unbounded" + type="CT_CellSmartTagPr"/> + </xsd:sequence> + <xsd:attribute name="type" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="deleted" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="xmlBased" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_CellSmartTagPr"> + <xsd:attribute name="key" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="val" type="s:ST_Xstring" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Drawing"> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_LegacyDrawing"> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_DrawingHF"> + <xsd:attribute ref="r:id" use="required"/> + <xsd:attribute name="lho" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="lhe" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="lhf" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="cho" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="che" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="chf" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="rho" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="rhe" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="rhf" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="lfo" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="lfe" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="lff" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="cfo" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="cfe" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="cff" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="rfo" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="rfe" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="rff" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_CustomSheetViews"> + <xsd:sequence> + <xsd:element name="customSheetView" minOccurs="1" maxOccurs="unbounded" + type="CT_CustomSheetView"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_CustomSheetView"> + <xsd:sequence> + <xsd:element name="pane" type="CT_Pane" minOccurs="0" maxOccurs="1"/> + <xsd:element name="selection" type="CT_Selection" minOccurs="0" maxOccurs="1"/> + <xsd:element name="rowBreaks" type="CT_PageBreak" minOccurs="0" maxOccurs="1"/> + <xsd:element name="colBreaks" type="CT_PageBreak" minOccurs="0" maxOccurs="1"/> + <xsd:element name="pageMargins" type="CT_PageMargins" minOccurs="0" maxOccurs="1"/> + <xsd:element name="printOptions" type="CT_PrintOptions" minOccurs="0" maxOccurs="1"/> + <xsd:element name="pageSetup" type="CT_PageSetup" minOccurs="0" maxOccurs="1"/> + <xsd:element name="headerFooter" type="CT_HeaderFooter" minOccurs="0" maxOccurs="1"/> + <xsd:element name="autoFilter" type="CT_AutoFilter" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="guid" type="s:ST_Guid" use="required"/> + <xsd:attribute name="scale" type="xsd:unsignedInt" default="100"/> + <xsd:attribute name="colorId" type="xsd:unsignedInt" default="64"/> + <xsd:attribute name="showPageBreaks" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="showFormulas" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="showGridLines" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="showRowCol" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="outlineSymbols" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="zeroValues" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="fitToPage" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="printArea" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="filter" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="showAutoFilter" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="hiddenRows" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="hiddenColumns" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="state" type="ST_SheetState" default="visible"/> + <xsd:attribute name="filterUnique" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="view" type="ST_SheetViewType" default="normal"/> + <xsd:attribute name="showRuler" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="topLeftCell" type="ST_CellRef" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_DataValidations"> + <xsd:sequence> + <xsd:element name="dataValidation" type="CT_DataValidation" minOccurs="1" + maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="disablePrompts" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="xWindow" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="yWindow" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_DataValidation"> + <xsd:sequence> + <xsd:element name="formula1" type="ST_Formula" minOccurs="0" maxOccurs="1"/> + <xsd:element name="formula2" type="ST_Formula" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="type" type="ST_DataValidationType" use="optional" default="none"/> + <xsd:attribute name="errorStyle" type="ST_DataValidationErrorStyle" use="optional" + default="stop"/> + <xsd:attribute name="imeMode" type="ST_DataValidationImeMode" use="optional" default="noControl"/> + <xsd:attribute name="operator" type="ST_DataValidationOperator" use="optional" default="between"/> + <xsd:attribute name="allowBlank" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="showDropDown" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="showInputMessage" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="showErrorMessage" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="errorTitle" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="error" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="promptTitle" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="prompt" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="sqref" type="ST_Sqref" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_DataValidationType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="whole"/> + <xsd:enumeration value="decimal"/> + <xsd:enumeration value="list"/> + <xsd:enumeration value="date"/> + <xsd:enumeration value="time"/> + <xsd:enumeration value="textLength"/> + <xsd:enumeration value="custom"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_DataValidationOperator"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="between"/> + <xsd:enumeration value="notBetween"/> + <xsd:enumeration value="equal"/> + <xsd:enumeration value="notEqual"/> + <xsd:enumeration value="lessThan"/> + <xsd:enumeration value="lessThanOrEqual"/> + <xsd:enumeration value="greaterThan"/> + <xsd:enumeration value="greaterThanOrEqual"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_DataValidationErrorStyle"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="stop"/> + <xsd:enumeration value="warning"/> + <xsd:enumeration value="information"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_DataValidationImeMode"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="noControl"/> + <xsd:enumeration value="off"/> + <xsd:enumeration value="on"/> + <xsd:enumeration value="disabled"/> + <xsd:enumeration value="hiragana"/> + <xsd:enumeration value="fullKatakana"/> + <xsd:enumeration value="halfKatakana"/> + <xsd:enumeration value="fullAlpha"/> + <xsd:enumeration value="halfAlpha"/> + <xsd:enumeration value="fullHangul"/> + <xsd:enumeration value="halfHangul"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_CfType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="expression"/> + <xsd:enumeration value="cellIs"/> + <xsd:enumeration value="colorScale"/> + <xsd:enumeration value="dataBar"/> + <xsd:enumeration value="iconSet"/> + <xsd:enumeration value="top10"/> + <xsd:enumeration value="uniqueValues"/> + <xsd:enumeration value="duplicateValues"/> + <xsd:enumeration value="containsText"/> + <xsd:enumeration value="notContainsText"/> + <xsd:enumeration value="beginsWith"/> + <xsd:enumeration value="endsWith"/> + <xsd:enumeration value="containsBlanks"/> + <xsd:enumeration value="notContainsBlanks"/> + <xsd:enumeration value="containsErrors"/> + <xsd:enumeration value="notContainsErrors"/> + <xsd:enumeration value="timePeriod"/> + <xsd:enumeration value="aboveAverage"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TimePeriod"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="today"/> + <xsd:enumeration value="yesterday"/> + <xsd:enumeration value="tomorrow"/> + <xsd:enumeration value="last7Days"/> + <xsd:enumeration value="thisMonth"/> + <xsd:enumeration value="lastMonth"/> + <xsd:enumeration value="nextMonth"/> + <xsd:enumeration value="thisWeek"/> + <xsd:enumeration value="lastWeek"/> + <xsd:enumeration value="nextWeek"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ConditionalFormattingOperator"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="lessThan"/> + <xsd:enumeration value="lessThanOrEqual"/> + <xsd:enumeration value="equal"/> + <xsd:enumeration value="notEqual"/> + <xsd:enumeration value="greaterThanOrEqual"/> + <xsd:enumeration value="greaterThan"/> + <xsd:enumeration value="between"/> + <xsd:enumeration value="notBetween"/> + <xsd:enumeration value="containsText"/> + <xsd:enumeration value="notContains"/> + <xsd:enumeration value="beginsWith"/> + <xsd:enumeration value="endsWith"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_CfvoType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="num"/> + <xsd:enumeration value="percent"/> + <xsd:enumeration value="max"/> + <xsd:enumeration value="min"/> + <xsd:enumeration value="formula"/> + <xsd:enumeration value="percentile"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_ConditionalFormatting"> + <xsd:sequence> + <xsd:element name="cfRule" type="CT_CfRule" minOccurs="1" maxOccurs="unbounded"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="pivot" type="xsd:boolean" default="false"/> + <xsd:attribute name="sqref" type="ST_Sqref"/> + </xsd:complexType> + <xsd:complexType name="CT_CfRule"> + <xsd:sequence> + <xsd:element name="formula" type="ST_Formula" minOccurs="0" maxOccurs="3"/> + <xsd:element name="colorScale" type="CT_ColorScale" minOccurs="0" maxOccurs="1"/> + <xsd:element name="dataBar" type="CT_DataBar" minOccurs="0" maxOccurs="1"/> + <xsd:element name="iconSet" type="CT_IconSet" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="type" type="ST_CfType"/> + <xsd:attribute name="dxfId" type="ST_DxfId" use="optional"/> + <xsd:attribute name="priority" type="xsd:int" use="required"/> + <xsd:attribute name="stopIfTrue" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="aboveAverage" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="percent" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="bottom" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="operator" type="ST_ConditionalFormattingOperator" use="optional"/> + <xsd:attribute name="text" type="xsd:string" use="optional"/> + <xsd:attribute name="timePeriod" type="ST_TimePeriod" use="optional"/> + <xsd:attribute name="rank" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="stdDev" type="xsd:int" use="optional"/> + <xsd:attribute name="equalAverage" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_Hyperlinks"> + <xsd:sequence> + <xsd:element name="hyperlink" type="CT_Hyperlink" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Hyperlink"> + <xsd:attribute name="ref" type="ST_Ref" use="required"/> + <xsd:attribute ref="r:id" use="optional"/> + <xsd:attribute name="location" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="tooltip" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="display" type="s:ST_Xstring" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_CellFormula"> + <xsd:simpleContent> + <xsd:extension base="ST_Formula"> + <xsd:attribute name="t" type="ST_CellFormulaType" use="optional" default="normal"/> + <xsd:attribute name="aca" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="ref" type="ST_Ref" use="optional"/> + <xsd:attribute name="dt2D" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="dtr" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="del1" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="del2" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="r1" type="ST_CellRef" use="optional"/> + <xsd:attribute name="r2" type="ST_CellRef" use="optional"/> + <xsd:attribute name="ca" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="si" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="bx" type="xsd:boolean" use="optional" default="false"/> + </xsd:extension> + </xsd:simpleContent> + </xsd:complexType> + <xsd:complexType name="CT_ColorScale"> + <xsd:sequence> + <xsd:element name="cfvo" type="CT_Cfvo" minOccurs="2" maxOccurs="unbounded"/> + <xsd:element name="color" type="CT_Color" minOccurs="2" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_DataBar"> + <xsd:sequence> + <xsd:element name="cfvo" type="CT_Cfvo" minOccurs="2" maxOccurs="2"/> + <xsd:element name="color" type="CT_Color" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="minLength" type="xsd:unsignedInt" use="optional" default="10"/> + <xsd:attribute name="maxLength" type="xsd:unsignedInt" use="optional" default="90"/> + <xsd:attribute name="showValue" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_IconSet"> + <xsd:sequence> + <xsd:element name="cfvo" type="CT_Cfvo" minOccurs="2" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="iconSet" type="ST_IconSetType" use="optional" default="3TrafficLights1"/> + <xsd:attribute name="showValue" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="percent" type="xsd:boolean" default="true"/> + <xsd:attribute name="reverse" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_Cfvo"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="type" type="ST_CfvoType" use="required"/> + <xsd:attribute name="val" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="gte" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_PageMargins"> + <xsd:attribute name="left" type="xsd:double" use="required"/> + <xsd:attribute name="right" type="xsd:double" use="required"/> + <xsd:attribute name="top" type="xsd:double" use="required"/> + <xsd:attribute name="bottom" type="xsd:double" use="required"/> + <xsd:attribute name="header" type="xsd:double" use="required"/> + <xsd:attribute name="footer" type="xsd:double" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_PrintOptions"> + <xsd:attribute name="horizontalCentered" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="verticalCentered" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="headings" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="gridLines" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="gridLinesSet" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_PageSetup"> + <xsd:attribute name="paperSize" type="xsd:unsignedInt" use="optional" default="1"/> + <xsd:attribute name="paperHeight" type="s:ST_PositiveUniversalMeasure" use="optional"/> + <xsd:attribute name="paperWidth" type="s:ST_PositiveUniversalMeasure" use="optional"/> + <xsd:attribute name="scale" type="xsd:unsignedInt" use="optional" default="100"/> + <xsd:attribute name="firstPageNumber" type="xsd:unsignedInt" use="optional" default="1"/> + <xsd:attribute name="fitToWidth" type="xsd:unsignedInt" use="optional" default="1"/> + <xsd:attribute name="fitToHeight" type="xsd:unsignedInt" use="optional" default="1"/> + <xsd:attribute name="pageOrder" type="ST_PageOrder" use="optional" default="downThenOver"/> + <xsd:attribute name="orientation" type="ST_Orientation" use="optional" default="default"/> + <xsd:attribute name="usePrinterDefaults" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="blackAndWhite" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="draft" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="cellComments" type="ST_CellComments" use="optional" default="none"/> + <xsd:attribute name="useFirstPageNumber" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="errors" type="ST_PrintError" use="optional" default="displayed"/> + <xsd:attribute name="horizontalDpi" type="xsd:unsignedInt" use="optional" default="600"/> + <xsd:attribute name="verticalDpi" type="xsd:unsignedInt" use="optional" default="600"/> + <xsd:attribute name="copies" type="xsd:unsignedInt" use="optional" default="1"/> + <xsd:attribute ref="r:id" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_PageOrder"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="downThenOver"/> + <xsd:enumeration value="overThenDown"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_Orientation"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="default"/> + <xsd:enumeration value="portrait"/> + <xsd:enumeration value="landscape"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_CellComments"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="asDisplayed"/> + <xsd:enumeration value="atEnd"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_HeaderFooter"> + <xsd:sequence> + <xsd:element name="oddHeader" type="s:ST_Xstring" minOccurs="0" maxOccurs="1"/> + <xsd:element name="oddFooter" type="s:ST_Xstring" minOccurs="0" maxOccurs="1"/> + <xsd:element name="evenHeader" type="s:ST_Xstring" minOccurs="0" maxOccurs="1"/> + <xsd:element name="evenFooter" type="s:ST_Xstring" minOccurs="0" maxOccurs="1"/> + <xsd:element name="firstHeader" type="s:ST_Xstring" minOccurs="0" maxOccurs="1"/> + <xsd:element name="firstFooter" type="s:ST_Xstring" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="differentOddEven" type="xsd:boolean" default="false"/> + <xsd:attribute name="differentFirst" type="xsd:boolean" default="false"/> + <xsd:attribute name="scaleWithDoc" type="xsd:boolean" default="true"/> + <xsd:attribute name="alignWithMargins" type="xsd:boolean" default="true"/> + </xsd:complexType> + <xsd:simpleType name="ST_PrintError"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="displayed"/> + <xsd:enumeration value="blank"/> + <xsd:enumeration value="dash"/> + <xsd:enumeration value="NA"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Scenarios"> + <xsd:sequence> + <xsd:element name="scenario" type="CT_Scenario" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="current" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="show" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="sqref" type="ST_Sqref" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_SheetProtection"> + <xsd:attribute name="password" type="ST_UnsignedShortHex" use="optional"/> + <xsd:attribute name="algorithmName" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="hashValue" type="xsd:base64Binary" use="optional"/> + <xsd:attribute name="saltValue" type="xsd:base64Binary" use="optional"/> + <xsd:attribute name="spinCount" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="sheet" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="objects" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="scenarios" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="formatCells" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="formatColumns" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="formatRows" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="insertColumns" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="insertRows" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="insertHyperlinks" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="deleteColumns" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="deleteRows" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="selectLockedCells" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="sort" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="autoFilter" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="pivotTables" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="selectUnlockedCells" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_ProtectedRanges"> + <xsd:sequence> + <xsd:element name="protectedRange" type="CT_ProtectedRange" minOccurs="1" + maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_ProtectedRange"> + <xsd:sequence> + <xsd:element name="securityDescriptor" type="xsd:string" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="password" type="ST_UnsignedShortHex" use="optional"/> + <xsd:attribute name="sqref" type="ST_Sqref" use="required"/> + <xsd:attribute name="name" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="securityDescriptor" type="xsd:string" use="optional"/> + <xsd:attribute name="algorithmName" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="hashValue" type="xsd:base64Binary" use="optional"/> + <xsd:attribute name="saltValue" type="xsd:base64Binary" use="optional"/> + <xsd:attribute name="spinCount" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Scenario"> + <xsd:sequence> + <xsd:element name="inputCells" type="CT_InputCells" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="name" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="locked" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="hidden" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="user" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="comment" type="s:ST_Xstring" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_InputCells"> + <xsd:attribute name="r" type="ST_CellRef" use="required"/> + <xsd:attribute name="deleted" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="undone" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="val" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="numFmtId" type="ST_NumFmtId" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_CellWatches"> + <xsd:sequence> + <xsd:element name="cellWatch" type="CT_CellWatch" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_CellWatch"> + <xsd:attribute name="r" type="ST_CellRef" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Chartsheet"> + <xsd:sequence> + <xsd:element name="sheetPr" type="CT_ChartsheetPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sheetViews" type="CT_ChartsheetViews" minOccurs="1" maxOccurs="1"/> + <xsd:element name="sheetProtection" type="CT_ChartsheetProtection" minOccurs="0" maxOccurs="1"/> + <xsd:element name="customSheetViews" type="CT_CustomChartsheetViews" minOccurs="0" + maxOccurs="1"/> + <xsd:element name="pageMargins" minOccurs="0" type="CT_PageMargins"/> + <xsd:element name="pageSetup" type="CT_CsPageSetup" minOccurs="0" maxOccurs="1"/> + <xsd:element name="headerFooter" minOccurs="0" type="CT_HeaderFooter"/> + <xsd:element name="drawing" type="CT_Drawing" minOccurs="1" maxOccurs="1"/> + <xsd:element name="legacyDrawing" type="CT_LegacyDrawing" minOccurs="0" maxOccurs="1"/> + <xsd:element name="legacyDrawingHF" type="CT_LegacyDrawing" minOccurs="0" maxOccurs="1"/> + <xsd:element name="drawingHF" type="CT_DrawingHF" minOccurs="0" maxOccurs="1"/> + <xsd:element name="picture" type="CT_SheetBackgroundPicture" minOccurs="0" maxOccurs="1"/> + <xsd:element name="webPublishItems" type="CT_WebPublishItems" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_ChartsheetPr"> + <xsd:sequence> + <xsd:element name="tabColor" type="CT_Color" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="published" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="codeName" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_ChartsheetViews"> + <xsd:sequence> + <xsd:element name="sheetView" type="CT_ChartsheetView" minOccurs="1" maxOccurs="unbounded"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_ChartsheetView"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="tabSelected" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="zoomScale" type="xsd:unsignedInt" default="100" use="optional"/> + <xsd:attribute name="workbookViewId" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="zoomToFit" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_ChartsheetProtection"> + <xsd:attribute name="password" type="ST_UnsignedShortHex" use="optional"/> + <xsd:attribute name="algorithmName" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="hashValue" type="xsd:base64Binary" use="optional"/> + <xsd:attribute name="saltValue" type="xsd:base64Binary" use="optional"/> + <xsd:attribute name="spinCount" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="content" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="objects" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_CsPageSetup"> + <xsd:attribute name="paperSize" type="xsd:unsignedInt" use="optional" default="1"/> + <xsd:attribute name="paperHeight" type="s:ST_PositiveUniversalMeasure" use="optional"/> + <xsd:attribute name="paperWidth" type="s:ST_PositiveUniversalMeasure" use="optional"/> + <xsd:attribute name="firstPageNumber" type="xsd:unsignedInt" use="optional" default="1"/> + <xsd:attribute name="orientation" type="ST_Orientation" use="optional" default="default"/> + <xsd:attribute name="usePrinterDefaults" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="blackAndWhite" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="draft" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="useFirstPageNumber" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="horizontalDpi" type="xsd:unsignedInt" use="optional" default="600"/> + <xsd:attribute name="verticalDpi" type="xsd:unsignedInt" use="optional" default="600"/> + <xsd:attribute name="copies" type="xsd:unsignedInt" use="optional" default="1"/> + <xsd:attribute ref="r:id" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_CustomChartsheetViews"> + <xsd:sequence> + <xsd:element name="customSheetView" minOccurs="0" maxOccurs="unbounded" + type="CT_CustomChartsheetView"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_CustomChartsheetView"> + <xsd:sequence> + <xsd:element name="pageMargins" type="CT_PageMargins" minOccurs="0" maxOccurs="1"/> + <xsd:element name="pageSetup" type="CT_CsPageSetup" minOccurs="0" maxOccurs="1"/> + <xsd:element name="headerFooter" type="CT_HeaderFooter" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="guid" type="s:ST_Guid" use="required"/> + <xsd:attribute name="scale" type="xsd:unsignedInt" default="100"/> + <xsd:attribute name="state" type="ST_SheetState" default="visible"/> + <xsd:attribute name="zoomToFit" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_CustomProperties"> + <xsd:sequence> + <xsd:element name="customPr" type="CT_CustomProperty" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_CustomProperty"> + <xsd:attribute name="name" type="s:ST_Xstring" use="required"/> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_OleObjects"> + <xsd:sequence> + <xsd:element name="oleObject" type="CT_OleObject" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_OleObject"> + <xsd:sequence> + <xsd:element name="objectPr" type="CT_ObjectPr" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="progId" type="xsd:string" use="optional"/> + <xsd:attribute name="dvAspect" type="ST_DvAspect" use="optional" default="DVASPECT_CONTENT"/> + <xsd:attribute name="link" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="oleUpdate" type="ST_OleUpdate" use="optional"/> + <xsd:attribute name="autoLoad" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="shapeId" type="xsd:unsignedInt" use="required"/> + <xsd:attribute ref="r:id" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_ObjectPr"> + <xsd:sequence> + <xsd:element name="anchor" type="CT_ObjectAnchor" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="locked" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="defaultSize" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="print" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="disabled" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="uiObject" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="autoFill" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="autoLine" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="autoPict" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="macro" type="ST_Formula" use="optional"/> + <xsd:attribute name="altText" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="dde" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute ref="r:id" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_DvAspect"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="DVASPECT_CONTENT"/> + <xsd:enumeration value="DVASPECT_ICON"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_OleUpdate"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="OLEUPDATE_ALWAYS"/> + <xsd:enumeration value="OLEUPDATE_ONCALL"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_WebPublishItems"> + <xsd:sequence> + <xsd:element name="webPublishItem" type="CT_WebPublishItem" minOccurs="1" + maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_WebPublishItem"> + <xsd:attribute name="id" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="divId" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="sourceType" type="ST_WebSourceType" use="required"/> + <xsd:attribute name="sourceRef" type="ST_Ref" use="optional"/> + <xsd:attribute name="sourceObject" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="destinationFile" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="title" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="autoRepublish" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_Controls"> + <xsd:sequence> + <xsd:element name="control" type="CT_Control" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Control"> + <xsd:sequence> + <xsd:element name="controlPr" type="CT_ControlPr" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="shapeId" type="xsd:unsignedInt" use="required"/> + <xsd:attribute ref="r:id" use="required"/> + <xsd:attribute name="name" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_ControlPr"> + <xsd:sequence> + <xsd:element name="anchor" type="CT_ObjectAnchor" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="locked" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="defaultSize" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="print" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="disabled" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="recalcAlways" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="uiObject" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="autoFill" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="autoLine" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="autoPict" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="macro" type="ST_Formula" use="optional"/> + <xsd:attribute name="altText" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="linkedCell" type="ST_Formula" use="optional"/> + <xsd:attribute name="listFillRange" type="ST_Formula" use="optional"/> + <xsd:attribute name="cf" type="s:ST_Xstring" use="optional" default="pict"/> + <xsd:attribute ref="r:id" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_WebSourceType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="sheet"/> + <xsd:enumeration value="printArea"/> + <xsd:enumeration value="autoFilter"/> + <xsd:enumeration value="range"/> + <xsd:enumeration value="chart"/> + <xsd:enumeration value="pivotTable"/> + <xsd:enumeration value="query"/> + <xsd:enumeration value="label"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_IgnoredErrors"> + <xsd:sequence> + <xsd:element name="ignoredError" type="CT_IgnoredError" minOccurs="1" maxOccurs="unbounded"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_IgnoredError"> + <xsd:attribute name="sqref" type="ST_Sqref" use="required"/> + <xsd:attribute name="evalError" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="twoDigitTextYear" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="numberStoredAsText" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="formula" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="formulaRange" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="unlockedFormula" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="emptyCellReference" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="listDataValidation" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="calculatedColumn" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:simpleType name="ST_PaneState"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="split"/> + <xsd:enumeration value="frozen"/> + <xsd:enumeration value="frozenSplit"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TableParts"> + <xsd:sequence> + <xsd:element name="tablePart" type="CT_TablePart" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_TablePart"> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:element name="metadata" type="CT_Metadata"/> + <xsd:complexType name="CT_Metadata"> + <xsd:sequence> + <xsd:element name="metadataTypes" type="CT_MetadataTypes" minOccurs="0" maxOccurs="1"/> + <xsd:element name="metadataStrings" type="CT_MetadataStrings" minOccurs="0" maxOccurs="1"/> + <xsd:element name="mdxMetadata" type="CT_MdxMetadata" minOccurs="0" maxOccurs="1"/> + <xsd:element name="futureMetadata" type="CT_FutureMetadata" minOccurs="0" + maxOccurs="unbounded"/> + <xsd:element name="cellMetadata" type="CT_MetadataBlocks" minOccurs="0" maxOccurs="1"/> + <xsd:element name="valueMetadata" type="CT_MetadataBlocks" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" minOccurs="0" maxOccurs="1" type="CT_ExtensionList"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_MetadataTypes"> + <xsd:sequence> + <xsd:element name="metadataType" type="CT_MetadataType" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_MetadataType"> + <xsd:attribute name="name" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="minSupportedVersion" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="ghostRow" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="ghostCol" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="edit" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="delete" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="copy" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="pasteAll" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="pasteFormulas" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="pasteValues" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="pasteFormats" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="pasteComments" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="pasteDataValidation" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="pasteBorders" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="pasteColWidths" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="pasteNumberFormats" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="merge" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="splitFirst" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="splitAll" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="rowColShift" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="clearAll" type="xsd:boolean" default="false"/> + <xsd:attribute name="clearFormats" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="clearContents" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="clearComments" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="assign" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="coerce" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="adjust" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="cellMeta" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_MetadataBlocks"> + <xsd:sequence> + <xsd:element name="bk" type="CT_MetadataBlock" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_MetadataBlock"> + <xsd:sequence> + <xsd:element name="rc" type="CT_MetadataRecord" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_MetadataRecord"> + <xsd:attribute name="t" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="v" type="xsd:unsignedInt" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_FutureMetadata"> + <xsd:sequence> + <xsd:element name="bk" type="CT_FutureMetadataBlock" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="extLst" minOccurs="0" maxOccurs="1" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="name" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_FutureMetadataBlock"> + <xsd:sequence> + <xsd:element name="extLst" minOccurs="0" maxOccurs="1" type="CT_ExtensionList"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_MdxMetadata"> + <xsd:sequence> + <xsd:element name="mdx" type="CT_Mdx" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_Mdx"> + <xsd:choice minOccurs="1" maxOccurs="1"> + <xsd:element name="t" type="CT_MdxTuple"/> + <xsd:element name="ms" type="CT_MdxSet"/> + <xsd:element name="p" type="CT_MdxMemeberProp"/> + <xsd:element name="k" type="CT_MdxKPI"/> + </xsd:choice> + <xsd:attribute name="n" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="f" type="ST_MdxFunctionType" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_MdxFunctionType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="m"/> + <xsd:enumeration value="v"/> + <xsd:enumeration value="s"/> + <xsd:enumeration value="c"/> + <xsd:enumeration value="r"/> + <xsd:enumeration value="p"/> + <xsd:enumeration value="k"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_MdxTuple"> + <xsd:sequence> + <xsd:element name="n" type="CT_MetadataStringIndex" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="c" type="xsd:unsignedInt" use="optional" default="0"/> + <xsd:attribute name="ct" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="si" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="fi" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="bc" type="ST_UnsignedIntHex" use="optional"/> + <xsd:attribute name="fc" type="ST_UnsignedIntHex" use="optional"/> + <xsd:attribute name="i" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="u" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="st" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="b" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_MdxSet"> + <xsd:sequence> + <xsd:element name="n" type="CT_MetadataStringIndex" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="ns" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="c" type="xsd:unsignedInt" use="optional" default="0"/> + <xsd:attribute name="o" type="ST_MdxSetOrder" use="optional" default="u"/> + </xsd:complexType> + <xsd:simpleType name="ST_MdxSetOrder"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="u"/> + <xsd:enumeration value="a"/> + <xsd:enumeration value="d"/> + <xsd:enumeration value="aa"/> + <xsd:enumeration value="ad"/> + <xsd:enumeration value="na"/> + <xsd:enumeration value="nd"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_MdxMemeberProp"> + <xsd:attribute name="n" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="np" type="xsd:unsignedInt" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_MdxKPI"> + <xsd:attribute name="n" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="np" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="p" type="ST_MdxKPIProperty" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_MdxKPIProperty"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="v"/> + <xsd:enumeration value="g"/> + <xsd:enumeration value="s"/> + <xsd:enumeration value="t"/> + <xsd:enumeration value="w"/> + <xsd:enumeration value="m"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_MetadataStringIndex"> + <xsd:attribute name="x" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="s" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_MetadataStrings"> + <xsd:sequence> + <xsd:element name="s" type="CT_XStringElement" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional" default="0"/> + </xsd:complexType> + <xsd:element name="singleXmlCells" type="CT_SingleXmlCells"/> + <xsd:complexType name="CT_SingleXmlCells"> + <xsd:sequence> + <xsd:element name="singleXmlCell" type="CT_SingleXmlCell" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SingleXmlCell"> + <xsd:sequence> + <xsd:element name="xmlCellPr" type="CT_XmlCellPr" minOccurs="1" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="id" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="r" type="ST_CellRef" use="required"/> + <xsd:attribute name="connectionId" type="xsd:unsignedInt" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_XmlCellPr"> + <xsd:sequence> + <xsd:element name="xmlPr" type="CT_XmlPr" minOccurs="1" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="id" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="uniqueName" type="s:ST_Xstring" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_XmlPr"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="mapId" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="xpath" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="xmlDataType" type="ST_XmlDataType" use="required"/> + </xsd:complexType> + <xsd:element name="styleSheet" type="CT_Stylesheet"/> + <xsd:complexType name="CT_Stylesheet"> + <xsd:sequence> + <xsd:element name="numFmts" type="CT_NumFmts" minOccurs="0" maxOccurs="1"/> + <xsd:element name="fonts" type="CT_Fonts" minOccurs="0" maxOccurs="1"/> + <xsd:element name="fills" type="CT_Fills" minOccurs="0" maxOccurs="1"/> + <xsd:element name="borders" type="CT_Borders" minOccurs="0" maxOccurs="1"/> + <xsd:element name="cellStyleXfs" type="CT_CellStyleXfs" minOccurs="0" maxOccurs="1"/> + <xsd:element name="cellXfs" type="CT_CellXfs" minOccurs="0" maxOccurs="1"/> + <xsd:element name="cellStyles" type="CT_CellStyles" minOccurs="0" maxOccurs="1"/> + <xsd:element name="dxfs" type="CT_Dxfs" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tableStyles" type="CT_TableStyles" minOccurs="0" maxOccurs="1"/> + <xsd:element name="colors" type="CT_Colors" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_CellAlignment"> + <xsd:attribute name="horizontal" type="ST_HorizontalAlignment" use="optional"/> + <xsd:attribute name="vertical" type="ST_VerticalAlignment" default="bottom" use="optional"/> + <xsd:attribute name="textRotation" type="ST_TextRotation" use="optional"/> + <xsd:attribute name="wrapText" type="xsd:boolean" use="optional"/> + <xsd:attribute name="indent" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="relativeIndent" type="xsd:int" use="optional"/> + <xsd:attribute name="justifyLastLine" type="xsd:boolean" use="optional"/> + <xsd:attribute name="shrinkToFit" type="xsd:boolean" use="optional"/> + <xsd:attribute name="readingOrder" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_TextRotation"> + <xsd:union> + <xsd:simpleType> + <xsd:restriction base="xsd:nonNegativeInteger"> + <xsd:maxInclusive value="180"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType> + <xsd:restriction base="xsd:nonNegativeInteger"> + <xsd:enumeration value="255"/> + </xsd:restriction> + </xsd:simpleType> + </xsd:union> + </xsd:simpleType> + <xsd:simpleType name="ST_BorderStyle"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="thin"/> + <xsd:enumeration value="medium"/> + <xsd:enumeration value="dashed"/> + <xsd:enumeration value="dotted"/> + <xsd:enumeration value="thick"/> + <xsd:enumeration value="double"/> + <xsd:enumeration value="hair"/> + <xsd:enumeration value="mediumDashed"/> + <xsd:enumeration value="dashDot"/> + <xsd:enumeration value="mediumDashDot"/> + <xsd:enumeration value="dashDotDot"/> + <xsd:enumeration value="mediumDashDotDot"/> + <xsd:enumeration value="slantDashDot"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Borders"> + <xsd:sequence> + <xsd:element name="border" type="CT_Border" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Border"> + <xsd:sequence> + <xsd:element name="start" type="CT_BorderPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="end" type="CT_BorderPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="left" type="CT_BorderPr" minOccurs="0"/> + <xsd:element name="right" type="CT_BorderPr" minOccurs="0"/> + <xsd:element name="top" type="CT_BorderPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="bottom" type="CT_BorderPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="diagonal" type="CT_BorderPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="vertical" type="CT_BorderPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="horizontal" type="CT_BorderPr" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="diagonalUp" type="xsd:boolean" use="optional"/> + <xsd:attribute name="diagonalDown" type="xsd:boolean" use="optional"/> + <xsd:attribute name="outline" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_BorderPr"> + <xsd:sequence> + <xsd:element name="color" type="CT_Color" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="style" type="ST_BorderStyle" use="optional" default="none"/> + </xsd:complexType> + <xsd:complexType name="CT_CellProtection"> + <xsd:attribute name="locked" type="xsd:boolean" use="optional"/> + <xsd:attribute name="hidden" type="xsd:boolean" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Fonts"> + <xsd:sequence> + <xsd:element name="font" type="CT_Font" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Fills"> + <xsd:sequence> + <xsd:element name="fill" type="CT_Fill" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Fill"> + <xsd:choice minOccurs="1" maxOccurs="1"> + <xsd:element name="patternFill" type="CT_PatternFill" minOccurs="0" maxOccurs="1"/> + <xsd:element name="gradientFill" type="CT_GradientFill" minOccurs="0" maxOccurs="1"/> + </xsd:choice> + </xsd:complexType> + <xsd:complexType name="CT_PatternFill"> + <xsd:sequence> + <xsd:element name="fgColor" type="CT_Color" minOccurs="0" maxOccurs="1"/> + <xsd:element name="bgColor" type="CT_Color" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="patternType" type="ST_PatternType" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Color"> + <xsd:attribute name="auto" type="xsd:boolean" use="optional"/> + <xsd:attribute name="indexed" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="rgb" type="ST_UnsignedIntHex" use="optional"/> + <xsd:attribute name="theme" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="tint" type="xsd:double" use="optional" default="0.0"/> + </xsd:complexType> + <xsd:simpleType name="ST_PatternType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="solid"/> + <xsd:enumeration value="mediumGray"/> + <xsd:enumeration value="darkGray"/> + <xsd:enumeration value="lightGray"/> + <xsd:enumeration value="darkHorizontal"/> + <xsd:enumeration value="darkVertical"/> + <xsd:enumeration value="darkDown"/> + <xsd:enumeration value="darkUp"/> + <xsd:enumeration value="darkGrid"/> + <xsd:enumeration value="darkTrellis"/> + <xsd:enumeration value="lightHorizontal"/> + <xsd:enumeration value="lightVertical"/> + <xsd:enumeration value="lightDown"/> + <xsd:enumeration value="lightUp"/> + <xsd:enumeration value="lightGrid"/> + <xsd:enumeration value="lightTrellis"/> + <xsd:enumeration value="gray125"/> + <xsd:enumeration value="gray0625"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_GradientFill"> + <xsd:sequence> + <xsd:element name="stop" type="CT_GradientStop" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="type" type="ST_GradientType" use="optional" default="linear"/> + <xsd:attribute name="degree" type="xsd:double" use="optional" default="0"/> + <xsd:attribute name="left" type="xsd:double" use="optional" default="0"/> + <xsd:attribute name="right" type="xsd:double" use="optional" default="0"/> + <xsd:attribute name="top" type="xsd:double" use="optional" default="0"/> + <xsd:attribute name="bottom" type="xsd:double" use="optional" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_GradientStop"> + <xsd:sequence> + <xsd:element name="color" type="CT_Color" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="position" type="xsd:double" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_GradientType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="linear"/> + <xsd:enumeration value="path"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_HorizontalAlignment"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="general"/> + <xsd:enumeration value="left"/> + <xsd:enumeration value="center"/> + <xsd:enumeration value="right"/> + <xsd:enumeration value="fill"/> + <xsd:enumeration value="justify"/> + <xsd:enumeration value="centerContinuous"/> + <xsd:enumeration value="distributed"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_VerticalAlignment"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="top"/> + <xsd:enumeration value="center"/> + <xsd:enumeration value="bottom"/> + <xsd:enumeration value="justify"/> + <xsd:enumeration value="distributed"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_NumFmts"> + <xsd:sequence> + <xsd:element name="numFmt" type="CT_NumFmt" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_NumFmt"> + <xsd:attribute name="numFmtId" type="ST_NumFmtId" use="required"/> + <xsd:attribute name="formatCode" type="s:ST_Xstring" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_CellStyleXfs"> + <xsd:sequence> + <xsd:element name="xf" type="CT_Xf" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_CellXfs"> + <xsd:sequence> + <xsd:element name="xf" type="CT_Xf" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Xf"> + <xsd:sequence> + <xsd:element name="alignment" type="CT_CellAlignment" minOccurs="0" maxOccurs="1"/> + <xsd:element name="protection" type="CT_CellProtection" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="numFmtId" type="ST_NumFmtId" use="optional"/> + <xsd:attribute name="fontId" type="ST_FontId" use="optional"/> + <xsd:attribute name="fillId" type="ST_FillId" use="optional"/> + <xsd:attribute name="borderId" type="ST_BorderId" use="optional"/> + <xsd:attribute name="xfId" type="ST_CellStyleXfId" use="optional"/> + <xsd:attribute name="quotePrefix" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="pivotButton" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="applyNumberFormat" type="xsd:boolean" use="optional"/> + <xsd:attribute name="applyFont" type="xsd:boolean" use="optional"/> + <xsd:attribute name="applyFill" type="xsd:boolean" use="optional"/> + <xsd:attribute name="applyBorder" type="xsd:boolean" use="optional"/> + <xsd:attribute name="applyAlignment" type="xsd:boolean" use="optional"/> + <xsd:attribute name="applyProtection" type="xsd:boolean" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_CellStyles"> + <xsd:sequence> + <xsd:element name="cellStyle" type="CT_CellStyle" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_CellStyle"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="name" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="xfId" type="ST_CellStyleXfId" use="required"/> + <xsd:attribute name="builtinId" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="iLevel" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="hidden" type="xsd:boolean" use="optional"/> + <xsd:attribute name="customBuiltin" type="xsd:boolean" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Dxfs"> + <xsd:sequence> + <xsd:element name="dxf" type="CT_Dxf" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Dxf"> + <xsd:sequence> + <xsd:element name="font" type="CT_Font" minOccurs="0" maxOccurs="1"/> + <xsd:element name="numFmt" type="CT_NumFmt" minOccurs="0" maxOccurs="1"/> + <xsd:element name="fill" type="CT_Fill" minOccurs="0" maxOccurs="1"/> + <xsd:element name="alignment" type="CT_CellAlignment" minOccurs="0" maxOccurs="1"/> + <xsd:element name="border" type="CT_Border" minOccurs="0" maxOccurs="1"/> + <xsd:element name="protection" type="CT_CellProtection" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_NumFmtId"> + <xsd:restriction base="xsd:unsignedInt"/> + </xsd:simpleType> + <xsd:simpleType name="ST_FontId"> + <xsd:restriction base="xsd:unsignedInt"/> + </xsd:simpleType> + <xsd:simpleType name="ST_FillId"> + <xsd:restriction base="xsd:unsignedInt"/> + </xsd:simpleType> + <xsd:simpleType name="ST_BorderId"> + <xsd:restriction base="xsd:unsignedInt"/> + </xsd:simpleType> + <xsd:simpleType name="ST_CellStyleXfId"> + <xsd:restriction base="xsd:unsignedInt"/> + </xsd:simpleType> + <xsd:simpleType name="ST_DxfId"> + <xsd:restriction base="xsd:unsignedInt"/> + </xsd:simpleType> + <xsd:complexType name="CT_Colors"> + <xsd:sequence> + <xsd:element name="indexedColors" type="CT_IndexedColors" minOccurs="0" maxOccurs="1"/> + <xsd:element name="mruColors" type="CT_MRUColors" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_IndexedColors"> + <xsd:sequence> + <xsd:element name="rgbColor" type="CT_RgbColor" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_MRUColors"> + <xsd:sequence> + <xsd:element name="color" type="CT_Color" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_RgbColor"> + <xsd:attribute name="rgb" type="ST_UnsignedIntHex" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_TableStyles"> + <xsd:sequence> + <xsd:element name="tableStyle" type="CT_TableStyle" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="defaultTableStyle" type="xsd:string" use="optional"/> + <xsd:attribute name="defaultPivotStyle" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_TableStyle"> + <xsd:sequence> + <xsd:element name="tableStyleElement" type="CT_TableStyleElement" minOccurs="0" + maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="required"/> + <xsd:attribute name="pivot" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="table" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_TableStyleElement"> + <xsd:attribute name="type" type="ST_TableStyleType" use="required"/> + <xsd:attribute name="size" type="xsd:unsignedInt" use="optional" default="1"/> + <xsd:attribute name="dxfId" type="ST_DxfId" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_TableStyleType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="wholeTable"/> + <xsd:enumeration value="headerRow"/> + <xsd:enumeration value="totalRow"/> + <xsd:enumeration value="firstColumn"/> + <xsd:enumeration value="lastColumn"/> + <xsd:enumeration value="firstRowStripe"/> + <xsd:enumeration value="secondRowStripe"/> + <xsd:enumeration value="firstColumnStripe"/> + <xsd:enumeration value="secondColumnStripe"/> + <xsd:enumeration value="firstHeaderCell"/> + <xsd:enumeration value="lastHeaderCell"/> + <xsd:enumeration value="firstTotalCell"/> + <xsd:enumeration value="lastTotalCell"/> + <xsd:enumeration value="firstSubtotalColumn"/> + <xsd:enumeration value="secondSubtotalColumn"/> + <xsd:enumeration value="thirdSubtotalColumn"/> + <xsd:enumeration value="firstSubtotalRow"/> + <xsd:enumeration value="secondSubtotalRow"/> + <xsd:enumeration value="thirdSubtotalRow"/> + <xsd:enumeration value="blankRow"/> + <xsd:enumeration value="firstColumnSubheading"/> + <xsd:enumeration value="secondColumnSubheading"/> + <xsd:enumeration value="thirdColumnSubheading"/> + <xsd:enumeration value="firstRowSubheading"/> + <xsd:enumeration value="secondRowSubheading"/> + <xsd:enumeration value="thirdRowSubheading"/> + <xsd:enumeration value="pageFieldLabels"/> + <xsd:enumeration value="pageFieldValues"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_BooleanProperty"> + <xsd:attribute name="val" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:complexType name="CT_FontSize"> + <xsd:attribute name="val" type="xsd:double" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_IntProperty"> + <xsd:attribute name="val" type="xsd:int" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_FontName"> + <xsd:attribute name="val" type="s:ST_Xstring" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_VerticalAlignFontProperty"> + <xsd:attribute name="val" type="s:ST_VerticalAlignRun" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_FontScheme"> + <xsd:attribute name="val" type="ST_FontScheme" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_FontScheme"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="major"/> + <xsd:enumeration value="minor"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_UnderlineProperty"> + <xsd:attribute name="val" type="ST_UnderlineValues" use="optional" default="single"/> + </xsd:complexType> + <xsd:simpleType name="ST_UnderlineValues"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="single"/> + <xsd:enumeration value="double"/> + <xsd:enumeration value="singleAccounting"/> + <xsd:enumeration value="doubleAccounting"/> + <xsd:enumeration value="none"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Font"> + <xsd:choice maxOccurs="unbounded"> + <xsd:element name="name" type="CT_FontName" minOccurs="0" maxOccurs="1"/> + <xsd:element name="charset" type="CT_IntProperty" minOccurs="0" maxOccurs="1"/> + <xsd:element name="family" type="CT_FontFamily" minOccurs="0" maxOccurs="1"/> + <xsd:element name="b" type="CT_BooleanProperty" minOccurs="0" maxOccurs="1"/> + <xsd:element name="i" type="CT_BooleanProperty" minOccurs="0" maxOccurs="1"/> + <xsd:element name="strike" type="CT_BooleanProperty" minOccurs="0" maxOccurs="1"/> + <xsd:element name="outline" type="CT_BooleanProperty" minOccurs="0" maxOccurs="1"/> + <xsd:element name="shadow" type="CT_BooleanProperty" minOccurs="0" maxOccurs="1"/> + <xsd:element name="condense" type="CT_BooleanProperty" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extend" type="CT_BooleanProperty" minOccurs="0" maxOccurs="1"/> + <xsd:element name="color" type="CT_Color" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sz" type="CT_FontSize" minOccurs="0" maxOccurs="1"/> + <xsd:element name="u" type="CT_UnderlineProperty" minOccurs="0" maxOccurs="1"/> + <xsd:element name="vertAlign" type="CT_VerticalAlignFontProperty" minOccurs="0" maxOccurs="1"/> + <xsd:element name="scheme" type="CT_FontScheme" minOccurs="0" maxOccurs="1"/> + </xsd:choice> + </xsd:complexType> + <xsd:complexType name="CT_FontFamily"> + <xsd:attribute name="val" type="ST_FontFamily" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_FontFamily"> + <xsd:restriction base="xsd:integer"> + <xsd:minInclusive value="0"/> + <xsd:maxInclusive value="14"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:attributeGroup name="AG_AutoFormat"> + <xsd:attribute name="autoFormatId" type="xsd:unsignedInt"/> + <xsd:attribute name="applyNumberFormats" type="xsd:boolean"/> + <xsd:attribute name="applyBorderFormats" type="xsd:boolean"/> + <xsd:attribute name="applyFontFormats" type="xsd:boolean"/> + <xsd:attribute name="applyPatternFormats" type="xsd:boolean"/> + <xsd:attribute name="applyAlignmentFormats" type="xsd:boolean"/> + <xsd:attribute name="applyWidthHeightFormats" type="xsd:boolean"/> + </xsd:attributeGroup> + <xsd:element name="externalLink" type="CT_ExternalLink"/> + <xsd:complexType name="CT_ExternalLink"> + <xsd:sequence> + <xsd:choice> + <xsd:element name="externalBook" type="CT_ExternalBook" minOccurs="0" maxOccurs="1"/> + <xsd:element name="ddeLink" type="CT_DdeLink" minOccurs="0" maxOccurs="1"/> + <xsd:element name="oleLink" type="CT_OleLink" minOccurs="0" maxOccurs="1"/> + </xsd:choice> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_ExternalBook"> + <xsd:sequence> + <xsd:element name="sheetNames" type="CT_ExternalSheetNames" minOccurs="0" maxOccurs="1"/> + <xsd:element name="definedNames" type="CT_ExternalDefinedNames" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sheetDataSet" type="CT_ExternalSheetDataSet" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_ExternalSheetNames"> + <xsd:sequence> + <xsd:element name="sheetName" minOccurs="1" maxOccurs="unbounded" type="CT_ExternalSheetName" + /> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_ExternalSheetName"> + <xsd:attribute name="val" type="s:ST_Xstring"/> + </xsd:complexType> + <xsd:complexType name="CT_ExternalDefinedNames"> + <xsd:sequence> + <xsd:element name="definedName" type="CT_ExternalDefinedName" minOccurs="0" + maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_ExternalDefinedName"> + <xsd:attribute name="name" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="refersTo" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="sheetId" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_ExternalSheetDataSet"> + <xsd:sequence> + <xsd:element name="sheetData" type="CT_ExternalSheetData" minOccurs="1" maxOccurs="unbounded" + /> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_ExternalSheetData"> + <xsd:sequence> + <xsd:element name="row" type="CT_ExternalRow" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="sheetId" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="refreshError" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_ExternalRow"> + <xsd:sequence> + <xsd:element name="cell" type="CT_ExternalCell" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="r" type="xsd:unsignedInt" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_ExternalCell"> + <xsd:sequence> + <xsd:element name="v" type="s:ST_Xstring" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="r" type="ST_CellRef" use="optional"/> + <xsd:attribute name="t" type="ST_CellType" use="optional" default="n"/> + <xsd:attribute name="vm" type="xsd:unsignedInt" use="optional" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_DdeLink"> + <xsd:sequence> + <xsd:element name="ddeItems" type="CT_DdeItems" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="ddeService" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="ddeTopic" type="s:ST_Xstring" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_DdeItems"> + <xsd:sequence> + <xsd:element name="ddeItem" type="CT_DdeItem" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_DdeItem"> + <xsd:sequence> + <xsd:element name="values" type="CT_DdeValues" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="name" type="s:ST_Xstring" default="0"/> + <xsd:attribute name="ole" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="advise" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="preferPic" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_DdeValues"> + <xsd:sequence> + <xsd:element name="value" minOccurs="1" maxOccurs="unbounded" type="CT_DdeValue"/> + </xsd:sequence> + <xsd:attribute name="rows" type="xsd:unsignedInt" use="optional" default="1"/> + <xsd:attribute name="cols" type="xsd:unsignedInt" use="optional" default="1"/> + </xsd:complexType> + <xsd:complexType name="CT_DdeValue"> + <xsd:sequence> + <xsd:element name="val" type="s:ST_Xstring" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="t" type="ST_DdeValueType" use="optional" default="n"/> + </xsd:complexType> + <xsd:simpleType name="ST_DdeValueType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="nil"/> + <xsd:enumeration value="b"/> + <xsd:enumeration value="n"/> + <xsd:enumeration value="e"/> + <xsd:enumeration value="str"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_OleLink"> + <xsd:sequence> + <xsd:element name="oleItems" type="CT_OleItems" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute ref="r:id" use="required"/> + <xsd:attribute name="progId" type="s:ST_Xstring" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_OleItems"> + <xsd:sequence> + <xsd:element name="oleItem" type="CT_OleItem" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_OleItem"> + <xsd:attribute name="name" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="icon" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="advise" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="preferPic" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:element name="table" type="CT_Table"/> + <xsd:complexType name="CT_Table"> + <xsd:sequence> + <xsd:element name="autoFilter" type="CT_AutoFilter" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sortState" type="CT_SortState" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tableColumns" type="CT_TableColumns" minOccurs="1" maxOccurs="1"/> + <xsd:element name="tableStyleInfo" type="CT_TableStyleInfo" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="id" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="name" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="displayName" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="comment" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="ref" type="ST_Ref" use="required"/> + <xsd:attribute name="tableType" type="ST_TableType" use="optional" default="worksheet"/> + <xsd:attribute name="headerRowCount" type="xsd:unsignedInt" use="optional" default="1"/> + <xsd:attribute name="insertRow" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="insertRowShift" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="totalsRowCount" type="xsd:unsignedInt" use="optional" default="0"/> + <xsd:attribute name="totalsRowShown" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="published" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="headerRowDxfId" type="ST_DxfId" use="optional"/> + <xsd:attribute name="dataDxfId" type="ST_DxfId" use="optional"/> + <xsd:attribute name="totalsRowDxfId" type="ST_DxfId" use="optional"/> + <xsd:attribute name="headerRowBorderDxfId" type="ST_DxfId" use="optional"/> + <xsd:attribute name="tableBorderDxfId" type="ST_DxfId" use="optional"/> + <xsd:attribute name="totalsRowBorderDxfId" type="ST_DxfId" use="optional"/> + <xsd:attribute name="headerRowCellStyle" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="dataCellStyle" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="totalsRowCellStyle" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="connectionId" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_TableType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="worksheet"/> + <xsd:enumeration value="xml"/> + <xsd:enumeration value="queryTable"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TableStyleInfo"> + <xsd:attribute name="name" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="showFirstColumn" type="xsd:boolean" use="optional"/> + <xsd:attribute name="showLastColumn" type="xsd:boolean" use="optional"/> + <xsd:attribute name="showRowStripes" type="xsd:boolean" use="optional"/> + <xsd:attribute name="showColumnStripes" type="xsd:boolean" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_TableColumns"> + <xsd:sequence> + <xsd:element name="tableColumn" type="CT_TableColumn" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_TableColumn"> + <xsd:sequence> + <xsd:element name="calculatedColumnFormula" type="CT_TableFormula" minOccurs="0" maxOccurs="1"/> + <xsd:element name="totalsRowFormula" type="CT_TableFormula" minOccurs="0" maxOccurs="1"/> + <xsd:element name="xmlColumnPr" type="CT_XmlColumnPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="id" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="uniqueName" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="name" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="totalsRowFunction" type="ST_TotalsRowFunction" use="optional" + default="none"/> + <xsd:attribute name="totalsRowLabel" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="queryTableFieldId" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="headerRowDxfId" type="ST_DxfId" use="optional"/> + <xsd:attribute name="dataDxfId" type="ST_DxfId" use="optional"/> + <xsd:attribute name="totalsRowDxfId" type="ST_DxfId" use="optional"/> + <xsd:attribute name="headerRowCellStyle" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="dataCellStyle" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="totalsRowCellStyle" type="s:ST_Xstring" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_TableFormula"> + <xsd:simpleContent> + <xsd:extension base="ST_Formula"> + <xsd:attribute name="array" type="xsd:boolean" default="false"/> + </xsd:extension> + </xsd:simpleContent> + </xsd:complexType> + <xsd:simpleType name="ST_TotalsRowFunction"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="sum"/> + <xsd:enumeration value="min"/> + <xsd:enumeration value="max"/> + <xsd:enumeration value="average"/> + <xsd:enumeration value="count"/> + <xsd:enumeration value="countNums"/> + <xsd:enumeration value="stdDev"/> + <xsd:enumeration value="var"/> + <xsd:enumeration value="custom"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_XmlColumnPr"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="mapId" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="xpath" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="denormalized" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="xmlDataType" type="ST_XmlDataType" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_XmlDataType"> + <xsd:restriction base="xsd:string"/> + </xsd:simpleType> + <xsd:element name="volTypes" type="CT_VolTypes"/> + <xsd:complexType name="CT_VolTypes"> + <xsd:sequence> + <xsd:element name="volType" type="CT_VolType" minOccurs="1" maxOccurs="unbounded"/> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_VolType"> + <xsd:sequence> + <xsd:element name="main" type="CT_VolMain" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="type" type="ST_VolDepType" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_VolMain"> + <xsd:sequence> + <xsd:element name="tp" type="CT_VolTopic" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="first" type="s:ST_Xstring" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_VolTopic"> + <xsd:sequence> + <xsd:element name="v" type="s:ST_Xstring" minOccurs="1" maxOccurs="1"/> + <xsd:element name="stp" type="s:ST_Xstring" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="tr" type="CT_VolTopicRef" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="t" type="ST_VolValueType" use="optional" default="n"/> + </xsd:complexType> + <xsd:complexType name="CT_VolTopicRef"> + <xsd:attribute name="r" type="ST_CellRef" use="required"/> + <xsd:attribute name="s" type="xsd:unsignedInt" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_VolDepType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="realTimeData"/> + <xsd:enumeration value="olapFunctions"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_VolValueType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="b"/> + <xsd:enumeration value="n"/> + <xsd:enumeration value="e"/> + <xsd:enumeration value="s"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:element name="workbook" type="CT_Workbook"/> + <xsd:complexType name="CT_Workbook"> + <xsd:sequence> + <xsd:element name="fileVersion" type="CT_FileVersion" minOccurs="0" maxOccurs="1"/> + <xsd:element name="fileSharing" type="CT_FileSharing" minOccurs="0" maxOccurs="1"/> + <xsd:element name="workbookPr" type="CT_WorkbookPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="workbookProtection" type="CT_WorkbookProtection" minOccurs="0" + maxOccurs="1"/> + <xsd:element name="bookViews" type="CT_BookViews" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sheets" type="CT_Sheets" minOccurs="1" maxOccurs="1"/> + <xsd:element name="functionGroups" type="CT_FunctionGroups" minOccurs="0" maxOccurs="1"/> + <xsd:element name="externalReferences" type="CT_ExternalReferences" minOccurs="0" + maxOccurs="1"/> + <xsd:element name="definedNames" type="CT_DefinedNames" minOccurs="0" maxOccurs="1"/> + <xsd:element name="calcPr" type="CT_CalcPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="oleSize" type="CT_OleSize" minOccurs="0" maxOccurs="1"/> + <xsd:element name="customWorkbookViews" type="CT_CustomWorkbookViews" minOccurs="0" + maxOccurs="1"/> + <xsd:element name="pivotCaches" type="CT_PivotCaches" minOccurs="0" maxOccurs="1"/> + <xsd:element name="smartTagPr" type="CT_SmartTagPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="smartTagTypes" type="CT_SmartTagTypes" minOccurs="0" maxOccurs="1"/> + <xsd:element name="webPublishing" type="CT_WebPublishing" minOccurs="0" maxOccurs="1"/> + <xsd:element name="fileRecoveryPr" type="CT_FileRecoveryPr" minOccurs="0" + maxOccurs="unbounded"/> + <xsd:element name="webPublishObjects" type="CT_WebPublishObjects" minOccurs="0" maxOccurs="1"/> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="conformance" type="s:ST_ConformanceClass"/> + </xsd:complexType> + <xsd:complexType name="CT_FileVersion"> + <xsd:attribute name="appName" type="xsd:string" use="optional"/> + <xsd:attribute name="lastEdited" type="xsd:string" use="optional"/> + <xsd:attribute name="lowestEdited" type="xsd:string" use="optional"/> + <xsd:attribute name="rupBuild" type="xsd:string" use="optional"/> + <xsd:attribute name="codeName" type="s:ST_Guid" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_BookViews"> + <xsd:sequence> + <xsd:element name="workbookView" type="CT_BookView" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_BookView"> + <xsd:sequence> + <xsd:element name="extLst" type="CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="visibility" type="ST_Visibility" use="optional" default="visible"/> + <xsd:attribute name="minimized" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="showHorizontalScroll" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="showVerticalScroll" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="showSheetTabs" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="xWindow" type="xsd:int" use="optional"/> + <xsd:attribute name="yWindow" type="xsd:int" use="optional"/> + <xsd:attribute name="windowWidth" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="windowHeight" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="tabRatio" type="xsd:unsignedInt" use="optional" default="600"/> + <xsd:attribute name="firstSheet" type="xsd:unsignedInt" use="optional" default="0"/> + <xsd:attribute name="activeTab" type="xsd:unsignedInt" use="optional" default="0"/> + <xsd:attribute name="autoFilterDateGrouping" type="xsd:boolean" use="optional" default="true"/> + </xsd:complexType> + <xsd:simpleType name="ST_Visibility"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="visible"/> + <xsd:enumeration value="hidden"/> + <xsd:enumeration value="veryHidden"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_CustomWorkbookViews"> + <xsd:sequence> + <xsd:element name="customWorkbookView" minOccurs="1" maxOccurs="unbounded" + type="CT_CustomWorkbookView"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_CustomWorkbookView"> + <xsd:sequence> + <xsd:element name="extLst" minOccurs="0" type="CT_ExtensionList"/> + </xsd:sequence> + <xsd:attribute name="name" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="guid" type="s:ST_Guid" use="required"/> + <xsd:attribute name="autoUpdate" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="mergeInterval" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="changesSavedWin" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="onlySync" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="personalView" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="includePrintSettings" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="includeHiddenRowCol" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="maximized" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="minimized" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="showHorizontalScroll" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="showVerticalScroll" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="showSheetTabs" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="xWindow" type="xsd:int" use="optional" default="0"/> + <xsd:attribute name="yWindow" type="xsd:int" use="optional" default="0"/> + <xsd:attribute name="windowWidth" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="windowHeight" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="tabRatio" type="xsd:unsignedInt" use="optional" default="600"/> + <xsd:attribute name="activeSheetId" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="showFormulaBar" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="showStatusbar" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="showComments" type="ST_Comments" use="optional" default="commIndicator"/> + <xsd:attribute name="showObjects" type="ST_Objects" use="optional" default="all"/> + </xsd:complexType> + <xsd:simpleType name="ST_Comments"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="commNone"/> + <xsd:enumeration value="commIndicator"/> + <xsd:enumeration value="commIndAndComment"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_Objects"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="all"/> + <xsd:enumeration value="placeholders"/> + <xsd:enumeration value="none"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Sheets"> + <xsd:sequence> + <xsd:element name="sheet" type="CT_Sheet" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Sheet"> + <xsd:attribute name="name" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="sheetId" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="state" type="ST_SheetState" use="optional" default="visible"/> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_SheetState"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="visible"/> + <xsd:enumeration value="hidden"/> + <xsd:enumeration value="veryHidden"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_WorkbookPr"> + <xsd:attribute name="date1904" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="showObjects" type="ST_Objects" use="optional" default="all"/> + <xsd:attribute name="showBorderUnselectedTables" type="xsd:boolean" use="optional" + default="true"/> + <xsd:attribute name="filterPrivacy" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="promptedSolutions" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="showInkAnnotation" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="backupFile" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="saveExternalLinkValues" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="updateLinks" type="ST_UpdateLinks" use="optional" default="userSet"/> + <xsd:attribute name="codeName" type="xsd:string" use="optional"/> + <xsd:attribute name="hidePivotFieldList" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="showPivotChartFilter" type="xsd:boolean" default="false"/> + <xsd:attribute name="allowRefreshQuery" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="publishItems" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="checkCompatibility" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="autoCompressPictures" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="refreshAllConnections" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="defaultThemeVersion" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_UpdateLinks"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="userSet"/> + <xsd:enumeration value="never"/> + <xsd:enumeration value="always"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_SmartTagPr"> + <xsd:attribute name="embed" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="show" type="ST_SmartTagShow" use="optional" default="all"/> + </xsd:complexType> + <xsd:simpleType name="ST_SmartTagShow"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="all"/> + <xsd:enumeration value="none"/> + <xsd:enumeration value="noIndicator"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_SmartTagTypes"> + <xsd:sequence> + <xsd:element name="smartTagType" type="CT_SmartTagType" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SmartTagType"> + <xsd:attribute name="namespaceUri" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="name" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="url" type="s:ST_Xstring" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_FileRecoveryPr"> + <xsd:attribute name="autoRecover" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="crashSave" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="dataExtractLoad" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="repairLoad" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> + <xsd:complexType name="CT_CalcPr"> + <xsd:attribute name="calcId" type="xsd:unsignedInt"/> + <xsd:attribute name="calcMode" type="ST_CalcMode" use="optional" default="auto"/> + <xsd:attribute name="fullCalcOnLoad" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="refMode" type="ST_RefMode" use="optional" default="A1"/> + <xsd:attribute name="iterate" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="iterateCount" type="xsd:unsignedInt" use="optional" default="100"/> + <xsd:attribute name="iterateDelta" type="xsd:double" use="optional" default="0.001"/> + <xsd:attribute name="fullPrecision" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="calcCompleted" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="calcOnSave" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="concurrentCalc" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="concurrentManualCount" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="forceFullCalc" type="xsd:boolean" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_CalcMode"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="manual"/> + <xsd:enumeration value="auto"/> + <xsd:enumeration value="autoNoTable"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_RefMode"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="A1"/> + <xsd:enumeration value="R1C1"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_DefinedNames"> + <xsd:sequence> + <xsd:element name="definedName" type="CT_DefinedName" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_DefinedName"> + <xsd:simpleContent> + <xsd:extension base="ST_Formula"> + <xsd:attribute name="name" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="comment" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="customMenu" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="description" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="help" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="statusBar" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="localSheetId" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="hidden" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="function" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="vbProcedure" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="xlm" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="functionGroupId" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="shortcutKey" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="publishToServer" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="workbookParameter" type="xsd:boolean" use="optional" default="false"/> + </xsd:extension> + </xsd:simpleContent> + </xsd:complexType> + <xsd:complexType name="CT_ExternalReferences"> + <xsd:sequence> + <xsd:element name="externalReference" type="CT_ExternalReference" minOccurs="1" + maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_ExternalReference"> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_SheetBackgroundPicture"> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_PivotCaches"> + <xsd:sequence> + <xsd:element name="pivotCache" type="CT_PivotCache" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_PivotCache"> + <xsd:attribute name="cacheId" type="xsd:unsignedInt" use="required"/> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_FileSharing"> + <xsd:attribute name="readOnlyRecommended" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="userName" type="s:ST_Xstring"/> + <xsd:attribute name="reservationPassword" type="ST_UnsignedShortHex"/> + <xsd:attribute name="algorithmName" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="hashValue" type="xsd:base64Binary" use="optional"/> + <xsd:attribute name="saltValue" type="xsd:base64Binary" use="optional"/> + <xsd:attribute name="spinCount" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_OleSize"> + <xsd:attribute name="ref" type="ST_Ref" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_WorkbookProtection"> + <xsd:attribute name="workbookPassword" type="ST_UnsignedShortHex" use="optional"/> + <xsd:attribute name="workbookPasswordCharacterSet" type="xsd:string" use="optional"/> + <xsd:attribute name="revisionsPassword" type="ST_UnsignedShortHex" use="optional"/> + <xsd:attribute name="revisionsPasswordCharacterSet" type="xsd:string" use="optional"/> + <xsd:attribute name="lockStructure" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="lockWindows" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="lockRevision" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="revisionsAlgorithmName" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="revisionsHashValue" type="xsd:base64Binary" use="optional"/> + <xsd:attribute name="revisionsSaltValue" type="xsd:base64Binary" use="optional"/> + <xsd:attribute name="revisionsSpinCount" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="workbookAlgorithmName" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="workbookHashValue" type="xsd:base64Binary" use="optional"/> + <xsd:attribute name="workbookSaltValue" type="xsd:base64Binary" use="optional"/> + <xsd:attribute name="workbookSpinCount" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_WebPublishing"> + <xsd:attribute name="css" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="thicket" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="longFileNames" type="xsd:boolean" use="optional" default="true"/> + <xsd:attribute name="vml" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="allowPng" type="xsd:boolean" use="optional" default="false"/> + <xsd:attribute name="targetScreenSize" type="ST_TargetScreenSize" use="optional" + default="800x600"/> + <xsd:attribute name="dpi" type="xsd:unsignedInt" use="optional" default="96"/> + <xsd:attribute name="codePage" type="xsd:unsignedInt" use="optional"/> + <xsd:attribute name="characterSet" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_TargetScreenSize"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="544x376"/> + <xsd:enumeration value="640x480"/> + <xsd:enumeration value="720x512"/> + <xsd:enumeration value="800x600"/> + <xsd:enumeration value="1024x768"/> + <xsd:enumeration value="1152x882"/> + <xsd:enumeration value="1152x900"/> + <xsd:enumeration value="1280x1024"/> + <xsd:enumeration value="1600x1200"/> + <xsd:enumeration value="1800x1440"/> + <xsd:enumeration value="1920x1200"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_FunctionGroups"> + <xsd:sequence maxOccurs="unbounded"> + <xsd:element name="functionGroup" type="CT_FunctionGroup" minOccurs="0"/> + </xsd:sequence> + <xsd:attribute name="builtInGroupCount" type="xsd:unsignedInt" default="16" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_FunctionGroup"> + <xsd:attribute name="name" type="s:ST_Xstring"/> + </xsd:complexType> + <xsd:complexType name="CT_WebPublishObjects"> + <xsd:sequence> + <xsd:element name="webPublishObject" type="CT_WebPublishObject" minOccurs="1" + maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="count" type="xsd:unsignedInt" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_WebPublishObject"> + <xsd:attribute name="id" type="xsd:unsignedInt" use="required"/> + <xsd:attribute name="divId" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="sourceObject" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="destinationFile" type="s:ST_Xstring" use="required"/> + <xsd:attribute name="title" type="s:ST_Xstring" use="optional"/> + <xsd:attribute name="autoRepublish" type="xsd:boolean" use="optional" default="false"/> + </xsd:complexType> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/vml-main.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/vml-main.xsd new file mode 100644 index 00000000..8821dd18 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/vml-main.xsd @@ -0,0 +1,570 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="urn:schemas-microsoft-com:vml" + xmlns:pvml="urn:schemas-microsoft-com:office:powerpoint" + xmlns:o="urn:schemas-microsoft-com:office:office" + xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" + xmlns:w10="urn:schemas-microsoft-com:office:word" + xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" + xmlns:x="urn:schemas-microsoft-com:office:excel" + xmlns:s="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + targetNamespace="urn:schemas-microsoft-com:vml" elementFormDefault="qualified" + attributeFormDefault="unqualified"> + <xsd:import namespace="urn:schemas-microsoft-com:office:office" + schemaLocation="vml-officeDrawing.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/wordprocessingml/2006/main" + schemaLocation="wml.xsd"/> + <xsd:import namespace="urn:schemas-microsoft-com:office:word" + schemaLocation="vml-wordprocessingDrawing.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/relationships" + schemaLocation="shared-relationshipReference.xsd"/> + <xsd:import namespace="urn:schemas-microsoft-com:office:excel" + schemaLocation="vml-spreadsheetDrawing.xsd"/> + <xsd:import namespace="urn:schemas-microsoft-com:office:powerpoint" + schemaLocation="vml-presentationDrawing.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + schemaLocation="shared-commonSimpleTypes.xsd"/> + <xsd:attributeGroup name="AG_Id"> + <xsd:attribute name="id" type="xsd:string" use="optional"/> + </xsd:attributeGroup> + <xsd:attributeGroup name="AG_Style"> + <xsd:attribute name="style" type="xsd:string" use="optional"/> + </xsd:attributeGroup> + <xsd:attributeGroup name="AG_Type"> + <xsd:attribute name="type" type="xsd:string" use="optional"/> + </xsd:attributeGroup> + <xsd:attributeGroup name="AG_Adj"> + <xsd:attribute name="adj" type="xsd:string" use="optional"/> + </xsd:attributeGroup> + <xsd:attributeGroup name="AG_Path"> + <xsd:attribute name="path" type="xsd:string" use="optional"/> + </xsd:attributeGroup> + <xsd:attributeGroup name="AG_Fill"> + <xsd:attribute name="filled" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="fillcolor" type="s:ST_ColorType" use="optional"/> + </xsd:attributeGroup> + <xsd:attributeGroup name="AG_Chromakey"> + <xsd:attribute name="chromakey" type="s:ST_ColorType" use="optional"/> + </xsd:attributeGroup> + <xsd:attributeGroup name="AG_Ext"> + <xsd:attribute name="ext" form="qualified" type="ST_Ext"/> + </xsd:attributeGroup> + <xsd:attributeGroup name="AG_CoreAttributes"> + <xsd:attributeGroup ref="AG_Id"/> + <xsd:attributeGroup ref="AG_Style"/> + <xsd:attribute name="href" type="xsd:string" use="optional"/> + <xsd:attribute name="target" type="xsd:string" use="optional"/> + <xsd:attribute name="class" type="xsd:string" use="optional"/> + <xsd:attribute name="title" type="xsd:string" use="optional"/> + <xsd:attribute name="alt" type="xsd:string" use="optional"/> + <xsd:attribute name="coordsize" type="xsd:string" use="optional"/> + <xsd:attribute name="coordorigin" type="xsd:string" use="optional"/> + <xsd:attribute name="wrapcoords" type="xsd:string" use="optional"/> + <xsd:attribute name="print" type="s:ST_TrueFalse" use="optional"/> + </xsd:attributeGroup> + <xsd:attributeGroup name="AG_ShapeAttributes"> + <xsd:attributeGroup ref="AG_Chromakey"/> + <xsd:attributeGroup ref="AG_Fill"/> + <xsd:attribute name="opacity" type="xsd:string" use="optional"/> + <xsd:attribute name="stroked" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="strokecolor" type="s:ST_ColorType" use="optional"/> + <xsd:attribute name="strokeweight" type="xsd:string" use="optional"/> + <xsd:attribute name="insetpen" type="s:ST_TrueFalse" use="optional"/> + </xsd:attributeGroup> + <xsd:attributeGroup name="AG_OfficeCoreAttributes"> + <xsd:attribute ref="o:spid"/> + <xsd:attribute ref="o:oned"/> + <xsd:attribute ref="o:regroupid"/> + <xsd:attribute ref="o:doubleclicknotify"/> + <xsd:attribute ref="o:button"/> + <xsd:attribute ref="o:userhidden"/> + <xsd:attribute ref="o:bullet"/> + <xsd:attribute ref="o:hr"/> + <xsd:attribute ref="o:hrstd"/> + <xsd:attribute ref="o:hrnoshade"/> + <xsd:attribute ref="o:hrpct"/> + <xsd:attribute ref="o:hralign"/> + <xsd:attribute ref="o:allowincell"/> + <xsd:attribute ref="o:allowoverlap"/> + <xsd:attribute ref="o:userdrawn"/> + <xsd:attribute ref="o:bordertopcolor"/> + <xsd:attribute ref="o:borderleftcolor"/> + <xsd:attribute ref="o:borderbottomcolor"/> + <xsd:attribute ref="o:borderrightcolor"/> + <xsd:attribute ref="o:dgmlayout"/> + <xsd:attribute ref="o:dgmnodekind"/> + <xsd:attribute ref="o:dgmlayoutmru"/> + <xsd:attribute ref="o:insetmode"/> + </xsd:attributeGroup> + <xsd:attributeGroup name="AG_OfficeShapeAttributes"> + <xsd:attribute ref="o:spt"/> + <xsd:attribute ref="o:connectortype"/> + <xsd:attribute ref="o:bwmode"/> + <xsd:attribute ref="o:bwpure"/> + <xsd:attribute ref="o:bwnormal"/> + <xsd:attribute ref="o:forcedash"/> + <xsd:attribute ref="o:oleicon"/> + <xsd:attribute ref="o:ole"/> + <xsd:attribute ref="o:preferrelative"/> + <xsd:attribute ref="o:cliptowrap"/> + <xsd:attribute ref="o:clip"/> + </xsd:attributeGroup> + <xsd:attributeGroup name="AG_AllCoreAttributes"> + <xsd:attributeGroup ref="AG_CoreAttributes"/> + <xsd:attributeGroup ref="AG_OfficeCoreAttributes"/> + </xsd:attributeGroup> + <xsd:attributeGroup name="AG_AllShapeAttributes"> + <xsd:attributeGroup ref="AG_ShapeAttributes"/> + <xsd:attributeGroup ref="AG_OfficeShapeAttributes"/> + </xsd:attributeGroup> + <xsd:attributeGroup name="AG_ImageAttributes"> + <xsd:attribute name="src" type="xsd:string" use="optional"/> + <xsd:attribute name="cropleft" type="xsd:string" use="optional"/> + <xsd:attribute name="croptop" type="xsd:string" use="optional"/> + <xsd:attribute name="cropright" type="xsd:string" use="optional"/> + <xsd:attribute name="cropbottom" type="xsd:string" use="optional"/> + <xsd:attribute name="gain" type="xsd:string" use="optional"/> + <xsd:attribute name="blacklevel" type="xsd:string" use="optional"/> + <xsd:attribute name="gamma" type="xsd:string" use="optional"/> + <xsd:attribute name="grayscale" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="bilevel" type="s:ST_TrueFalse" use="optional"/> + </xsd:attributeGroup> + <xsd:attributeGroup name="AG_StrokeAttributes"> + <xsd:attribute name="on" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="weight" type="xsd:string" use="optional"/> + <xsd:attribute name="color" type="s:ST_ColorType" use="optional"/> + <xsd:attribute name="opacity" type="xsd:string" use="optional"/> + <xsd:attribute name="linestyle" type="ST_StrokeLineStyle" use="optional"/> + <xsd:attribute name="miterlimit" type="xsd:decimal" use="optional"/> + <xsd:attribute name="joinstyle" type="ST_StrokeJoinStyle" use="optional"/> + <xsd:attribute name="endcap" type="ST_StrokeEndCap" use="optional"/> + <xsd:attribute name="dashstyle" type="xsd:string" use="optional"/> + <xsd:attribute name="filltype" type="ST_FillType" use="optional"/> + <xsd:attribute name="src" type="xsd:string" use="optional"/> + <xsd:attribute name="imageaspect" type="ST_ImageAspect" use="optional"/> + <xsd:attribute name="imagesize" type="xsd:string" use="optional"/> + <xsd:attribute name="imagealignshape" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="color2" type="s:ST_ColorType" use="optional"/> + <xsd:attribute name="startarrow" type="ST_StrokeArrowType" use="optional"/> + <xsd:attribute name="startarrowwidth" type="ST_StrokeArrowWidth" use="optional"/> + <xsd:attribute name="startarrowlength" type="ST_StrokeArrowLength" use="optional"/> + <xsd:attribute name="endarrow" type="ST_StrokeArrowType" use="optional"/> + <xsd:attribute name="endarrowwidth" type="ST_StrokeArrowWidth" use="optional"/> + <xsd:attribute name="endarrowlength" type="ST_StrokeArrowLength" use="optional"/> + <xsd:attribute ref="o:href"/> + <xsd:attribute ref="o:althref"/> + <xsd:attribute ref="o:title"/> + <xsd:attribute ref="o:forcedash"/> + <xsd:attribute ref="r:id" use="optional"/> + <xsd:attribute name="insetpen" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute ref="o:relid"/> + </xsd:attributeGroup> + <xsd:group name="EG_ShapeElements"> + <xsd:choice> + <xsd:element ref="path"/> + <xsd:element ref="formulas"/> + <xsd:element ref="handles"/> + <xsd:element ref="fill"/> + <xsd:element ref="stroke"/> + <xsd:element ref="shadow"/> + <xsd:element ref="textbox"/> + <xsd:element ref="textpath"/> + <xsd:element ref="imagedata"/> + <xsd:element ref="o:skew"/> + <xsd:element ref="o:extrusion"/> + <xsd:element ref="o:callout"/> + <xsd:element ref="o:lock"/> + <xsd:element ref="o:clippath"/> + <xsd:element ref="o:signatureline"/> + <xsd:element ref="w10:wrap"/> + <xsd:element ref="w10:anchorlock"/> + <xsd:element ref="w10:bordertop"/> + <xsd:element ref="w10:borderbottom"/> + <xsd:element ref="w10:borderleft"/> + <xsd:element ref="w10:borderright"/> + <xsd:element ref="x:ClientData" minOccurs="0"/> + <xsd:element ref="pvml:textdata" minOccurs="0"/> + </xsd:choice> + </xsd:group> + <xsd:element name="shape" type="CT_Shape"/> + <xsd:element name="shapetype" type="CT_Shapetype"/> + <xsd:element name="group" type="CT_Group"/> + <xsd:element name="background" type="CT_Background"/> + <xsd:complexType name="CT_Shape"> + <xsd:choice maxOccurs="unbounded"> + <xsd:group ref="EG_ShapeElements"/> + <xsd:element ref="o:ink"/> + <xsd:element ref="pvml:iscomment"/> + <xsd:element ref="o:equationxml"/> + </xsd:choice> + <xsd:attributeGroup ref="AG_AllCoreAttributes"/> + <xsd:attributeGroup ref="AG_AllShapeAttributes"/> + <xsd:attributeGroup ref="AG_Type"/> + <xsd:attributeGroup ref="AG_Adj"/> + <xsd:attributeGroup ref="AG_Path"/> + <xsd:attribute ref="o:gfxdata"/> + <xsd:attribute name="equationxml" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Shapetype"> + <xsd:sequence> + <xsd:group ref="EG_ShapeElements" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element ref="o:complex" minOccurs="0"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_AllCoreAttributes"/> + <xsd:attributeGroup ref="AG_AllShapeAttributes"/> + <xsd:attributeGroup ref="AG_Adj"/> + <xsd:attributeGroup ref="AG_Path"/> + <xsd:attribute ref="o:master"/> + </xsd:complexType> + <xsd:complexType name="CT_Group"> + <xsd:choice maxOccurs="unbounded"> + <xsd:group ref="EG_ShapeElements"/> + <xsd:element ref="group"/> + <xsd:element ref="shape"/> + <xsd:element ref="shapetype"/> + <xsd:element ref="arc"/> + <xsd:element ref="curve"/> + <xsd:element ref="image"/> + <xsd:element ref="line"/> + <xsd:element ref="oval"/> + <xsd:element ref="polyline"/> + <xsd:element ref="rect"/> + <xsd:element ref="roundrect"/> + <xsd:element ref="o:diagram"/> + </xsd:choice> + <xsd:attributeGroup ref="AG_AllCoreAttributes"/> + <xsd:attributeGroup ref="AG_Fill"/> + <xsd:attribute name="editas" type="ST_EditAs" use="optional"/> + <xsd:attribute ref="o:tableproperties"/> + <xsd:attribute ref="o:tablelimits"/> + </xsd:complexType> + <xsd:complexType name="CT_Background"> + <xsd:sequence> + <xsd:element ref="fill" minOccurs="0"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_Id"/> + <xsd:attributeGroup ref="AG_Fill"/> + <xsd:attribute ref="o:bwmode"/> + <xsd:attribute ref="o:bwpure"/> + <xsd:attribute ref="o:bwnormal"/> + <xsd:attribute ref="o:targetscreensize"/> + </xsd:complexType> + <xsd:element name="fill" type="CT_Fill"/> + <xsd:element name="formulas" type="CT_Formulas"/> + <xsd:element name="handles" type="CT_Handles"/> + <xsd:element name="imagedata" type="CT_ImageData"/> + <xsd:element name="path" type="CT_Path"/> + <xsd:element name="textbox" type="CT_Textbox"/> + <xsd:element name="shadow" type="CT_Shadow"/> + <xsd:element name="stroke" type="CT_Stroke"/> + <xsd:element name="textpath" type="CT_TextPath"/> + <xsd:complexType name="CT_Fill"> + <xsd:sequence> + <xsd:element ref="o:fill" minOccurs="0"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_Id"/> + <xsd:attribute name="type" type="ST_FillType" use="optional"/> + <xsd:attribute name="on" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="color" type="s:ST_ColorType" use="optional"/> + <xsd:attribute name="opacity" type="xsd:string" use="optional"/> + <xsd:attribute name="color2" type="s:ST_ColorType" use="optional"/> + <xsd:attribute name="src" type="xsd:string" use="optional"/> + <xsd:attribute ref="o:href"/> + <xsd:attribute ref="o:althref"/> + <xsd:attribute name="size" type="xsd:string" use="optional"/> + <xsd:attribute name="origin" type="xsd:string" use="optional"/> + <xsd:attribute name="position" type="xsd:string" use="optional"/> + <xsd:attribute name="aspect" type="ST_ImageAspect" use="optional"/> + <xsd:attribute name="colors" type="xsd:string" use="optional"/> + <xsd:attribute name="angle" type="xsd:decimal" use="optional"/> + <xsd:attribute name="alignshape" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="focus" type="xsd:string" use="optional"/> + <xsd:attribute name="focussize" type="xsd:string" use="optional"/> + <xsd:attribute name="focusposition" type="xsd:string" use="optional"/> + <xsd:attribute name="method" type="ST_FillMethod" use="optional"/> + <xsd:attribute ref="o:detectmouseclick"/> + <xsd:attribute ref="o:title"/> + <xsd:attribute ref="o:opacity2"/> + <xsd:attribute name="recolor" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="rotate" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute ref="r:id" use="optional"/> + <xsd:attribute ref="o:relid" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Formulas"> + <xsd:sequence> + <xsd:element name="f" type="CT_F" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_F"> + <xsd:attribute name="eqn" type="xsd:string"/> + </xsd:complexType> + <xsd:complexType name="CT_Handles"> + <xsd:sequence> + <xsd:element name="h" type="CT_H" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_H"> + <xsd:attribute name="position" type="xsd:string"/> + <xsd:attribute name="polar" type="xsd:string"/> + <xsd:attribute name="map" type="xsd:string"/> + <xsd:attribute name="invx" type="s:ST_TrueFalse"/> + <xsd:attribute name="invy" type="s:ST_TrueFalse"/> + <xsd:attribute name="switch" type="s:ST_TrueFalseBlank"/> + <xsd:attribute name="xrange" type="xsd:string"/> + <xsd:attribute name="yrange" type="xsd:string"/> + <xsd:attribute name="radiusrange" type="xsd:string"/> + </xsd:complexType> + <xsd:complexType name="CT_ImageData"> + <xsd:attributeGroup ref="AG_Id"/> + <xsd:attributeGroup ref="AG_ImageAttributes"/> + <xsd:attributeGroup ref="AG_Chromakey"/> + <xsd:attribute name="embosscolor" type="s:ST_ColorType" use="optional"/> + <xsd:attribute name="recolortarget" type="s:ST_ColorType"/> + <xsd:attribute ref="o:href"/> + <xsd:attribute ref="o:althref"/> + <xsd:attribute ref="o:title"/> + <xsd:attribute ref="o:oleid"/> + <xsd:attribute ref="o:detectmouseclick"/> + <xsd:attribute ref="o:movie"/> + <xsd:attribute ref="o:relid"/> + <xsd:attribute ref="r:id"/> + <xsd:attribute ref="r:pict"/> + <xsd:attribute ref="r:href"/> + </xsd:complexType> + <xsd:complexType name="CT_Path"> + <xsd:attributeGroup ref="AG_Id"/> + <xsd:attribute name="v" type="xsd:string" use="optional"/> + <xsd:attribute name="limo" type="xsd:string" use="optional"/> + <xsd:attribute name="textboxrect" type="xsd:string" use="optional"/> + <xsd:attribute name="fillok" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="strokeok" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="shadowok" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="arrowok" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="gradientshapeok" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="textpathok" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="insetpenok" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute ref="o:connecttype"/> + <xsd:attribute ref="o:connectlocs"/> + <xsd:attribute ref="o:connectangles"/> + <xsd:attribute ref="o:extrusionok"/> + </xsd:complexType> + <xsd:complexType name="CT_Shadow"> + <xsd:attributeGroup ref="AG_Id"/> + <xsd:attribute name="on" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="type" type="ST_ShadowType" use="optional"/> + <xsd:attribute name="obscured" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="color" type="s:ST_ColorType" use="optional"/> + <xsd:attribute name="opacity" type="xsd:string" use="optional"/> + <xsd:attribute name="offset" type="xsd:string" use="optional"/> + <xsd:attribute name="color2" type="s:ST_ColorType" use="optional"/> + <xsd:attribute name="offset2" type="xsd:string" use="optional"/> + <xsd:attribute name="origin" type="xsd:string" use="optional"/> + <xsd:attribute name="matrix" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Stroke"> + <xsd:sequence> + <xsd:element ref="o:left" minOccurs="0"/> + <xsd:element ref="o:top" minOccurs="0"/> + <xsd:element ref="o:right" minOccurs="0"/> + <xsd:element ref="o:bottom" minOccurs="0"/> + <xsd:element ref="o:column" minOccurs="0"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_Id"/> + <xsd:attributeGroup ref="AG_StrokeAttributes"/> + </xsd:complexType> + <xsd:complexType name="CT_Textbox"> + <xsd:choice> + <xsd:element ref="w:txbxContent" minOccurs="0"/> + <xsd:any namespace="##local" processContents="skip"/> + </xsd:choice> + <xsd:attributeGroup ref="AG_Id"/> + <xsd:attributeGroup ref="AG_Style"/> + <xsd:attribute name="inset" type="xsd:string" use="optional"/> + <xsd:attribute ref="o:singleclick"/> + <xsd:attribute ref="o:insetmode"/> + </xsd:complexType> + <xsd:complexType name="CT_TextPath"> + <xsd:attributeGroup ref="AG_Id"/> + <xsd:attributeGroup ref="AG_Style"/> + <xsd:attribute name="on" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="fitshape" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="fitpath" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="trim" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="xscale" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="string" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:element name="arc" type="CT_Arc"/> + <xsd:element name="curve" type="CT_Curve"/> + <xsd:element name="image" type="CT_Image"/> + <xsd:element name="line" type="CT_Line"/> + <xsd:element name="oval" type="CT_Oval"/> + <xsd:element name="polyline" type="CT_PolyLine"/> + <xsd:element name="rect" type="CT_Rect"/> + <xsd:element name="roundrect" type="CT_RoundRect"/> + <xsd:complexType name="CT_Arc"> + <xsd:sequence> + <xsd:group ref="EG_ShapeElements" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_AllCoreAttributes"/> + <xsd:attributeGroup ref="AG_AllShapeAttributes"/> + <xsd:attribute name="startAngle" type="xsd:decimal" use="optional"/> + <xsd:attribute name="endAngle" type="xsd:decimal" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Curve"> + <xsd:sequence> + <xsd:group ref="EG_ShapeElements" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_AllCoreAttributes"/> + <xsd:attributeGroup ref="AG_AllShapeAttributes"/> + <xsd:attribute name="from" type="xsd:string" use="optional"/> + <xsd:attribute name="control1" type="xsd:string" use="optional"/> + <xsd:attribute name="control2" type="xsd:string" use="optional"/> + <xsd:attribute name="to" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Image"> + <xsd:sequence> + <xsd:group ref="EG_ShapeElements" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_AllCoreAttributes"/> + <xsd:attributeGroup ref="AG_AllShapeAttributes"/> + <xsd:attributeGroup ref="AG_ImageAttributes"/> + </xsd:complexType> + <xsd:complexType name="CT_Line"> + <xsd:sequence> + <xsd:group ref="EG_ShapeElements" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_AllCoreAttributes"/> + <xsd:attributeGroup ref="AG_AllShapeAttributes"/> + <xsd:attribute name="from" type="xsd:string" use="optional"/> + <xsd:attribute name="to" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Oval"> + <xsd:choice maxOccurs="unbounded"> + <xsd:group ref="EG_ShapeElements" minOccurs="0" maxOccurs="unbounded"/> + </xsd:choice> + <xsd:attributeGroup ref="AG_AllCoreAttributes"/> + <xsd:attributeGroup ref="AG_AllShapeAttributes"/> + </xsd:complexType> + <xsd:complexType name="CT_PolyLine"> + <xsd:choice minOccurs="0" maxOccurs="unbounded"> + <xsd:group ref="EG_ShapeElements"/> + <xsd:element ref="o:ink"/> + </xsd:choice> + <xsd:attributeGroup ref="AG_AllCoreAttributes"/> + <xsd:attributeGroup ref="AG_AllShapeAttributes"/> + <xsd:attribute name="points" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Rect"> + <xsd:choice maxOccurs="unbounded"> + <xsd:group ref="EG_ShapeElements" minOccurs="0" maxOccurs="unbounded"/> + </xsd:choice> + <xsd:attributeGroup ref="AG_AllCoreAttributes"/> + <xsd:attributeGroup ref="AG_AllShapeAttributes"/> + </xsd:complexType> + <xsd:complexType name="CT_RoundRect"> + <xsd:choice maxOccurs="unbounded"> + <xsd:group ref="EG_ShapeElements" minOccurs="0" maxOccurs="unbounded"/> + </xsd:choice> + <xsd:attributeGroup ref="AG_AllCoreAttributes"/> + <xsd:attributeGroup ref="AG_AllShapeAttributes"/> + <xsd:attribute name="arcsize" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_Ext"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="view"/> + <xsd:enumeration value="edit"/> + <xsd:enumeration value="backwardCompatible"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_FillType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="solid"/> + <xsd:enumeration value="gradient"/> + <xsd:enumeration value="gradientRadial"/> + <xsd:enumeration value="tile"/> + <xsd:enumeration value="pattern"/> + <xsd:enumeration value="frame"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_FillMethod"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="linear"/> + <xsd:enumeration value="sigma"/> + <xsd:enumeration value="any"/> + <xsd:enumeration value="linear sigma"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ShadowType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="single"/> + <xsd:enumeration value="double"/> + <xsd:enumeration value="emboss"/> + <xsd:enumeration value="perspective"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_StrokeLineStyle"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="single"/> + <xsd:enumeration value="thinThin"/> + <xsd:enumeration value="thinThick"/> + <xsd:enumeration value="thickThin"/> + <xsd:enumeration value="thickBetweenThin"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_StrokeJoinStyle"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="round"/> + <xsd:enumeration value="bevel"/> + <xsd:enumeration value="miter"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_StrokeEndCap"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="flat"/> + <xsd:enumeration value="square"/> + <xsd:enumeration value="round"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_StrokeArrowLength"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="short"/> + <xsd:enumeration value="medium"/> + <xsd:enumeration value="long"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_StrokeArrowWidth"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="narrow"/> + <xsd:enumeration value="medium"/> + <xsd:enumeration value="wide"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_StrokeArrowType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="block"/> + <xsd:enumeration value="classic"/> + <xsd:enumeration value="oval"/> + <xsd:enumeration value="diamond"/> + <xsd:enumeration value="open"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ImageAspect"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="ignore"/> + <xsd:enumeration value="atMost"/> + <xsd:enumeration value="atLeast"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_EditAs"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="canvas"/> + <xsd:enumeration value="orgchart"/> + <xsd:enumeration value="radial"/> + <xsd:enumeration value="cycle"/> + <xsd:enumeration value="stacked"/> + <xsd:enumeration value="venn"/> + <xsd:enumeration value="bullseye"/> + </xsd:restriction> + </xsd:simpleType> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/vml-officeDrawing.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/vml-officeDrawing.xsd new file mode 100644 index 00000000..ca2575c7 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/vml-officeDrawing.xsd @@ -0,0 +1,509 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" + xmlns="urn:schemas-microsoft-com:office:office" xmlns:v="urn:schemas-microsoft-com:vml" + xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" + xmlns:s="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + targetNamespace="urn:schemas-microsoft-com:office:office" elementFormDefault="qualified" + attributeFormDefault="unqualified"> + <xsd:import namespace="urn:schemas-microsoft-com:vml" schemaLocation="vml-main.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/relationships" + schemaLocation="shared-relationshipReference.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + schemaLocation="shared-commonSimpleTypes.xsd"/> + <xsd:attribute name="bwmode" type="ST_BWMode"/> + <xsd:attribute name="bwpure" type="ST_BWMode"/> + <xsd:attribute name="bwnormal" type="ST_BWMode"/> + <xsd:attribute name="targetscreensize" type="ST_ScreenSize"/> + <xsd:attribute name="insetmode" type="ST_InsetMode" default="custom"/> + <xsd:attribute name="spt" type="xsd:float"/> + <xsd:attribute name="wrapcoords" type="xsd:string"/> + <xsd:attribute name="oned" type="s:ST_TrueFalse"/> + <xsd:attribute name="regroupid" type="xsd:integer"/> + <xsd:attribute name="doubleclicknotify" type="s:ST_TrueFalse"/> + <xsd:attribute name="connectortype" type="ST_ConnectorType" default="straight"/> + <xsd:attribute name="button" type="s:ST_TrueFalse"/> + <xsd:attribute name="userhidden" type="s:ST_TrueFalse"/> + <xsd:attribute name="forcedash" type="s:ST_TrueFalse"/> + <xsd:attribute name="oleicon" type="s:ST_TrueFalse"/> + <xsd:attribute name="ole" type="s:ST_TrueFalseBlank"/> + <xsd:attribute name="preferrelative" type="s:ST_TrueFalse"/> + <xsd:attribute name="cliptowrap" type="s:ST_TrueFalse"/> + <xsd:attribute name="clip" type="s:ST_TrueFalse"/> + <xsd:attribute name="bullet" type="s:ST_TrueFalse"/> + <xsd:attribute name="hr" type="s:ST_TrueFalse"/> + <xsd:attribute name="hrstd" type="s:ST_TrueFalse"/> + <xsd:attribute name="hrnoshade" type="s:ST_TrueFalse"/> + <xsd:attribute name="hrpct" type="xsd:float"/> + <xsd:attribute name="hralign" type="ST_HrAlign" default="left"/> + <xsd:attribute name="allowincell" type="s:ST_TrueFalse"/> + <xsd:attribute name="allowoverlap" type="s:ST_TrueFalse"/> + <xsd:attribute name="userdrawn" type="s:ST_TrueFalse"/> + <xsd:attribute name="bordertopcolor" type="xsd:string"/> + <xsd:attribute name="borderleftcolor" type="xsd:string"/> + <xsd:attribute name="borderbottomcolor" type="xsd:string"/> + <xsd:attribute name="borderrightcolor" type="xsd:string"/> + <xsd:attribute name="connecttype" type="ST_ConnectType"/> + <xsd:attribute name="connectlocs" type="xsd:string"/> + <xsd:attribute name="connectangles" type="xsd:string"/> + <xsd:attribute name="master" type="xsd:string"/> + <xsd:attribute name="extrusionok" type="s:ST_TrueFalse"/> + <xsd:attribute name="href" type="xsd:string"/> + <xsd:attribute name="althref" type="xsd:string"/> + <xsd:attribute name="title" type="xsd:string"/> + <xsd:attribute name="singleclick" type="s:ST_TrueFalse"/> + <xsd:attribute name="oleid" type="xsd:float"/> + <xsd:attribute name="detectmouseclick" type="s:ST_TrueFalse"/> + <xsd:attribute name="movie" type="xsd:float"/> + <xsd:attribute name="spid" type="xsd:string"/> + <xsd:attribute name="opacity2" type="xsd:string"/> + <xsd:attribute name="relid" type="r:ST_RelationshipId"/> + <xsd:attribute name="dgmlayout" type="ST_DiagramLayout"/> + <xsd:attribute name="dgmnodekind" type="xsd:integer"/> + <xsd:attribute name="dgmlayoutmru" type="ST_DiagramLayout"/> + <xsd:attribute name="gfxdata" type="xsd:base64Binary"/> + <xsd:attribute name="tableproperties" type="xsd:string"/> + <xsd:attribute name="tablelimits" type="xsd:string"/> + <xsd:element name="shapedefaults" type="CT_ShapeDefaults"/> + <xsd:element name="shapelayout" type="CT_ShapeLayout"/> + <xsd:element name="signatureline" type="CT_SignatureLine"/> + <xsd:element name="ink" type="CT_Ink"/> + <xsd:element name="diagram" type="CT_Diagram"/> + <xsd:element name="equationxml" type="CT_EquationXml"/> + <xsd:complexType name="CT_ShapeDefaults"> + <xsd:all minOccurs="0"> + <xsd:element ref="v:fill" minOccurs="0"/> + <xsd:element ref="v:stroke" minOccurs="0"/> + <xsd:element ref="v:textbox" minOccurs="0"/> + <xsd:element ref="v:shadow" minOccurs="0"/> + <xsd:element ref="skew" minOccurs="0"/> + <xsd:element ref="extrusion" minOccurs="0"/> + <xsd:element ref="callout" minOccurs="0"/> + <xsd:element ref="lock" minOccurs="0"/> + <xsd:element name="colormru" minOccurs="0" type="CT_ColorMru"/> + <xsd:element name="colormenu" minOccurs="0" type="CT_ColorMenu"/> + </xsd:all> + <xsd:attributeGroup ref="v:AG_Ext"/> + <xsd:attribute name="spidmax" type="xsd:integer" use="optional"/> + <xsd:attribute name="style" type="xsd:string" use="optional"/> + <xsd:attribute name="fill" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="fillcolor" type="s:ST_ColorType" use="optional"/> + <xsd:attribute name="stroke" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="strokecolor" type="s:ST_ColorType"/> + <xsd:attribute name="allowincell" form="qualified" type="s:ST_TrueFalse"/> + </xsd:complexType> + <xsd:complexType name="CT_Ink"> + <xsd:sequence/> + <xsd:attribute name="i" type="xsd:string"/> + <xsd:attribute name="annotation" type="s:ST_TrueFalse"/> + <xsd:attribute name="contentType" type="ST_ContentType" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_SignatureLine"> + <xsd:attributeGroup ref="v:AG_Ext"/> + <xsd:attribute name="issignatureline" type="s:ST_TrueFalse"/> + <xsd:attribute name="id" type="s:ST_Guid"/> + <xsd:attribute name="provid" type="s:ST_Guid"/> + <xsd:attribute name="signinginstructionsset" type="s:ST_TrueFalse"/> + <xsd:attribute name="allowcomments" type="s:ST_TrueFalse"/> + <xsd:attribute name="showsigndate" type="s:ST_TrueFalse"/> + <xsd:attribute name="suggestedsigner" type="xsd:string" form="qualified"/> + <xsd:attribute name="suggestedsigner2" type="xsd:string" form="qualified"/> + <xsd:attribute name="suggestedsigneremail" type="xsd:string" form="qualified"/> + <xsd:attribute name="signinginstructions" type="xsd:string"/> + <xsd:attribute name="addlxml" type="xsd:string"/> + <xsd:attribute name="sigprovurl" type="xsd:string"/> + </xsd:complexType> + <xsd:complexType name="CT_ShapeLayout"> + <xsd:all> + <xsd:element name="idmap" type="CT_IdMap" minOccurs="0"/> + <xsd:element name="regrouptable" type="CT_RegroupTable" minOccurs="0"/> + <xsd:element name="rules" type="CT_Rules" minOccurs="0"/> + </xsd:all> + <xsd:attributeGroup ref="v:AG_Ext"/> + </xsd:complexType> + <xsd:complexType name="CT_IdMap"> + <xsd:attributeGroup ref="v:AG_Ext"/> + <xsd:attribute name="data" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_RegroupTable"> + <xsd:sequence> + <xsd:element name="entry" type="CT_Entry" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attributeGroup ref="v:AG_Ext"/> + </xsd:complexType> + <xsd:complexType name="CT_Entry"> + <xsd:attribute name="new" type="xsd:int" use="optional"/> + <xsd:attribute name="old" type="xsd:int" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Rules"> + <xsd:sequence> + <xsd:element name="r" type="CT_R" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attributeGroup ref="v:AG_Ext"/> + </xsd:complexType> + <xsd:complexType name="CT_R"> + <xsd:sequence> + <xsd:element name="proxy" type="CT_Proxy" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="id" type="xsd:string" use="required"/> + <xsd:attribute name="type" type="ST_RType" use="optional"/> + <xsd:attribute name="how" type="ST_How" use="optional"/> + <xsd:attribute name="idref" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Proxy"> + <xsd:attribute name="start" type="s:ST_TrueFalseBlank" use="optional" default="false"/> + <xsd:attribute name="end" type="s:ST_TrueFalseBlank" use="optional" default="false"/> + <xsd:attribute name="idref" type="xsd:string" use="optional"/> + <xsd:attribute name="connectloc" type="xsd:int" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Diagram"> + <xsd:sequence> + <xsd:element name="relationtable" type="CT_RelationTable" minOccurs="0"/> + </xsd:sequence> + <xsd:attributeGroup ref="v:AG_Ext"/> + <xsd:attribute name="dgmstyle" type="xsd:integer" use="optional"/> + <xsd:attribute name="autoformat" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="reverse" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="autolayout" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="dgmscalex" type="xsd:integer" use="optional"/> + <xsd:attribute name="dgmscaley" type="xsd:integer" use="optional"/> + <xsd:attribute name="dgmfontsize" type="xsd:integer" use="optional"/> + <xsd:attribute name="constrainbounds" type="xsd:string" use="optional"/> + <xsd:attribute name="dgmbasetextscale" type="xsd:integer" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_EquationXml"> + <xsd:sequence> + <xsd:any namespace="##any"/> + </xsd:sequence> + <xsd:attribute name="contentType" type="ST_AlternateMathContentType" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_AlternateMathContentType"> + <xsd:restriction base="xsd:string"/> + </xsd:simpleType> + <xsd:complexType name="CT_RelationTable"> + <xsd:sequence> + <xsd:element name="rel" type="CT_Relation" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attributeGroup ref="v:AG_Ext"/> + </xsd:complexType> + <xsd:complexType name="CT_Relation"> + <xsd:attributeGroup ref="v:AG_Ext"/> + <xsd:attribute name="idsrc" type="xsd:string" use="optional"/> + <xsd:attribute name="iddest" type="xsd:string" use="optional"/> + <xsd:attribute name="idcntr" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_ColorMru"> + <xsd:attributeGroup ref="v:AG_Ext"/> + <xsd:attribute name="colors" type="xsd:string"/> + </xsd:complexType> + <xsd:complexType name="CT_ColorMenu"> + <xsd:attributeGroup ref="v:AG_Ext"/> + <xsd:attribute name="strokecolor" type="s:ST_ColorType"/> + <xsd:attribute name="fillcolor" type="s:ST_ColorType"/> + <xsd:attribute name="shadowcolor" type="s:ST_ColorType"/> + <xsd:attribute name="extrusioncolor" type="s:ST_ColorType"/> + </xsd:complexType> + <xsd:element name="skew" type="CT_Skew"/> + <xsd:element name="extrusion" type="CT_Extrusion"/> + <xsd:element name="callout" type="CT_Callout"/> + <xsd:element name="lock" type="CT_Lock"/> + <xsd:element name="OLEObject" type="CT_OLEObject"/> + <xsd:element name="complex" type="CT_Complex"/> + <xsd:element name="left" type="CT_StrokeChild"/> + <xsd:element name="top" type="CT_StrokeChild"/> + <xsd:element name="right" type="CT_StrokeChild"/> + <xsd:element name="bottom" type="CT_StrokeChild"/> + <xsd:element name="column" type="CT_StrokeChild"/> + <xsd:element name="clippath" type="CT_ClipPath"/> + <xsd:element name="fill" type="CT_Fill"/> + <xsd:complexType name="CT_Skew"> + <xsd:attributeGroup ref="v:AG_Ext"/> + <xsd:attribute name="id" type="xsd:string" use="optional"/> + <xsd:attribute name="on" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="offset" type="xsd:string" use="optional"/> + <xsd:attribute name="origin" type="xsd:string" use="optional"/> + <xsd:attribute name="matrix" type="xsd:string" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Extrusion"> + <xsd:attributeGroup ref="v:AG_Ext"/> + <xsd:attribute name="on" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="type" type="ST_ExtrusionType" default="parallel" use="optional"/> + <xsd:attribute name="render" type="ST_ExtrusionRender" default="solid" use="optional"/> + <xsd:attribute name="viewpointorigin" type="xsd:string" use="optional"/> + <xsd:attribute name="viewpoint" type="xsd:string" use="optional"/> + <xsd:attribute name="plane" type="ST_ExtrusionPlane" default="XY" use="optional"/> + <xsd:attribute name="skewangle" type="xsd:float" use="optional"/> + <xsd:attribute name="skewamt" type="xsd:string" use="optional"/> + <xsd:attribute name="foredepth" type="xsd:string" use="optional"/> + <xsd:attribute name="backdepth" type="xsd:string" use="optional"/> + <xsd:attribute name="orientation" type="xsd:string" use="optional"/> + <xsd:attribute name="orientationangle" type="xsd:float" use="optional"/> + <xsd:attribute name="lockrotationcenter" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="autorotationcenter" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="rotationcenter" type="xsd:string" use="optional"/> + <xsd:attribute name="rotationangle" type="xsd:string" use="optional"/> + <xsd:attribute name="colormode" type="ST_ColorMode" use="optional"/> + <xsd:attribute name="color" type="s:ST_ColorType" use="optional"/> + <xsd:attribute name="shininess" type="xsd:float" use="optional"/> + <xsd:attribute name="specularity" type="xsd:string" use="optional"/> + <xsd:attribute name="diffusity" type="xsd:string" use="optional"/> + <xsd:attribute name="metal" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="edge" type="xsd:string" use="optional"/> + <xsd:attribute name="facet" type="xsd:string" use="optional"/> + <xsd:attribute name="lightface" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="brightness" type="xsd:string" use="optional"/> + <xsd:attribute name="lightposition" type="xsd:string" use="optional"/> + <xsd:attribute name="lightlevel" type="xsd:string" use="optional"/> + <xsd:attribute name="lightharsh" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="lightposition2" type="xsd:string" use="optional"/> + <xsd:attribute name="lightlevel2" type="xsd:string" use="optional"/> + <xsd:attribute name="lightharsh2" type="s:ST_TrueFalse" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Callout"> + <xsd:attributeGroup ref="v:AG_Ext"/> + <xsd:attribute name="on" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="type" type="xsd:string" use="optional"/> + <xsd:attribute name="gap" type="xsd:string" use="optional"/> + <xsd:attribute name="angle" type="ST_Angle" use="optional"/> + <xsd:attribute name="dropauto" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="drop" type="ST_CalloutDrop" use="optional"/> + <xsd:attribute name="distance" type="xsd:string" use="optional"/> + <xsd:attribute name="lengthspecified" type="s:ST_TrueFalse" default="f" use="optional"/> + <xsd:attribute name="length" type="xsd:string" use="optional"/> + <xsd:attribute name="accentbar" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="textborder" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="minusx" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="minusy" type="s:ST_TrueFalse" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Lock"> + <xsd:attributeGroup ref="v:AG_Ext"/> + <xsd:attribute name="position" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="selection" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="grouping" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="ungrouping" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="rotation" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="cropping" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="verticies" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="adjusthandles" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="text" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="aspectratio" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="shapetype" type="s:ST_TrueFalse" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_OLEObject"> + <xsd:sequence> + <xsd:element name="LinkType" type="ST_OLELinkType" minOccurs="0"/> + <xsd:element name="LockedField" type="s:ST_TrueFalseBlank" minOccurs="0"/> + <xsd:element name="FieldCodes" type="xsd:string" minOccurs="0"/> + </xsd:sequence> + <xsd:attribute name="Type" type="ST_OLEType" use="optional"/> + <xsd:attribute name="ProgID" type="xsd:string" use="optional"/> + <xsd:attribute name="ShapeID" type="xsd:string" use="optional"/> + <xsd:attribute name="DrawAspect" type="ST_OLEDrawAspect" use="optional"/> + <xsd:attribute name="ObjectID" type="xsd:string" use="optional"/> + <xsd:attribute ref="r:id" use="optional"/> + <xsd:attribute name="UpdateMode" type="ST_OLEUpdateMode" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Complex"> + <xsd:attributeGroup ref="v:AG_Ext"/> + </xsd:complexType> + <xsd:complexType name="CT_StrokeChild"> + <xsd:attributeGroup ref="v:AG_Ext"/> + <xsd:attribute name="on" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="weight" type="xsd:string" use="optional"/> + <xsd:attribute name="color" type="s:ST_ColorType" use="optional"/> + <xsd:attribute name="color2" type="s:ST_ColorType" use="optional"/> + <xsd:attribute name="opacity" type="xsd:string" use="optional"/> + <xsd:attribute name="linestyle" type="v:ST_StrokeLineStyle" use="optional"/> + <xsd:attribute name="miterlimit" type="xsd:decimal" use="optional"/> + <xsd:attribute name="joinstyle" type="v:ST_StrokeJoinStyle" use="optional"/> + <xsd:attribute name="endcap" type="v:ST_StrokeEndCap" use="optional"/> + <xsd:attribute name="dashstyle" type="xsd:string" use="optional"/> + <xsd:attribute name="insetpen" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="filltype" type="v:ST_FillType" use="optional"/> + <xsd:attribute name="src" type="xsd:string" use="optional"/> + <xsd:attribute name="imageaspect" type="v:ST_ImageAspect" use="optional"/> + <xsd:attribute name="imagesize" type="xsd:string" use="optional"/> + <xsd:attribute name="imagealignshape" type="s:ST_TrueFalse" use="optional"/> + <xsd:attribute name="startarrow" type="v:ST_StrokeArrowType" use="optional"/> + <xsd:attribute name="startarrowwidth" type="v:ST_StrokeArrowWidth" use="optional"/> + <xsd:attribute name="startarrowlength" type="v:ST_StrokeArrowLength" use="optional"/> + <xsd:attribute name="endarrow" type="v:ST_StrokeArrowType" use="optional"/> + <xsd:attribute name="endarrowwidth" type="v:ST_StrokeArrowWidth" use="optional"/> + <xsd:attribute name="endarrowlength" type="v:ST_StrokeArrowLength" use="optional"/> + <xsd:attribute ref="href"/> + <xsd:attribute ref="althref"/> + <xsd:attribute ref="title"/> + <xsd:attribute ref="forcedash"/> + </xsd:complexType> + <xsd:complexType name="CT_ClipPath"> + <xsd:attribute name="v" type="xsd:string" use="required" form="qualified"/> + </xsd:complexType> + <xsd:complexType name="CT_Fill"> + <xsd:attributeGroup ref="v:AG_Ext"/> + <xsd:attribute name="type" type="ST_FillType"/> + </xsd:complexType> + <xsd:simpleType name="ST_RType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="arc"/> + <xsd:enumeration value="callout"/> + <xsd:enumeration value="connector"/> + <xsd:enumeration value="align"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_How"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="top"/> + <xsd:enumeration value="middle"/> + <xsd:enumeration value="bottom"/> + <xsd:enumeration value="left"/> + <xsd:enumeration value="center"/> + <xsd:enumeration value="right"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_BWMode"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="color"/> + <xsd:enumeration value="auto"/> + <xsd:enumeration value="grayScale"/> + <xsd:enumeration value="lightGrayscale"/> + <xsd:enumeration value="inverseGray"/> + <xsd:enumeration value="grayOutline"/> + <xsd:enumeration value="highContrast"/> + <xsd:enumeration value="black"/> + <xsd:enumeration value="white"/> + <xsd:enumeration value="hide"/> + <xsd:enumeration value="undrawn"/> + <xsd:enumeration value="blackTextAndLines"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ScreenSize"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="544,376"/> + <xsd:enumeration value="640,480"/> + <xsd:enumeration value="720,512"/> + <xsd:enumeration value="800,600"/> + <xsd:enumeration value="1024,768"/> + <xsd:enumeration value="1152,862"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_InsetMode"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="auto"/> + <xsd:enumeration value="custom"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ColorMode"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="auto"/> + <xsd:enumeration value="custom"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ContentType"> + <xsd:restriction base="xsd:string"/> + </xsd:simpleType> + <xsd:simpleType name="ST_DiagramLayout"> + <xsd:restriction base="xsd:integer"> + <xsd:enumeration value="0"/> + <xsd:enumeration value="1"/> + <xsd:enumeration value="2"/> + <xsd:enumeration value="3"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ExtrusionType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="perspective"/> + <xsd:enumeration value="parallel"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ExtrusionRender"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="solid"/> + <xsd:enumeration value="wireFrame"/> + <xsd:enumeration value="boundingCube"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ExtrusionPlane"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="XY"/> + <xsd:enumeration value="ZX"/> + <xsd:enumeration value="YZ"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_Angle"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="any"/> + <xsd:enumeration value="30"/> + <xsd:enumeration value="45"/> + <xsd:enumeration value="60"/> + <xsd:enumeration value="90"/> + <xsd:enumeration value="auto"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_CalloutDrop"> + <xsd:restriction base="xsd:string"/> + </xsd:simpleType> + <xsd:simpleType name="ST_CalloutPlacement"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="top"/> + <xsd:enumeration value="center"/> + <xsd:enumeration value="bottom"/> + <xsd:enumeration value="user"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ConnectorType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="straight"/> + <xsd:enumeration value="elbow"/> + <xsd:enumeration value="curved"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_HrAlign"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="left"/> + <xsd:enumeration value="right"/> + <xsd:enumeration value="center"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_ConnectType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="rect"/> + <xsd:enumeration value="segments"/> + <xsd:enumeration value="custom"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_OLELinkType"> + <xsd:restriction base="xsd:string"/> + </xsd:simpleType> + <xsd:simpleType name="ST_OLEType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="Embed"/> + <xsd:enumeration value="Link"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_OLEDrawAspect"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="Content"/> + <xsd:enumeration value="Icon"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_OLEUpdateMode"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="Always"/> + <xsd:enumeration value="OnCall"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_FillType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="gradientCenter"/> + <xsd:enumeration value="solid"/> + <xsd:enumeration value="pattern"/> + <xsd:enumeration value="tile"/> + <xsd:enumeration value="frame"/> + <xsd:enumeration value="gradientUnscaled"/> + <xsd:enumeration value="gradientRadial"/> + <xsd:enumeration value="gradient"/> + <xsd:enumeration value="background"/> + </xsd:restriction> + </xsd:simpleType> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/vml-presentationDrawing.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/vml-presentationDrawing.xsd new file mode 100644 index 00000000..dd079e60 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/vml-presentationDrawing.xsd @@ -0,0 +1,12 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" + xmlns="urn:schemas-microsoft-com:office:powerpoint" + targetNamespace="urn:schemas-microsoft-com:office:powerpoint" elementFormDefault="qualified" + attributeFormDefault="unqualified"> + <xsd:element name="iscomment" type="CT_Empty"/> + <xsd:element name="textdata" type="CT_Rel"/> + <xsd:complexType name="CT_Empty"/> + <xsd:complexType name="CT_Rel"> + <xsd:attribute name="id" type="xsd:string"/> + </xsd:complexType> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/vml-spreadsheetDrawing.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/vml-spreadsheetDrawing.xsd new file mode 100644 index 00000000..3dd6cf62 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/vml-spreadsheetDrawing.xsd @@ -0,0 +1,108 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" + xmlns="urn:schemas-microsoft-com:office:excel" + xmlns:s="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + targetNamespace="urn:schemas-microsoft-com:office:excel" elementFormDefault="qualified" + attributeFormDefault="unqualified"> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + schemaLocation="shared-commonSimpleTypes.xsd"/> + <xsd:element name="ClientData" type="CT_ClientData"/> + <xsd:complexType name="CT_ClientData"> + <xsd:choice minOccurs="0" maxOccurs="unbounded"> + <xsd:element name="MoveWithCells" type="s:ST_TrueFalseBlank"/> + <xsd:element name="SizeWithCells" type="s:ST_TrueFalseBlank"/> + <xsd:element name="Anchor" type="xsd:string"/> + <xsd:element name="Locked" type="s:ST_TrueFalseBlank"/> + <xsd:element name="DefaultSize" type="s:ST_TrueFalseBlank"/> + <xsd:element name="PrintObject" type="s:ST_TrueFalseBlank"/> + <xsd:element name="Disabled" type="s:ST_TrueFalseBlank"/> + <xsd:element name="AutoFill" type="s:ST_TrueFalseBlank"/> + <xsd:element name="AutoLine" type="s:ST_TrueFalseBlank"/> + <xsd:element name="AutoPict" type="s:ST_TrueFalseBlank"/> + <xsd:element name="FmlaMacro" type="xsd:string"/> + <xsd:element name="TextHAlign" type="xsd:string"/> + <xsd:element name="TextVAlign" type="xsd:string"/> + <xsd:element name="LockText" type="s:ST_TrueFalseBlank"/> + <xsd:element name="JustLastX" type="s:ST_TrueFalseBlank"/> + <xsd:element name="SecretEdit" type="s:ST_TrueFalseBlank"/> + <xsd:element name="Default" type="s:ST_TrueFalseBlank"/> + <xsd:element name="Help" type="s:ST_TrueFalseBlank"/> + <xsd:element name="Cancel" type="s:ST_TrueFalseBlank"/> + <xsd:element name="Dismiss" type="s:ST_TrueFalseBlank"/> + <xsd:element name="Accel" type="xsd:integer"/> + <xsd:element name="Accel2" type="xsd:integer"/> + <xsd:element name="Row" type="xsd:integer"/> + <xsd:element name="Column" type="xsd:integer"/> + <xsd:element name="Visible" type="s:ST_TrueFalseBlank"/> + <xsd:element name="RowHidden" type="s:ST_TrueFalseBlank"/> + <xsd:element name="ColHidden" type="s:ST_TrueFalseBlank"/> + <xsd:element name="VTEdit" type="xsd:integer"/> + <xsd:element name="MultiLine" type="s:ST_TrueFalseBlank"/> + <xsd:element name="VScroll" type="s:ST_TrueFalseBlank"/> + <xsd:element name="ValidIds" type="s:ST_TrueFalseBlank"/> + <xsd:element name="FmlaRange" type="xsd:string"/> + <xsd:element name="WidthMin" type="xsd:integer"/> + <xsd:element name="Sel" type="xsd:integer"/> + <xsd:element name="NoThreeD2" type="s:ST_TrueFalseBlank"/> + <xsd:element name="SelType" type="xsd:string"/> + <xsd:element name="MultiSel" type="xsd:string"/> + <xsd:element name="LCT" type="xsd:string"/> + <xsd:element name="ListItem" type="xsd:string"/> + <xsd:element name="DropStyle" type="xsd:string"/> + <xsd:element name="Colored" type="s:ST_TrueFalseBlank"/> + <xsd:element name="DropLines" type="xsd:integer"/> + <xsd:element name="Checked" type="xsd:integer"/> + <xsd:element name="FmlaLink" type="xsd:string"/> + <xsd:element name="FmlaPict" type="xsd:string"/> + <xsd:element name="NoThreeD" type="s:ST_TrueFalseBlank"/> + <xsd:element name="FirstButton" type="s:ST_TrueFalseBlank"/> + <xsd:element name="FmlaGroup" type="xsd:string"/> + <xsd:element name="Val" type="xsd:integer"/> + <xsd:element name="Min" type="xsd:integer"/> + <xsd:element name="Max" type="xsd:integer"/> + <xsd:element name="Inc" type="xsd:integer"/> + <xsd:element name="Page" type="xsd:integer"/> + <xsd:element name="Horiz" type="s:ST_TrueFalseBlank"/> + <xsd:element name="Dx" type="xsd:integer"/> + <xsd:element name="MapOCX" type="s:ST_TrueFalseBlank"/> + <xsd:element name="CF" type="ST_CF"/> + <xsd:element name="Camera" type="s:ST_TrueFalseBlank"/> + <xsd:element name="RecalcAlways" type="s:ST_TrueFalseBlank"/> + <xsd:element name="AutoScale" type="s:ST_TrueFalseBlank"/> + <xsd:element name="DDE" type="s:ST_TrueFalseBlank"/> + <xsd:element name="UIObj" type="s:ST_TrueFalseBlank"/> + <xsd:element name="ScriptText" type="xsd:string"/> + <xsd:element name="ScriptExtended" type="xsd:string"/> + <xsd:element name="ScriptLanguage" type="xsd:nonNegativeInteger"/> + <xsd:element name="ScriptLocation" type="xsd:nonNegativeInteger"/> + <xsd:element name="FmlaTxbx" type="xsd:string"/> + </xsd:choice> + <xsd:attribute name="ObjectType" type="ST_ObjectType" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_CF"> + <xsd:restriction base="xsd:string"/> + </xsd:simpleType> + <xsd:simpleType name="ST_ObjectType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="Button"/> + <xsd:enumeration value="Checkbox"/> + <xsd:enumeration value="Dialog"/> + <xsd:enumeration value="Drop"/> + <xsd:enumeration value="Edit"/> + <xsd:enumeration value="GBox"/> + <xsd:enumeration value="Label"/> + <xsd:enumeration value="LineA"/> + <xsd:enumeration value="List"/> + <xsd:enumeration value="Movie"/> + <xsd:enumeration value="Note"/> + <xsd:enumeration value="Pict"/> + <xsd:enumeration value="Radio"/> + <xsd:enumeration value="RectA"/> + <xsd:enumeration value="Scroll"/> + <xsd:enumeration value="Spin"/> + <xsd:enumeration value="Shape"/> + <xsd:enumeration value="Group"/> + <xsd:enumeration value="Rect"/> + </xsd:restriction> + </xsd:simpleType> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/vml-wordprocessingDrawing.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/vml-wordprocessingDrawing.xsd new file mode 100644 index 00000000..f1041e34 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/vml-wordprocessingDrawing.xsd @@ -0,0 +1,96 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" + xmlns="urn:schemas-microsoft-com:office:word" + targetNamespace="urn:schemas-microsoft-com:office:word" elementFormDefault="qualified" + attributeFormDefault="unqualified"> + <xsd:element name="bordertop" type="CT_Border"/> + <xsd:element name="borderleft" type="CT_Border"/> + <xsd:element name="borderright" type="CT_Border"/> + <xsd:element name="borderbottom" type="CT_Border"/> + <xsd:complexType name="CT_Border"> + <xsd:attribute name="type" type="ST_BorderType" use="optional"/> + <xsd:attribute name="width" type="xsd:positiveInteger" use="optional"/> + <xsd:attribute name="shadow" type="ST_BorderShadow" use="optional"/> + </xsd:complexType> + <xsd:element name="wrap" type="CT_Wrap"/> + <xsd:complexType name="CT_Wrap"> + <xsd:attribute name="type" type="ST_WrapType" use="optional"/> + <xsd:attribute name="side" type="ST_WrapSide" use="optional"/> + <xsd:attribute name="anchorx" type="ST_HorizontalAnchor" use="optional"/> + <xsd:attribute name="anchory" type="ST_VerticalAnchor" use="optional"/> + </xsd:complexType> + <xsd:element name="anchorlock" type="CT_AnchorLock"/> + <xsd:complexType name="CT_AnchorLock"/> + <xsd:simpleType name="ST_BorderType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="single"/> + <xsd:enumeration value="thick"/> + <xsd:enumeration value="double"/> + <xsd:enumeration value="hairline"/> + <xsd:enumeration value="dot"/> + <xsd:enumeration value="dash"/> + <xsd:enumeration value="dotDash"/> + <xsd:enumeration value="dashDotDot"/> + <xsd:enumeration value="triple"/> + <xsd:enumeration value="thinThickSmall"/> + <xsd:enumeration value="thickThinSmall"/> + <xsd:enumeration value="thickBetweenThinSmall"/> + <xsd:enumeration value="thinThick"/> + <xsd:enumeration value="thickThin"/> + <xsd:enumeration value="thickBetweenThin"/> + <xsd:enumeration value="thinThickLarge"/> + <xsd:enumeration value="thickThinLarge"/> + <xsd:enumeration value="thickBetweenThinLarge"/> + <xsd:enumeration value="wave"/> + <xsd:enumeration value="doubleWave"/> + <xsd:enumeration value="dashedSmall"/> + <xsd:enumeration value="dashDotStroked"/> + <xsd:enumeration value="threeDEmboss"/> + <xsd:enumeration value="threeDEngrave"/> + <xsd:enumeration value="HTMLOutset"/> + <xsd:enumeration value="HTMLInset"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_BorderShadow"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="t"/> + <xsd:enumeration value="true"/> + <xsd:enumeration value="f"/> + <xsd:enumeration value="false"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_WrapType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="topAndBottom"/> + <xsd:enumeration value="square"/> + <xsd:enumeration value="none"/> + <xsd:enumeration value="tight"/> + <xsd:enumeration value="through"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_WrapSide"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="both"/> + <xsd:enumeration value="left"/> + <xsd:enumeration value="right"/> + <xsd:enumeration value="largest"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_HorizontalAnchor"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="margin"/> + <xsd:enumeration value="page"/> + <xsd:enumeration value="text"/> + <xsd:enumeration value="char"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_VerticalAnchor"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="margin"/> + <xsd:enumeration value="page"/> + <xsd:enumeration value="text"/> + <xsd:enumeration value="line"/> + </xsd:restriction> + </xsd:simpleType> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/wml.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/wml.xsd new file mode 100644 index 00000000..9c5b7a63 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/wml.xsd @@ -0,0 +1,3646 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" + xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math" + xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" + xmlns:sl="http://schemas.openxmlformats.org/schemaLibrary/2006/main" + xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" + xmlns="http://schemas.openxmlformats.org/wordprocessingml/2006/main" + xmlns:s="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" + elementFormDefault="qualified" attributeFormDefault="qualified" blockDefault="#all" + targetNamespace="http://schemas.openxmlformats.org/wordprocessingml/2006/main"> + <xsd:import namespace="http://schemas.openxmlformats.org/markup-compatibility/2006" schemaLocation="../mce/mc.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" + schemaLocation="dml-wordprocessingDrawing.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/math" + schemaLocation="shared-math.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/relationships" + schemaLocation="shared-relationshipReference.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" + schemaLocation="shared-commonSimpleTypes.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/schemaLibrary/2006/main" + schemaLocation="shared-customXmlSchemaProperties.xsd"/> + <xsd:import namespace="http://www.w3.org/XML/1998/namespace"/> + <xsd:complexType name="CT_Empty"/> + <xsd:complexType name="CT_OnOff"> + <xsd:attribute name="val" type="s:ST_OnOff"/> + </xsd:complexType> + <xsd:simpleType name="ST_LongHexNumber"> + <xsd:restriction base="xsd:hexBinary"> + <xsd:length value="4"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_LongHexNumber"> + <xsd:attribute name="val" type="ST_LongHexNumber" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_ShortHexNumber"> + <xsd:restriction base="xsd:hexBinary"> + <xsd:length value="2"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_UcharHexNumber"> + <xsd:restriction base="xsd:hexBinary"> + <xsd:length value="1"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Charset"> + <xsd:attribute name="val" type="ST_UcharHexNumber" use="optional"/> + <xsd:attribute name="characterSet" type="s:ST_String" use="optional" default="ISO-8859-1"/> + </xsd:complexType> + <xsd:simpleType name="ST_DecimalNumberOrPercent"> + <xsd:union memberTypes="ST_UnqualifiedPercentage s:ST_Percentage"/> + </xsd:simpleType> + <xsd:simpleType name="ST_UnqualifiedPercentage"> + <xsd:restriction base="xsd:decimal"/> + </xsd:simpleType> + <xsd:simpleType name="ST_DecimalNumber"> + <xsd:restriction base="xsd:integer"/> + </xsd:simpleType> + <xsd:complexType name="CT_DecimalNumber"> + <xsd:attribute name="val" type="ST_DecimalNumber" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_UnsignedDecimalNumber"> + <xsd:attribute name="val" type="s:ST_UnsignedDecimalNumber" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_DecimalNumberOrPrecent"> + <xsd:attribute name="val" type="ST_DecimalNumberOrPercent" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_TwipsMeasure"> + <xsd:attribute name="val" type="s:ST_TwipsMeasure" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_SignedTwipsMeasure"> + <xsd:union memberTypes="xsd:integer s:ST_UniversalMeasure"/> + </xsd:simpleType> + <xsd:complexType name="CT_SignedTwipsMeasure"> + <xsd:attribute name="val" type="ST_SignedTwipsMeasure" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_PixelsMeasure"> + <xsd:restriction base="s:ST_UnsignedDecimalNumber"/> + </xsd:simpleType> + <xsd:complexType name="CT_PixelsMeasure"> + <xsd:attribute name="val" type="ST_PixelsMeasure" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_HpsMeasure"> + <xsd:union memberTypes="s:ST_UnsignedDecimalNumber s:ST_PositiveUniversalMeasure"/> + </xsd:simpleType> + <xsd:complexType name="CT_HpsMeasure"> + <xsd:attribute name="val" type="ST_HpsMeasure" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_SignedHpsMeasure"> + <xsd:union memberTypes="xsd:integer s:ST_UniversalMeasure"/> + </xsd:simpleType> + <xsd:complexType name="CT_SignedHpsMeasure"> + <xsd:attribute name="val" type="ST_SignedHpsMeasure" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_DateTime"> + <xsd:restriction base="xsd:dateTime"/> + </xsd:simpleType> + <xsd:simpleType name="ST_MacroName"> + <xsd:restriction base="xsd:string"> + <xsd:maxLength value="33"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_MacroName"> + <xsd:attribute name="val" use="required" type="ST_MacroName"/> + </xsd:complexType> + <xsd:simpleType name="ST_EighthPointMeasure"> + <xsd:restriction base="s:ST_UnsignedDecimalNumber"/> + </xsd:simpleType> + <xsd:simpleType name="ST_PointMeasure"> + <xsd:restriction base="s:ST_UnsignedDecimalNumber"/> + </xsd:simpleType> + <xsd:complexType name="CT_String"> + <xsd:attribute name="val" type="s:ST_String" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_TextScale"> + <xsd:union memberTypes="ST_TextScalePercent ST_TextScaleDecimal"/> + </xsd:simpleType> + <xsd:simpleType name="ST_TextScalePercent"> + <xsd:restriction base="xsd:string"> + <xsd:pattern value="0*(600|([0-5]?[0-9]?[0-9]))%"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TextScaleDecimal"> + <xsd:restriction base="xsd:integer"> + <xsd:minInclusive value="0"/> + <xsd:maxInclusive value="600"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TextScale"> + <xsd:attribute name="val" type="ST_TextScale"/> + </xsd:complexType> + <xsd:simpleType name="ST_HighlightColor"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="black"/> + <xsd:enumeration value="blue"/> + <xsd:enumeration value="cyan"/> + <xsd:enumeration value="green"/> + <xsd:enumeration value="magenta"/> + <xsd:enumeration value="red"/> + <xsd:enumeration value="yellow"/> + <xsd:enumeration value="white"/> + <xsd:enumeration value="darkBlue"/> + <xsd:enumeration value="darkCyan"/> + <xsd:enumeration value="darkGreen"/> + <xsd:enumeration value="darkMagenta"/> + <xsd:enumeration value="darkRed"/> + <xsd:enumeration value="darkYellow"/> + <xsd:enumeration value="darkGray"/> + <xsd:enumeration value="lightGray"/> + <xsd:enumeration value="none"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Highlight"> + <xsd:attribute name="val" type="ST_HighlightColor" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_HexColorAuto"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="auto"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_HexColor"> + <xsd:union memberTypes="ST_HexColorAuto s:ST_HexColorRGB"/> + </xsd:simpleType> + <xsd:complexType name="CT_Color"> + <xsd:attribute name="val" type="ST_HexColor" use="required"/> + <xsd:attribute name="themeColor" type="ST_ThemeColor" use="optional"/> + <xsd:attribute name="themeTint" type="ST_UcharHexNumber" use="optional"/> + <xsd:attribute name="themeShade" type="ST_UcharHexNumber" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Lang"> + <xsd:attribute name="val" type="s:ST_Lang" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Guid"> + <xsd:attribute name="val" type="s:ST_Guid"/> + </xsd:complexType> + <xsd:simpleType name="ST_Underline"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="single"/> + <xsd:enumeration value="words"/> + <xsd:enumeration value="double"/> + <xsd:enumeration value="thick"/> + <xsd:enumeration value="dotted"/> + <xsd:enumeration value="dottedHeavy"/> + <xsd:enumeration value="dash"/> + <xsd:enumeration value="dashedHeavy"/> + <xsd:enumeration value="dashLong"/> + <xsd:enumeration value="dashLongHeavy"/> + <xsd:enumeration value="dotDash"/> + <xsd:enumeration value="dashDotHeavy"/> + <xsd:enumeration value="dotDotDash"/> + <xsd:enumeration value="dashDotDotHeavy"/> + <xsd:enumeration value="wave"/> + <xsd:enumeration value="wavyHeavy"/> + <xsd:enumeration value="wavyDouble"/> + <xsd:enumeration value="none"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Underline"> + <xsd:attribute name="val" type="ST_Underline" use="optional"/> + <xsd:attribute name="color" type="ST_HexColor" use="optional" default="auto"/> + <xsd:attribute name="themeColor" type="ST_ThemeColor" use="optional"/> + <xsd:attribute name="themeTint" type="ST_UcharHexNumber" use="optional"/> + <xsd:attribute name="themeShade" type="ST_UcharHexNumber" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_TextEffect"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="blinkBackground"/> + <xsd:enumeration value="lights"/> + <xsd:enumeration value="antsBlack"/> + <xsd:enumeration value="antsRed"/> + <xsd:enumeration value="shimmer"/> + <xsd:enumeration value="sparkle"/> + <xsd:enumeration value="none"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TextEffect"> + <xsd:attribute name="val" type="ST_TextEffect" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_Border"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="nil"/> + <xsd:enumeration value="none"/> + <xsd:enumeration value="single"/> + <xsd:enumeration value="thick"/> + <xsd:enumeration value="double"/> + <xsd:enumeration value="dotted"/> + <xsd:enumeration value="dashed"/> + <xsd:enumeration value="dotDash"/> + <xsd:enumeration value="dotDotDash"/> + <xsd:enumeration value="triple"/> + <xsd:enumeration value="thinThickSmallGap"/> + <xsd:enumeration value="thickThinSmallGap"/> + <xsd:enumeration value="thinThickThinSmallGap"/> + <xsd:enumeration value="thinThickMediumGap"/> + <xsd:enumeration value="thickThinMediumGap"/> + <xsd:enumeration value="thinThickThinMediumGap"/> + <xsd:enumeration value="thinThickLargeGap"/> + <xsd:enumeration value="thickThinLargeGap"/> + <xsd:enumeration value="thinThickThinLargeGap"/> + <xsd:enumeration value="wave"/> + <xsd:enumeration value="doubleWave"/> + <xsd:enumeration value="dashSmallGap"/> + <xsd:enumeration value="dashDotStroked"/> + <xsd:enumeration value="threeDEmboss"/> + <xsd:enumeration value="threeDEngrave"/> + <xsd:enumeration value="outset"/> + <xsd:enumeration value="inset"/> + <xsd:enumeration value="apples"/> + <xsd:enumeration value="archedScallops"/> + <xsd:enumeration value="babyPacifier"/> + <xsd:enumeration value="babyRattle"/> + <xsd:enumeration value="balloons3Colors"/> + <xsd:enumeration value="balloonsHotAir"/> + <xsd:enumeration value="basicBlackDashes"/> + <xsd:enumeration value="basicBlackDots"/> + <xsd:enumeration value="basicBlackSquares"/> + <xsd:enumeration value="basicThinLines"/> + <xsd:enumeration value="basicWhiteDashes"/> + <xsd:enumeration value="basicWhiteDots"/> + <xsd:enumeration value="basicWhiteSquares"/> + <xsd:enumeration value="basicWideInline"/> + <xsd:enumeration value="basicWideMidline"/> + <xsd:enumeration value="basicWideOutline"/> + <xsd:enumeration value="bats"/> + <xsd:enumeration value="birds"/> + <xsd:enumeration value="birdsFlight"/> + <xsd:enumeration value="cabins"/> + <xsd:enumeration value="cakeSlice"/> + <xsd:enumeration value="candyCorn"/> + <xsd:enumeration value="celticKnotwork"/> + <xsd:enumeration value="certificateBanner"/> + <xsd:enumeration value="chainLink"/> + <xsd:enumeration value="champagneBottle"/> + <xsd:enumeration value="checkedBarBlack"/> + <xsd:enumeration value="checkedBarColor"/> + <xsd:enumeration value="checkered"/> + <xsd:enumeration value="christmasTree"/> + <xsd:enumeration value="circlesLines"/> + <xsd:enumeration value="circlesRectangles"/> + <xsd:enumeration value="classicalWave"/> + <xsd:enumeration value="clocks"/> + <xsd:enumeration value="compass"/> + <xsd:enumeration value="confetti"/> + <xsd:enumeration value="confettiGrays"/> + <xsd:enumeration value="confettiOutline"/> + <xsd:enumeration value="confettiStreamers"/> + <xsd:enumeration value="confettiWhite"/> + <xsd:enumeration value="cornerTriangles"/> + <xsd:enumeration value="couponCutoutDashes"/> + <xsd:enumeration value="couponCutoutDots"/> + <xsd:enumeration value="crazyMaze"/> + <xsd:enumeration value="creaturesButterfly"/> + <xsd:enumeration value="creaturesFish"/> + <xsd:enumeration value="creaturesInsects"/> + <xsd:enumeration value="creaturesLadyBug"/> + <xsd:enumeration value="crossStitch"/> + <xsd:enumeration value="cup"/> + <xsd:enumeration value="decoArch"/> + <xsd:enumeration value="decoArchColor"/> + <xsd:enumeration value="decoBlocks"/> + <xsd:enumeration value="diamondsGray"/> + <xsd:enumeration value="doubleD"/> + <xsd:enumeration value="doubleDiamonds"/> + <xsd:enumeration value="earth1"/> + <xsd:enumeration value="earth2"/> + <xsd:enumeration value="earth3"/> + <xsd:enumeration value="eclipsingSquares1"/> + <xsd:enumeration value="eclipsingSquares2"/> + <xsd:enumeration value="eggsBlack"/> + <xsd:enumeration value="fans"/> + <xsd:enumeration value="film"/> + <xsd:enumeration value="firecrackers"/> + <xsd:enumeration value="flowersBlockPrint"/> + <xsd:enumeration value="flowersDaisies"/> + <xsd:enumeration value="flowersModern1"/> + <xsd:enumeration value="flowersModern2"/> + <xsd:enumeration value="flowersPansy"/> + <xsd:enumeration value="flowersRedRose"/> + <xsd:enumeration value="flowersRoses"/> + <xsd:enumeration value="flowersTeacup"/> + <xsd:enumeration value="flowersTiny"/> + <xsd:enumeration value="gems"/> + <xsd:enumeration value="gingerbreadMan"/> + <xsd:enumeration value="gradient"/> + <xsd:enumeration value="handmade1"/> + <xsd:enumeration value="handmade2"/> + <xsd:enumeration value="heartBalloon"/> + <xsd:enumeration value="heartGray"/> + <xsd:enumeration value="hearts"/> + <xsd:enumeration value="heebieJeebies"/> + <xsd:enumeration value="holly"/> + <xsd:enumeration value="houseFunky"/> + <xsd:enumeration value="hypnotic"/> + <xsd:enumeration value="iceCreamCones"/> + <xsd:enumeration value="lightBulb"/> + <xsd:enumeration value="lightning1"/> + <xsd:enumeration value="lightning2"/> + <xsd:enumeration value="mapPins"/> + <xsd:enumeration value="mapleLeaf"/> + <xsd:enumeration value="mapleMuffins"/> + <xsd:enumeration value="marquee"/> + <xsd:enumeration value="marqueeToothed"/> + <xsd:enumeration value="moons"/> + <xsd:enumeration value="mosaic"/> + <xsd:enumeration value="musicNotes"/> + <xsd:enumeration value="northwest"/> + <xsd:enumeration value="ovals"/> + <xsd:enumeration value="packages"/> + <xsd:enumeration value="palmsBlack"/> + <xsd:enumeration value="palmsColor"/> + <xsd:enumeration value="paperClips"/> + <xsd:enumeration value="papyrus"/> + <xsd:enumeration value="partyFavor"/> + <xsd:enumeration value="partyGlass"/> + <xsd:enumeration value="pencils"/> + <xsd:enumeration value="people"/> + <xsd:enumeration value="peopleWaving"/> + <xsd:enumeration value="peopleHats"/> + <xsd:enumeration value="poinsettias"/> + <xsd:enumeration value="postageStamp"/> + <xsd:enumeration value="pumpkin1"/> + <xsd:enumeration value="pushPinNote2"/> + <xsd:enumeration value="pushPinNote1"/> + <xsd:enumeration value="pyramids"/> + <xsd:enumeration value="pyramidsAbove"/> + <xsd:enumeration value="quadrants"/> + <xsd:enumeration value="rings"/> + <xsd:enumeration value="safari"/> + <xsd:enumeration value="sawtooth"/> + <xsd:enumeration value="sawtoothGray"/> + <xsd:enumeration value="scaredCat"/> + <xsd:enumeration value="seattle"/> + <xsd:enumeration value="shadowedSquares"/> + <xsd:enumeration value="sharksTeeth"/> + <xsd:enumeration value="shorebirdTracks"/> + <xsd:enumeration value="skyrocket"/> + <xsd:enumeration value="snowflakeFancy"/> + <xsd:enumeration value="snowflakes"/> + <xsd:enumeration value="sombrero"/> + <xsd:enumeration value="southwest"/> + <xsd:enumeration value="stars"/> + <xsd:enumeration value="starsTop"/> + <xsd:enumeration value="stars3d"/> + <xsd:enumeration value="starsBlack"/> + <xsd:enumeration value="starsShadowed"/> + <xsd:enumeration value="sun"/> + <xsd:enumeration value="swirligig"/> + <xsd:enumeration value="tornPaper"/> + <xsd:enumeration value="tornPaperBlack"/> + <xsd:enumeration value="trees"/> + <xsd:enumeration value="triangleParty"/> + <xsd:enumeration value="triangles"/> + <xsd:enumeration value="triangle1"/> + <xsd:enumeration value="triangle2"/> + <xsd:enumeration value="triangleCircle1"/> + <xsd:enumeration value="triangleCircle2"/> + <xsd:enumeration value="shapes1"/> + <xsd:enumeration value="shapes2"/> + <xsd:enumeration value="twistedLines1"/> + <xsd:enumeration value="twistedLines2"/> + <xsd:enumeration value="vine"/> + <xsd:enumeration value="waveline"/> + <xsd:enumeration value="weavingAngles"/> + <xsd:enumeration value="weavingBraid"/> + <xsd:enumeration value="weavingRibbon"/> + <xsd:enumeration value="weavingStrips"/> + <xsd:enumeration value="whiteFlowers"/> + <xsd:enumeration value="woodwork"/> + <xsd:enumeration value="xIllusions"/> + <xsd:enumeration value="zanyTriangles"/> + <xsd:enumeration value="zigZag"/> + <xsd:enumeration value="zigZagStitch"/> + <xsd:enumeration value="custom"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Border"> + <xsd:attribute name="val" type="ST_Border" use="required"/> + <xsd:attribute name="color" type="ST_HexColor" use="optional" default="auto"/> + <xsd:attribute name="themeColor" type="ST_ThemeColor" use="optional"/> + <xsd:attribute name="themeTint" type="ST_UcharHexNumber" use="optional"/> + <xsd:attribute name="themeShade" type="ST_UcharHexNumber" use="optional"/> + <xsd:attribute name="sz" type="ST_EighthPointMeasure" use="optional"/> + <xsd:attribute name="space" type="ST_PointMeasure" use="optional" default="0"/> + <xsd:attribute name="shadow" type="s:ST_OnOff" use="optional"/> + <xsd:attribute name="frame" type="s:ST_OnOff" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_Shd"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="nil"/> + <xsd:enumeration value="clear"/> + <xsd:enumeration value="solid"/> + <xsd:enumeration value="horzStripe"/> + <xsd:enumeration value="vertStripe"/> + <xsd:enumeration value="reverseDiagStripe"/> + <xsd:enumeration value="diagStripe"/> + <xsd:enumeration value="horzCross"/> + <xsd:enumeration value="diagCross"/> + <xsd:enumeration value="thinHorzStripe"/> + <xsd:enumeration value="thinVertStripe"/> + <xsd:enumeration value="thinReverseDiagStripe"/> + <xsd:enumeration value="thinDiagStripe"/> + <xsd:enumeration value="thinHorzCross"/> + <xsd:enumeration value="thinDiagCross"/> + <xsd:enumeration value="pct5"/> + <xsd:enumeration value="pct10"/> + <xsd:enumeration value="pct12"/> + <xsd:enumeration value="pct15"/> + <xsd:enumeration value="pct20"/> + <xsd:enumeration value="pct25"/> + <xsd:enumeration value="pct30"/> + <xsd:enumeration value="pct35"/> + <xsd:enumeration value="pct37"/> + <xsd:enumeration value="pct40"/> + <xsd:enumeration value="pct45"/> + <xsd:enumeration value="pct50"/> + <xsd:enumeration value="pct55"/> + <xsd:enumeration value="pct60"/> + <xsd:enumeration value="pct62"/> + <xsd:enumeration value="pct65"/> + <xsd:enumeration value="pct70"/> + <xsd:enumeration value="pct75"/> + <xsd:enumeration value="pct80"/> + <xsd:enumeration value="pct85"/> + <xsd:enumeration value="pct87"/> + <xsd:enumeration value="pct90"/> + <xsd:enumeration value="pct95"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Shd"> + <xsd:attribute name="val" type="ST_Shd" use="required"/> + <xsd:attribute name="color" type="ST_HexColor" use="optional"/> + <xsd:attribute name="themeColor" type="ST_ThemeColor" use="optional"/> + <xsd:attribute name="themeTint" type="ST_UcharHexNumber" use="optional"/> + <xsd:attribute name="themeShade" type="ST_UcharHexNumber" use="optional"/> + <xsd:attribute name="fill" type="ST_HexColor" use="optional"/> + <xsd:attribute name="themeFill" type="ST_ThemeColor" use="optional"/> + <xsd:attribute name="themeFillTint" type="ST_UcharHexNumber" use="optional"/> + <xsd:attribute name="themeFillShade" type="ST_UcharHexNumber" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_VerticalAlignRun"> + <xsd:attribute name="val" type="s:ST_VerticalAlignRun" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_FitText"> + <xsd:attribute name="val" type="s:ST_TwipsMeasure" use="required"/> + <xsd:attribute name="id" type="ST_DecimalNumber" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_Em"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="dot"/> + <xsd:enumeration value="comma"/> + <xsd:enumeration value="circle"/> + <xsd:enumeration value="underDot"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Em"> + <xsd:attribute name="val" type="ST_Em" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Language"> + <xsd:attribute name="val" type="s:ST_Lang" use="optional"/> + <xsd:attribute name="eastAsia" type="s:ST_Lang" use="optional"/> + <xsd:attribute name="bidi" type="s:ST_Lang" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_CombineBrackets"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="round"/> + <xsd:enumeration value="square"/> + <xsd:enumeration value="angle"/> + <xsd:enumeration value="curly"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_EastAsianLayout"> + <xsd:attribute name="id" type="ST_DecimalNumber" use="optional"/> + <xsd:attribute name="combine" type="s:ST_OnOff" use="optional"/> + <xsd:attribute name="combineBrackets" type="ST_CombineBrackets" use="optional"/> + <xsd:attribute name="vert" type="s:ST_OnOff" use="optional"/> + <xsd:attribute name="vertCompress" type="s:ST_OnOff" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_HeightRule"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="auto"/> + <xsd:enumeration value="exact"/> + <xsd:enumeration value="atLeast"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_Wrap"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="auto"/> + <xsd:enumeration value="notBeside"/> + <xsd:enumeration value="around"/> + <xsd:enumeration value="tight"/> + <xsd:enumeration value="through"/> + <xsd:enumeration value="none"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_VAnchor"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="text"/> + <xsd:enumeration value="margin"/> + <xsd:enumeration value="page"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_HAnchor"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="text"/> + <xsd:enumeration value="margin"/> + <xsd:enumeration value="page"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_DropCap"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="drop"/> + <xsd:enumeration value="margin"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_FramePr"> + <xsd:attribute name="dropCap" type="ST_DropCap" use="optional"/> + <xsd:attribute name="lines" type="ST_DecimalNumber" use="optional"/> + <xsd:attribute name="w" type="s:ST_TwipsMeasure" use="optional"/> + <xsd:attribute name="h" type="s:ST_TwipsMeasure" use="optional"/> + <xsd:attribute name="vSpace" type="s:ST_TwipsMeasure" use="optional"/> + <xsd:attribute name="hSpace" type="s:ST_TwipsMeasure" use="optional"/> + <xsd:attribute name="wrap" type="ST_Wrap" use="optional"/> + <xsd:attribute name="hAnchor" type="ST_HAnchor" use="optional"/> + <xsd:attribute name="vAnchor" type="ST_VAnchor" use="optional"/> + <xsd:attribute name="x" type="ST_SignedTwipsMeasure" use="optional"/> + <xsd:attribute name="xAlign" type="s:ST_XAlign" use="optional"/> + <xsd:attribute name="y" type="ST_SignedTwipsMeasure" use="optional"/> + <xsd:attribute name="yAlign" type="s:ST_YAlign" use="optional"/> + <xsd:attribute name="hRule" type="ST_HeightRule" use="optional"/> + <xsd:attribute name="anchorLock" type="s:ST_OnOff" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_TabJc"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="clear"/> + <xsd:enumeration value="start"/> + <xsd:enumeration value="center"/> + <xsd:enumeration value="end"/> + <xsd:enumeration value="decimal"/> + <xsd:enumeration value="bar"/> + <xsd:enumeration value="num"/> + <xsd:enumeration value="left"/> + <xsd:enumeration value="right"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_TabTlc"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="dot"/> + <xsd:enumeration value="hyphen"/> + <xsd:enumeration value="underscore"/> + <xsd:enumeration value="heavy"/> + <xsd:enumeration value="middleDot"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TabStop"> + <xsd:attribute name="val" type="ST_TabJc" use="required"/> + <xsd:attribute name="leader" type="ST_TabTlc" use="optional"/> + <xsd:attribute name="pos" type="ST_SignedTwipsMeasure" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_LineSpacingRule"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="auto"/> + <xsd:enumeration value="exact"/> + <xsd:enumeration value="atLeast"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Spacing"> + <xsd:attribute name="before" type="s:ST_TwipsMeasure" use="optional" default="0"/> + <xsd:attribute name="beforeLines" type="ST_DecimalNumber" use="optional" default="0"/> + <xsd:attribute name="beforeAutospacing" type="s:ST_OnOff" use="optional" default="off"/> + <xsd:attribute name="after" type="s:ST_TwipsMeasure" use="optional" default="0"/> + <xsd:attribute name="afterLines" type="ST_DecimalNumber" use="optional" default="0"/> + <xsd:attribute name="afterAutospacing" type="s:ST_OnOff" use="optional" default="off"/> + <xsd:attribute name="line" type="ST_SignedTwipsMeasure" use="optional" default="0"/> + <xsd:attribute name="lineRule" type="ST_LineSpacingRule" use="optional" default="auto"/> + </xsd:complexType> + <xsd:complexType name="CT_Ind"> + <xsd:attribute name="start" type="ST_SignedTwipsMeasure" use="optional"/> + <xsd:attribute name="startChars" type="ST_DecimalNumber" use="optional"/> + <xsd:attribute name="end" type="ST_SignedTwipsMeasure" use="optional"/> + <xsd:attribute name="endChars" type="ST_DecimalNumber" use="optional"/> + <xsd:attribute name="left" type="ST_SignedTwipsMeasure" use="optional"/> + <xsd:attribute name="leftChars" type="ST_DecimalNumber" use="optional"/> + <xsd:attribute name="right" type="ST_SignedTwipsMeasure" use="optional"/> + <xsd:attribute name="rightChars" type="ST_DecimalNumber" use="optional"/> + <xsd:attribute name="hanging" type="s:ST_TwipsMeasure" use="optional"/> + <xsd:attribute name="hangingChars" type="ST_DecimalNumber" use="optional"/> + <xsd:attribute name="firstLine" type="s:ST_TwipsMeasure" use="optional"/> + <xsd:attribute name="firstLineChars" type="ST_DecimalNumber" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_Jc"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="start"/> + <xsd:enumeration value="center"/> + <xsd:enumeration value="end"/> + <xsd:enumeration value="both"/> + <xsd:enumeration value="mediumKashida"/> + <xsd:enumeration value="distribute"/> + <xsd:enumeration value="numTab"/> + <xsd:enumeration value="highKashida"/> + <xsd:enumeration value="lowKashida"/> + <xsd:enumeration value="thaiDistribute"/> + <xsd:enumeration value="left"/> + <xsd:enumeration value="right"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_JcTable"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="center"/> + <xsd:enumeration value="end"/> + <xsd:enumeration value="left"/> + <xsd:enumeration value="right"/> + <xsd:enumeration value="start"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Jc"> + <xsd:attribute name="val" type="ST_Jc" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_JcTable"> + <xsd:attribute name="val" type="ST_JcTable" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_View"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="print"/> + <xsd:enumeration value="outline"/> + <xsd:enumeration value="masterPages"/> + <xsd:enumeration value="normal"/> + <xsd:enumeration value="web"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_View"> + <xsd:attribute name="val" type="ST_View" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_Zoom"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="fullPage"/> + <xsd:enumeration value="bestFit"/> + <xsd:enumeration value="textFit"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Zoom"> + <xsd:attribute name="val" type="ST_Zoom" use="optional"/> + <xsd:attribute name="percent" type="ST_DecimalNumberOrPercent" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_WritingStyle"> + <xsd:attribute name="lang" type="s:ST_Lang" use="required"/> + <xsd:attribute name="vendorID" type="s:ST_String" use="required"/> + <xsd:attribute name="dllVersion" type="s:ST_String" use="required"/> + <xsd:attribute name="nlCheck" type="s:ST_OnOff" use="optional" default="off"/> + <xsd:attribute name="checkStyle" type="s:ST_OnOff" use="required"/> + <xsd:attribute name="appName" type="s:ST_String" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_Proof"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="clean"/> + <xsd:enumeration value="dirty"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Proof"> + <xsd:attribute name="spelling" type="ST_Proof" use="optional"/> + <xsd:attribute name="grammar" type="ST_Proof" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_DocType"> + <xsd:restriction base="xsd:string"/> + </xsd:simpleType> + <xsd:complexType name="CT_DocType"> + <xsd:attribute name="val" type="ST_DocType" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_DocProtect"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="readOnly"/> + <xsd:enumeration value="comments"/> + <xsd:enumeration value="trackedChanges"/> + <xsd:enumeration value="forms"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:attributeGroup name="AG_Password"> + <xsd:attribute name="algorithmName" type="s:ST_String" use="optional"/> + <xsd:attribute name="hashValue" type="xsd:base64Binary" use="optional"/> + <xsd:attribute name="saltValue" type="xsd:base64Binary" use="optional"/> + <xsd:attribute name="spinCount" type="ST_DecimalNumber" use="optional"/> + </xsd:attributeGroup> + <xsd:attributeGroup name="AG_TransitionalPassword"> + <xsd:attribute name="cryptProviderType" type="s:ST_CryptProv"/> + <xsd:attribute name="cryptAlgorithmClass" type="s:ST_AlgClass"/> + <xsd:attribute name="cryptAlgorithmType" type="s:ST_AlgType"/> + <xsd:attribute name="cryptAlgorithmSid" type="ST_DecimalNumber"/> + <xsd:attribute name="cryptSpinCount" type="ST_DecimalNumber"/> + <xsd:attribute name="cryptProvider" type="s:ST_String"/> + <xsd:attribute name="algIdExt" type="ST_LongHexNumber"/> + <xsd:attribute name="algIdExtSource" type="s:ST_String"/> + <xsd:attribute name="cryptProviderTypeExt" type="ST_LongHexNumber"/> + <xsd:attribute name="cryptProviderTypeExtSource" type="s:ST_String"/> + <xsd:attribute name="hash" type="xsd:base64Binary"/> + <xsd:attribute name="salt" type="xsd:base64Binary"/> + </xsd:attributeGroup> + <xsd:complexType name="CT_DocProtect"> + <xsd:attribute name="edit" type="ST_DocProtect" use="optional"/> + <xsd:attribute name="formatting" type="s:ST_OnOff" use="optional"/> + <xsd:attribute name="enforcement" type="s:ST_OnOff"/> + <xsd:attributeGroup ref="AG_Password"/> + <xsd:attributeGroup ref="AG_TransitionalPassword"/> + </xsd:complexType> + <xsd:simpleType name="ST_MailMergeDocType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="catalog"/> + <xsd:enumeration value="envelopes"/> + <xsd:enumeration value="mailingLabels"/> + <xsd:enumeration value="formLetters"/> + <xsd:enumeration value="email"/> + <xsd:enumeration value="fax"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_MailMergeDocType"> + <xsd:attribute name="val" type="ST_MailMergeDocType" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_MailMergeDataType"> + <xsd:restriction base="xsd:string"/> + </xsd:simpleType> + <xsd:complexType name="CT_MailMergeDataType"> + <xsd:attribute name="val" type="ST_MailMergeDataType" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_MailMergeDest"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="newDocument"/> + <xsd:enumeration value="printer"/> + <xsd:enumeration value="email"/> + <xsd:enumeration value="fax"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_MailMergeDest"> + <xsd:attribute name="val" type="ST_MailMergeDest" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_MailMergeOdsoFMDFieldType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="null"/> + <xsd:enumeration value="dbColumn"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_MailMergeOdsoFMDFieldType"> + <xsd:attribute name="val" type="ST_MailMergeOdsoFMDFieldType" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_TrackChangesView"> + <xsd:attribute name="markup" type="s:ST_OnOff" use="optional"/> + <xsd:attribute name="comments" type="s:ST_OnOff" use="optional"/> + <xsd:attribute name="insDel" type="s:ST_OnOff" use="optional"/> + <xsd:attribute name="formatting" type="s:ST_OnOff" use="optional"/> + <xsd:attribute name="inkAnnotations" type="s:ST_OnOff" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Kinsoku"> + <xsd:attribute name="lang" type="s:ST_Lang" use="required"/> + <xsd:attribute name="val" type="s:ST_String" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_TextDirection"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="tb"/> + <xsd:enumeration value="rl"/> + <xsd:enumeration value="lr"/> + <xsd:enumeration value="tbV"/> + <xsd:enumeration value="rlV"/> + <xsd:enumeration value="lrV"/> + <xsd:enumeration value="btLr"/> + <xsd:enumeration value="lrTb"/> + <xsd:enumeration value="lrTbV"/> + <xsd:enumeration value="tbLrV"/> + <xsd:enumeration value="tbRl"/> + <xsd:enumeration value="tbRlV"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TextDirection"> + <xsd:attribute name="val" type="ST_TextDirection" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_TextAlignment"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="top"/> + <xsd:enumeration value="center"/> + <xsd:enumeration value="baseline"/> + <xsd:enumeration value="bottom"/> + <xsd:enumeration value="auto"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TextAlignment"> + <xsd:attribute name="val" type="ST_TextAlignment" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_DisplacedByCustomXml"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="next"/> + <xsd:enumeration value="prev"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_AnnotationVMerge"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="cont"/> + <xsd:enumeration value="rest"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Markup"> + <xsd:attribute name="id" type="ST_DecimalNumber" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_TrackChange"> + <xsd:complexContent> + <xsd:extension base="CT_Markup"> + <xsd:attribute name="author" type="s:ST_String" use="required"/> + <xsd:attribute name="date" type="ST_DateTime" use="optional"/> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_CellMergeTrackChange"> + <xsd:complexContent> + <xsd:extension base="CT_TrackChange"> + <xsd:attribute name="vMerge" type="ST_AnnotationVMerge" use="optional"/> + <xsd:attribute name="vMergeOrig" type="ST_AnnotationVMerge" use="optional"/> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_TrackChangeRange"> + <xsd:complexContent> + <xsd:extension base="CT_TrackChange"> + <xsd:attribute name="displacedByCustomXml" type="ST_DisplacedByCustomXml" use="optional"/> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_MarkupRange"> + <xsd:complexContent> + <xsd:extension base="CT_Markup"> + <xsd:attribute name="displacedByCustomXml" type="ST_DisplacedByCustomXml" use="optional"/> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_BookmarkRange"> + <xsd:complexContent> + <xsd:extension base="CT_MarkupRange"> + <xsd:attribute name="colFirst" type="ST_DecimalNumber" use="optional"/> + <xsd:attribute name="colLast" type="ST_DecimalNumber" use="optional"/> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_Bookmark"> + <xsd:complexContent> + <xsd:extension base="CT_BookmarkRange"> + <xsd:attribute name="name" type="s:ST_String" use="required"/> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_MoveBookmark"> + <xsd:complexContent> + <xsd:extension base="CT_Bookmark"> + <xsd:attribute name="author" type="s:ST_String" use="required"/> + <xsd:attribute name="date" type="ST_DateTime" use="required"/> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_Comment"> + <xsd:complexContent> + <xsd:extension base="CT_TrackChange"> + <xsd:sequence> + <xsd:group ref="EG_BlockLevelElts" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="initials" type="s:ST_String" use="optional"/> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_TrackChangeNumbering"> + <xsd:complexContent> + <xsd:extension base="CT_TrackChange"> + <xsd:attribute name="original" type="s:ST_String" use="optional"/> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_TblPrExChange"> + <xsd:complexContent> + <xsd:extension base="CT_TrackChange"> + <xsd:sequence> + <xsd:element name="tblPrEx" type="CT_TblPrExBase" minOccurs="1"/> + </xsd:sequence> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_TcPrChange"> + <xsd:complexContent> + <xsd:extension base="CT_TrackChange"> + <xsd:sequence> + <xsd:element name="tcPr" type="CT_TcPrInner" minOccurs="1"/> + </xsd:sequence> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_TrPrChange"> + <xsd:complexContent> + <xsd:extension base="CT_TrackChange"> + <xsd:sequence> + <xsd:element name="trPr" type="CT_TrPrBase" minOccurs="1"/> + </xsd:sequence> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_TblGridChange"> + <xsd:complexContent> + <xsd:extension base="CT_Markup"> + <xsd:sequence> + <xsd:element name="tblGrid" type="CT_TblGridBase"/> + </xsd:sequence> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_TblPrChange"> + <xsd:complexContent> + <xsd:extension base="CT_TrackChange"> + <xsd:sequence> + <xsd:element name="tblPr" type="CT_TblPrBase"/> + </xsd:sequence> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_SectPrChange"> + <xsd:complexContent> + <xsd:extension base="CT_TrackChange"> + <xsd:sequence> + <xsd:element name="sectPr" type="CT_SectPrBase" minOccurs="0"/> + </xsd:sequence> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_PPrChange"> + <xsd:complexContent> + <xsd:extension base="CT_TrackChange"> + <xsd:sequence> + <xsd:element name="pPr" type="CT_PPrBase" minOccurs="1"/> + </xsd:sequence> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_RPrChange"> + <xsd:complexContent> + <xsd:extension base="CT_TrackChange"> + <xsd:sequence> + <xsd:element name="rPr" type="CT_RPrOriginal" minOccurs="1"/> + </xsd:sequence> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_ParaRPrChange"> + <xsd:complexContent> + <xsd:extension base="CT_TrackChange"> + <xsd:sequence> + <xsd:element name="rPr" type="CT_ParaRPrOriginal" minOccurs="1"/> + </xsd:sequence> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_RunTrackChange"> + <xsd:complexContent> + <xsd:extension base="CT_TrackChange"> + <xsd:choice minOccurs="0" maxOccurs="unbounded"> + <xsd:group ref="EG_ContentRunContent"/> + <xsd:group ref="m:EG_OMathMathElements"/> + </xsd:choice> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:group name="EG_PContentMath"> + <xsd:choice> + <xsd:group ref="EG_PContentBase" minOccurs="0" maxOccurs="unbounded"/> + <xsd:group ref="EG_ContentRunContentBase" minOccurs="0" maxOccurs="unbounded"/> + </xsd:choice> + </xsd:group> + <xsd:group name="EG_PContentBase"> + <xsd:choice> + <xsd:element name="customXml" type="CT_CustomXmlRun"/> + <xsd:element name="fldSimple" type="CT_SimpleField" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="hyperlink" type="CT_Hyperlink"/> + </xsd:choice> + </xsd:group> + <xsd:group name="EG_ContentRunContentBase"> + <xsd:choice> + <xsd:element name="smartTag" type="CT_SmartTagRun"/> + <xsd:element name="sdt" type="CT_SdtRun"/> + <xsd:group ref="EG_RunLevelElts" minOccurs="0" maxOccurs="unbounded"/> + </xsd:choice> + </xsd:group> + <xsd:group name="EG_CellMarkupElements"> + <xsd:choice> + <xsd:element name="cellIns" type="CT_TrackChange" minOccurs="0"/> + <xsd:element name="cellDel" type="CT_TrackChange" minOccurs="0"/> + <xsd:element name="cellMerge" type="CT_CellMergeTrackChange" minOccurs="0"/> + </xsd:choice> + </xsd:group> + <xsd:group name="EG_RangeMarkupElements"> + <xsd:choice> + <xsd:element name="bookmarkStart" type="CT_Bookmark"/> + <xsd:element name="bookmarkEnd" type="CT_MarkupRange"/> + <xsd:element name="moveFromRangeStart" type="CT_MoveBookmark"/> + <xsd:element name="moveFromRangeEnd" type="CT_MarkupRange"/> + <xsd:element name="moveToRangeStart" type="CT_MoveBookmark"/> + <xsd:element name="moveToRangeEnd" type="CT_MarkupRange"/> + <xsd:element name="commentRangeStart" type="CT_MarkupRange"/> + <xsd:element name="commentRangeEnd" type="CT_MarkupRange"/> + <xsd:element name="customXmlInsRangeStart" type="CT_TrackChange"/> + <xsd:element name="customXmlInsRangeEnd" type="CT_Markup"/> + <xsd:element name="customXmlDelRangeStart" type="CT_TrackChange"/> + <xsd:element name="customXmlDelRangeEnd" type="CT_Markup"/> + <xsd:element name="customXmlMoveFromRangeStart" type="CT_TrackChange"/> + <xsd:element name="customXmlMoveFromRangeEnd" type="CT_Markup"/> + <xsd:element name="customXmlMoveToRangeStart" type="CT_TrackChange"/> + <xsd:element name="customXmlMoveToRangeEnd" type="CT_Markup"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_NumPr"> + <xsd:sequence> + <xsd:element name="ilvl" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="numId" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="numberingChange" type="CT_TrackChangeNumbering" minOccurs="0"/> + <xsd:element name="ins" type="CT_TrackChange" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_PBdr"> + <xsd:sequence> + <xsd:element name="top" type="CT_Border" minOccurs="0"/> + <xsd:element name="left" type="CT_Border" minOccurs="0"/> + <xsd:element name="bottom" type="CT_Border" minOccurs="0"/> + <xsd:element name="right" type="CT_Border" minOccurs="0"/> + <xsd:element name="between" type="CT_Border" minOccurs="0"/> + <xsd:element name="bar" type="CT_Border" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Tabs"> + <xsd:sequence> + <xsd:element name="tab" type="CT_TabStop" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_TextboxTightWrap"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="allLines"/> + <xsd:enumeration value="firstAndLastLine"/> + <xsd:enumeration value="firstLineOnly"/> + <xsd:enumeration value="lastLineOnly"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TextboxTightWrap"> + <xsd:attribute name="val" type="ST_TextboxTightWrap" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_PPrBase"> + <xsd:sequence> + <xsd:element name="pStyle" type="CT_String" minOccurs="0"/> + <xsd:element name="keepNext" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="keepLines" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="pageBreakBefore" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="framePr" type="CT_FramePr" minOccurs="0"/> + <xsd:element name="widowControl" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="numPr" type="CT_NumPr" minOccurs="0"/> + <xsd:element name="suppressLineNumbers" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="pBdr" type="CT_PBdr" minOccurs="0"/> + <xsd:element name="shd" type="CT_Shd" minOccurs="0"/> + <xsd:element name="tabs" type="CT_Tabs" minOccurs="0"/> + <xsd:element name="suppressAutoHyphens" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="kinsoku" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="wordWrap" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="overflowPunct" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="topLinePunct" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="autoSpaceDE" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="autoSpaceDN" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="bidi" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="adjustRightInd" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="snapToGrid" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="spacing" type="CT_Spacing" minOccurs="0"/> + <xsd:element name="ind" type="CT_Ind" minOccurs="0"/> + <xsd:element name="contextualSpacing" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="mirrorIndents" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="suppressOverlap" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="jc" type="CT_Jc" minOccurs="0"/> + <xsd:element name="textDirection" type="CT_TextDirection" minOccurs="0"/> + <xsd:element name="textAlignment" type="CT_TextAlignment" minOccurs="0"/> + <xsd:element name="textboxTightWrap" type="CT_TextboxTightWrap" minOccurs="0"/> + <xsd:element name="outlineLvl" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="divId" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="cnfStyle" type="CT_Cnf" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_PPr"> + <xsd:complexContent> + <xsd:extension base="CT_PPrBase"> + <xsd:sequence> + <xsd:element name="rPr" type="CT_ParaRPr" minOccurs="0"/> + <xsd:element name="sectPr" type="CT_SectPr" minOccurs="0"/> + <xsd:element name="pPrChange" type="CT_PPrChange" minOccurs="0"/> + </xsd:sequence> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_PPrGeneral"> + <xsd:complexContent> + <xsd:extension base="CT_PPrBase"> + <xsd:sequence> + <xsd:element name="pPrChange" type="CT_PPrChange" minOccurs="0"/> + </xsd:sequence> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_Control"> + <xsd:attribute name="name" type="s:ST_String" use="optional"/> + <xsd:attribute name="shapeid" type="s:ST_String" use="optional"/> + <xsd:attribute ref="r:id" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Background"> + <xsd:sequence> + <xsd:sequence maxOccurs="unbounded"> + <xsd:any processContents="lax" namespace="urn:schemas-microsoft-com:vml" minOccurs="0" + maxOccurs="unbounded"/> + <xsd:any processContents="lax" namespace="urn:schemas-microsoft-com:office:office" + minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:element name="drawing" type="CT_Drawing" minOccurs="0"/> + </xsd:sequence> + <xsd:attribute name="color" type="ST_HexColor" use="optional" default="auto"/> + <xsd:attribute name="themeColor" type="ST_ThemeColor" use="optional"/> + <xsd:attribute name="themeTint" type="ST_UcharHexNumber" use="optional"/> + <xsd:attribute name="themeShade" type="ST_UcharHexNumber" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Rel"> + <xsd:attribute ref="r:id" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Object"> + <xsd:sequence> + <xsd:sequence maxOccurs="unbounded"> + <xsd:any processContents="lax" namespace="urn:schemas-microsoft-com:vml" minOccurs="0" + maxOccurs="unbounded"/> + <xsd:any processContents="lax" namespace="urn:schemas-microsoft-com:office:office" + minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:element name="drawing" type="CT_Drawing" minOccurs="0"/> + <xsd:choice minOccurs="0"> + <xsd:element name="control" type="CT_Control"/> + <xsd:element name="objectLink" type="CT_ObjectLink"/> + <xsd:element name="objectEmbed" type="CT_ObjectEmbed"/> + <xsd:element name="movie" type="CT_Rel"/> + </xsd:choice> + </xsd:sequence> + <xsd:attribute name="dxaOrig" type="s:ST_TwipsMeasure" use="optional"/> + <xsd:attribute name="dyaOrig" type="s:ST_TwipsMeasure" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Picture"> + <xsd:sequence> + <xsd:sequence maxOccurs="unbounded"> + <xsd:any processContents="lax" namespace="urn:schemas-microsoft-com:vml" minOccurs="0" + maxOccurs="unbounded"/> + <xsd:any processContents="lax" namespace="urn:schemas-microsoft-com:office:office" + minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:element name="movie" type="CT_Rel" minOccurs="0"/> + <xsd:element name="control" type="CT_Control" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_ObjectEmbed"> + <xsd:attribute name="drawAspect" type="ST_ObjectDrawAspect" use="optional"/> + <xsd:attribute ref="r:id" use="required"/> + <xsd:attribute name="progId" type="s:ST_String" use="optional"/> + <xsd:attribute name="shapeId" type="s:ST_String" use="optional"/> + <xsd:attribute name="fieldCodes" type="s:ST_String" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_ObjectDrawAspect"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="content"/> + <xsd:enumeration value="icon"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_ObjectLink"> + <xsd:complexContent> + <xsd:extension base="CT_ObjectEmbed"> + <xsd:attribute name="updateMode" type="ST_ObjectUpdateMode" use="required"/> + <xsd:attribute name="lockedField" type="s:ST_OnOff" use="optional"/> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:simpleType name="ST_ObjectUpdateMode"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="always"/> + <xsd:enumeration value="onCall"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Drawing"> + <xsd:choice minOccurs="1" maxOccurs="unbounded"> + <xsd:element ref="wp:anchor" minOccurs="0"/> + <xsd:element ref="wp:inline" minOccurs="0"/> + </xsd:choice> + </xsd:complexType> + <xsd:complexType name="CT_SimpleField"> + <xsd:sequence> + <xsd:element name="fldData" type="CT_Text" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_PContent" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="instr" type="s:ST_String" use="required"/> + <xsd:attribute name="fldLock" type="s:ST_OnOff"/> + <xsd:attribute name="dirty" type="s:ST_OnOff"/> + </xsd:complexType> + <xsd:simpleType name="ST_FldCharType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="begin"/> + <xsd:enumeration value="separate"/> + <xsd:enumeration value="end"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_InfoTextType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="text"/> + <xsd:enumeration value="autoText"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_FFHelpTextVal"> + <xsd:restriction base="xsd:string"> + <xsd:maxLength value="256"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_FFStatusTextVal"> + <xsd:restriction base="xsd:string"> + <xsd:maxLength value="140"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_FFName"> + <xsd:restriction base="xsd:string"> + <xsd:maxLength value="65"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_FFTextType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="regular"/> + <xsd:enumeration value="number"/> + <xsd:enumeration value="date"/> + <xsd:enumeration value="currentTime"/> + <xsd:enumeration value="currentDate"/> + <xsd:enumeration value="calculated"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_FFTextType"> + <xsd:attribute name="val" type="ST_FFTextType" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_FFName"> + <xsd:attribute name="val" type="ST_FFName"/> + </xsd:complexType> + <xsd:complexType name="CT_FldChar"> + <xsd:choice> + <xsd:element name="fldData" type="CT_Text" minOccurs="0" maxOccurs="1"/> + <xsd:element name="ffData" type="CT_FFData" minOccurs="0" maxOccurs="1"/> + <xsd:element name="numberingChange" type="CT_TrackChangeNumbering" minOccurs="0"/> + </xsd:choice> + <xsd:attribute name="fldCharType" type="ST_FldCharType" use="required"/> + <xsd:attribute name="fldLock" type="s:ST_OnOff"/> + <xsd:attribute name="dirty" type="s:ST_OnOff"/> + </xsd:complexType> + <xsd:complexType name="CT_Hyperlink"> + <xsd:group ref="EG_PContent" minOccurs="0" maxOccurs="unbounded"/> + <xsd:attribute name="tgtFrame" type="s:ST_String" use="optional"/> + <xsd:attribute name="tooltip" type="s:ST_String" use="optional"/> + <xsd:attribute name="docLocation" type="s:ST_String" use="optional"/> + <xsd:attribute name="history" type="s:ST_OnOff" use="optional"/> + <xsd:attribute name="anchor" type="s:ST_String" use="optional"/> + <xsd:attribute ref="r:id"/> + </xsd:complexType> + <xsd:complexType name="CT_FFData"> + <xsd:choice maxOccurs="unbounded"> + <xsd:element name="name" type="CT_FFName"/> + <xsd:element name="label" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="tabIndex" type="CT_UnsignedDecimalNumber" minOccurs="0"/> + <xsd:element name="enabled" type="CT_OnOff"/> + <xsd:element name="calcOnExit" type="CT_OnOff"/> + <xsd:element name="entryMacro" type="CT_MacroName" minOccurs="0" maxOccurs="1"/> + <xsd:element name="exitMacro" type="CT_MacroName" minOccurs="0" maxOccurs="1"/> + <xsd:element name="helpText" type="CT_FFHelpText" minOccurs="0" maxOccurs="1"/> + <xsd:element name="statusText" type="CT_FFStatusText" minOccurs="0" maxOccurs="1"/> + <xsd:choice> + <xsd:element name="checkBox" type="CT_FFCheckBox"/> + <xsd:element name="ddList" type="CT_FFDDList"/> + <xsd:element name="textInput" type="CT_FFTextInput"/> + </xsd:choice> + </xsd:choice> + </xsd:complexType> + <xsd:complexType name="CT_FFHelpText"> + <xsd:attribute name="type" type="ST_InfoTextType"/> + <xsd:attribute name="val" type="ST_FFHelpTextVal"/> + </xsd:complexType> + <xsd:complexType name="CT_FFStatusText"> + <xsd:attribute name="type" type="ST_InfoTextType"/> + <xsd:attribute name="val" type="ST_FFStatusTextVal"/> + </xsd:complexType> + <xsd:complexType name="CT_FFCheckBox"> + <xsd:sequence> + <xsd:choice> + <xsd:element name="size" type="CT_HpsMeasure"/> + <xsd:element name="sizeAuto" type="CT_OnOff"/> + </xsd:choice> + <xsd:element name="default" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="checked" type="CT_OnOff" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_FFDDList"> + <xsd:sequence> + <xsd:element name="result" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="default" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="listEntry" type="CT_String" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_FFTextInput"> + <xsd:sequence> + <xsd:element name="type" type="CT_FFTextType" minOccurs="0"/> + <xsd:element name="default" type="CT_String" minOccurs="0"/> + <xsd:element name="maxLength" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="format" type="CT_String" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_SectionMark"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="nextPage"/> + <xsd:enumeration value="nextColumn"/> + <xsd:enumeration value="continuous"/> + <xsd:enumeration value="evenPage"/> + <xsd:enumeration value="oddPage"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_SectType"> + <xsd:attribute name="val" type="ST_SectionMark"/> + </xsd:complexType> + <xsd:complexType name="CT_PaperSource"> + <xsd:attribute name="first" type="ST_DecimalNumber"/> + <xsd:attribute name="other" type="ST_DecimalNumber"/> + </xsd:complexType> + <xsd:simpleType name="ST_NumberFormat"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="decimal"/> + <xsd:enumeration value="upperRoman"/> + <xsd:enumeration value="lowerRoman"/> + <xsd:enumeration value="upperLetter"/> + <xsd:enumeration value="lowerLetter"/> + <xsd:enumeration value="ordinal"/> + <xsd:enumeration value="cardinalText"/> + <xsd:enumeration value="ordinalText"/> + <xsd:enumeration value="hex"/> + <xsd:enumeration value="chicago"/> + <xsd:enumeration value="ideographDigital"/> + <xsd:enumeration value="japaneseCounting"/> + <xsd:enumeration value="aiueo"/> + <xsd:enumeration value="iroha"/> + <xsd:enumeration value="decimalFullWidth"/> + <xsd:enumeration value="decimalHalfWidth"/> + <xsd:enumeration value="japaneseLegal"/> + <xsd:enumeration value="japaneseDigitalTenThousand"/> + <xsd:enumeration value="decimalEnclosedCircle"/> + <xsd:enumeration value="decimalFullWidth2"/> + <xsd:enumeration value="aiueoFullWidth"/> + <xsd:enumeration value="irohaFullWidth"/> + <xsd:enumeration value="decimalZero"/> + <xsd:enumeration value="bullet"/> + <xsd:enumeration value="ganada"/> + <xsd:enumeration value="chosung"/> + <xsd:enumeration value="decimalEnclosedFullstop"/> + <xsd:enumeration value="decimalEnclosedParen"/> + <xsd:enumeration value="decimalEnclosedCircleChinese"/> + <xsd:enumeration value="ideographEnclosedCircle"/> + <xsd:enumeration value="ideographTraditional"/> + <xsd:enumeration value="ideographZodiac"/> + <xsd:enumeration value="ideographZodiacTraditional"/> + <xsd:enumeration value="taiwaneseCounting"/> + <xsd:enumeration value="ideographLegalTraditional"/> + <xsd:enumeration value="taiwaneseCountingThousand"/> + <xsd:enumeration value="taiwaneseDigital"/> + <xsd:enumeration value="chineseCounting"/> + <xsd:enumeration value="chineseLegalSimplified"/> + <xsd:enumeration value="chineseCountingThousand"/> + <xsd:enumeration value="koreanDigital"/> + <xsd:enumeration value="koreanCounting"/> + <xsd:enumeration value="koreanLegal"/> + <xsd:enumeration value="koreanDigital2"/> + <xsd:enumeration value="vietnameseCounting"/> + <xsd:enumeration value="russianLower"/> + <xsd:enumeration value="russianUpper"/> + <xsd:enumeration value="none"/> + <xsd:enumeration value="numberInDash"/> + <xsd:enumeration value="hebrew1"/> + <xsd:enumeration value="hebrew2"/> + <xsd:enumeration value="arabicAlpha"/> + <xsd:enumeration value="arabicAbjad"/> + <xsd:enumeration value="hindiVowels"/> + <xsd:enumeration value="hindiConsonants"/> + <xsd:enumeration value="hindiNumbers"/> + <xsd:enumeration value="hindiCounting"/> + <xsd:enumeration value="thaiLetters"/> + <xsd:enumeration value="thaiNumbers"/> + <xsd:enumeration value="thaiCounting"/> + <xsd:enumeration value="bahtText"/> + <xsd:enumeration value="dollarText"/> + <xsd:enumeration value="custom"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_PageOrientation"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="portrait"/> + <xsd:enumeration value="landscape"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_PageSz"> + <xsd:attribute name="w" type="s:ST_TwipsMeasure"/> + <xsd:attribute name="h" type="s:ST_TwipsMeasure"/> + <xsd:attribute name="orient" type="ST_PageOrientation" use="optional"/> + <xsd:attribute name="code" type="ST_DecimalNumber" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_PageMar"> + <xsd:attribute name="top" type="ST_SignedTwipsMeasure" use="required"/> + <xsd:attribute name="right" type="s:ST_TwipsMeasure" use="required"/> + <xsd:attribute name="bottom" type="ST_SignedTwipsMeasure" use="required"/> + <xsd:attribute name="left" type="s:ST_TwipsMeasure" use="required"/> + <xsd:attribute name="header" type="s:ST_TwipsMeasure" use="required"/> + <xsd:attribute name="footer" type="s:ST_TwipsMeasure" use="required"/> + <xsd:attribute name="gutter" type="s:ST_TwipsMeasure" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_PageBorderZOrder"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="front"/> + <xsd:enumeration value="back"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_PageBorderDisplay"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="allPages"/> + <xsd:enumeration value="firstPage"/> + <xsd:enumeration value="notFirstPage"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_PageBorderOffset"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="page"/> + <xsd:enumeration value="text"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_PageBorders"> + <xsd:sequence> + <xsd:element name="top" type="CT_TopPageBorder" minOccurs="0"/> + <xsd:element name="left" type="CT_PageBorder" minOccurs="0"/> + <xsd:element name="bottom" type="CT_BottomPageBorder" minOccurs="0"/> + <xsd:element name="right" type="CT_PageBorder" minOccurs="0"/> + </xsd:sequence> + <xsd:attribute name="zOrder" type="ST_PageBorderZOrder" use="optional" default="front"/> + <xsd:attribute name="display" type="ST_PageBorderDisplay" use="optional"/> + <xsd:attribute name="offsetFrom" type="ST_PageBorderOffset" use="optional" default="text"/> + </xsd:complexType> + <xsd:complexType name="CT_PageBorder"> + <xsd:complexContent> + <xsd:extension base="CT_Border"> + <xsd:attribute ref="r:id" use="optional"/> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_BottomPageBorder"> + <xsd:complexContent> + <xsd:extension base="CT_PageBorder"> + <xsd:attribute ref="r:bottomLeft" use="optional"/> + <xsd:attribute ref="r:bottomRight" use="optional"/> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_TopPageBorder"> + <xsd:complexContent> + <xsd:extension base="CT_PageBorder"> + <xsd:attribute ref="r:topLeft" use="optional"/> + <xsd:attribute ref="r:topRight" use="optional"/> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:simpleType name="ST_ChapterSep"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="hyphen"/> + <xsd:enumeration value="period"/> + <xsd:enumeration value="colon"/> + <xsd:enumeration value="emDash"/> + <xsd:enumeration value="enDash"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_LineNumberRestart"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="newPage"/> + <xsd:enumeration value="newSection"/> + <xsd:enumeration value="continuous"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_LineNumber"> + <xsd:attribute name="countBy" type="ST_DecimalNumber" use="optional"/> + <xsd:attribute name="start" type="ST_DecimalNumber" use="optional" default="1"/> + <xsd:attribute name="distance" type="s:ST_TwipsMeasure" use="optional"/> + <xsd:attribute name="restart" type="ST_LineNumberRestart" use="optional" default="newPage"/> + </xsd:complexType> + <xsd:complexType name="CT_PageNumber"> + <xsd:attribute name="fmt" type="ST_NumberFormat" use="optional" default="decimal"/> + <xsd:attribute name="start" type="ST_DecimalNumber" use="optional"/> + <xsd:attribute name="chapStyle" type="ST_DecimalNumber" use="optional"/> + <xsd:attribute name="chapSep" type="ST_ChapterSep" use="optional" default="hyphen"/> + </xsd:complexType> + <xsd:complexType name="CT_Column"> + <xsd:attribute name="w" type="s:ST_TwipsMeasure" use="optional"/> + <xsd:attribute name="space" type="s:ST_TwipsMeasure" use="optional" default="0"/> + </xsd:complexType> + <xsd:complexType name="CT_Columns"> + <xsd:sequence minOccurs="0"> + <xsd:element name="col" type="CT_Column" maxOccurs="45"/> + </xsd:sequence> + <xsd:attribute name="equalWidth" type="s:ST_OnOff" use="optional"/> + <xsd:attribute name="space" type="s:ST_TwipsMeasure" use="optional" default="720"/> + <xsd:attribute name="num" type="ST_DecimalNumber" use="optional" default="1"/> + <xsd:attribute name="sep" type="s:ST_OnOff" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_VerticalJc"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="top"/> + <xsd:enumeration value="center"/> + <xsd:enumeration value="both"/> + <xsd:enumeration value="bottom"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_VerticalJc"> + <xsd:attribute name="val" type="ST_VerticalJc" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_DocGrid"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="default"/> + <xsd:enumeration value="lines"/> + <xsd:enumeration value="linesAndChars"/> + <xsd:enumeration value="snapToChars"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_DocGrid"> + <xsd:attribute name="type" type="ST_DocGrid"/> + <xsd:attribute name="linePitch" type="ST_DecimalNumber"/> + <xsd:attribute name="charSpace" type="ST_DecimalNumber"/> + </xsd:complexType> + <xsd:simpleType name="ST_HdrFtr"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="even"/> + <xsd:enumeration value="default"/> + <xsd:enumeration value="first"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_FtnEdn"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="normal"/> + <xsd:enumeration value="separator"/> + <xsd:enumeration value="continuationSeparator"/> + <xsd:enumeration value="continuationNotice"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_HdrFtrRef"> + <xsd:complexContent> + <xsd:extension base="CT_Rel"> + <xsd:attribute name="type" type="ST_HdrFtr" use="required"/> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:group name="EG_HdrFtrReferences"> + <xsd:choice> + <xsd:element name="headerReference" type="CT_HdrFtrRef" minOccurs="0"/> + <xsd:element name="footerReference" type="CT_HdrFtrRef" minOccurs="0"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_HdrFtr"> + <xsd:group ref="EG_BlockLevelElts" minOccurs="1" maxOccurs="unbounded"/> + </xsd:complexType> + <xsd:group name="EG_SectPrContents"> + <xsd:sequence> + <xsd:element name="footnotePr" type="CT_FtnProps" minOccurs="0"/> + <xsd:element name="endnotePr" type="CT_EdnProps" minOccurs="0"/> + <xsd:element name="type" type="CT_SectType" minOccurs="0"/> + <xsd:element name="pgSz" type="CT_PageSz" minOccurs="0"/> + <xsd:element name="pgMar" type="CT_PageMar" minOccurs="0"/> + <xsd:element name="paperSrc" type="CT_PaperSource" minOccurs="0"/> + <xsd:element name="pgBorders" type="CT_PageBorders" minOccurs="0"/> + <xsd:element name="lnNumType" type="CT_LineNumber" minOccurs="0"/> + <xsd:element name="pgNumType" type="CT_PageNumber" minOccurs="0"/> + <xsd:element name="cols" type="CT_Columns" minOccurs="0"/> + <xsd:element name="formProt" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="vAlign" type="CT_VerticalJc" minOccurs="0"/> + <xsd:element name="noEndnote" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="titlePg" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="textDirection" type="CT_TextDirection" minOccurs="0"/> + <xsd:element name="bidi" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="rtlGutter" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="docGrid" type="CT_DocGrid" minOccurs="0"/> + <xsd:element name="printerSettings" type="CT_Rel" minOccurs="0"/> + </xsd:sequence> + </xsd:group> + <xsd:attributeGroup name="AG_SectPrAttributes"> + <xsd:attribute name="rsidRPr" type="ST_LongHexNumber"/> + <xsd:attribute name="rsidDel" type="ST_LongHexNumber"/> + <xsd:attribute name="rsidR" type="ST_LongHexNumber"/> + <xsd:attribute name="rsidSect" type="ST_LongHexNumber"/> + </xsd:attributeGroup> + <xsd:complexType name="CT_SectPrBase"> + <xsd:sequence> + <xsd:group ref="EG_SectPrContents" minOccurs="0"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_SectPrAttributes"/> + </xsd:complexType> + <xsd:complexType name="CT_SectPr"> + <xsd:sequence> + <xsd:group ref="EG_HdrFtrReferences" minOccurs="0" maxOccurs="6"/> + <xsd:group ref="EG_SectPrContents" minOccurs="0"/> + <xsd:element name="sectPrChange" type="CT_SectPrChange" minOccurs="0"/> + </xsd:sequence> + <xsd:attributeGroup ref="AG_SectPrAttributes"/> + </xsd:complexType> + <xsd:simpleType name="ST_BrType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="page"/> + <xsd:enumeration value="column"/> + <xsd:enumeration value="textWrapping"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_BrClear"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="left"/> + <xsd:enumeration value="right"/> + <xsd:enumeration value="all"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Br"> + <xsd:attribute name="type" type="ST_BrType" use="optional"/> + <xsd:attribute name="clear" type="ST_BrClear" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_PTabAlignment"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="left"/> + <xsd:enumeration value="center"/> + <xsd:enumeration value="right"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_PTabRelativeTo"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="margin"/> + <xsd:enumeration value="indent"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_PTabLeader"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="dot"/> + <xsd:enumeration value="hyphen"/> + <xsd:enumeration value="underscore"/> + <xsd:enumeration value="middleDot"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_PTab"> + <xsd:attribute name="alignment" type="ST_PTabAlignment" use="required"/> + <xsd:attribute name="relativeTo" type="ST_PTabRelativeTo" use="required"/> + <xsd:attribute name="leader" type="ST_PTabLeader" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Sym"> + <xsd:attribute name="font" type="s:ST_String"/> + <xsd:attribute name="char" type="ST_ShortHexNumber"/> + </xsd:complexType> + <xsd:simpleType name="ST_ProofErr"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="spellStart"/> + <xsd:enumeration value="spellEnd"/> + <xsd:enumeration value="gramStart"/> + <xsd:enumeration value="gramEnd"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_ProofErr"> + <xsd:attribute name="type" type="ST_ProofErr" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_EdGrp"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="everyone"/> + <xsd:enumeration value="administrators"/> + <xsd:enumeration value="contributors"/> + <xsd:enumeration value="editors"/> + <xsd:enumeration value="owners"/> + <xsd:enumeration value="current"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Perm"> + <xsd:attribute name="id" type="s:ST_String" use="required"/> + <xsd:attribute name="displacedByCustomXml" type="ST_DisplacedByCustomXml" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_PermStart"> + <xsd:complexContent> + <xsd:extension base="CT_Perm"> + <xsd:attribute name="edGrp" type="ST_EdGrp" use="optional"/> + <xsd:attribute name="ed" type="s:ST_String" use="optional"/> + <xsd:attribute name="colFirst" type="ST_DecimalNumber" use="optional"/> + <xsd:attribute name="colLast" type="ST_DecimalNumber" use="optional"/> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_Text"> + <xsd:simpleContent> + <xsd:extension base="s:ST_String"> + <xsd:attribute ref="xml:space" use="optional"/> + </xsd:extension> + </xsd:simpleContent> + </xsd:complexType> + <xsd:group name="EG_RunInnerContent"> + <xsd:choice> + <xsd:element name="br" type="CT_Br"/> + <xsd:element name="t" type="CT_Text"/> + <xsd:element name="contentPart" type="CT_Rel"/> + <xsd:element name="delText" type="CT_Text"/> + <xsd:element name="instrText" type="CT_Text"/> + <xsd:element name="delInstrText" type="CT_Text"/> + <xsd:element name="noBreakHyphen" type="CT_Empty"/> + <xsd:element name="softHyphen" type="CT_Empty" minOccurs="0"/> + <xsd:element name="dayShort" type="CT_Empty" minOccurs="0"/> + <xsd:element name="monthShort" type="CT_Empty" minOccurs="0"/> + <xsd:element name="yearShort" type="CT_Empty" minOccurs="0"/> + <xsd:element name="dayLong" type="CT_Empty" minOccurs="0"/> + <xsd:element name="monthLong" type="CT_Empty" minOccurs="0"/> + <xsd:element name="yearLong" type="CT_Empty" minOccurs="0"/> + <xsd:element name="annotationRef" type="CT_Empty" minOccurs="0"/> + <xsd:element name="footnoteRef" type="CT_Empty" minOccurs="0"/> + <xsd:element name="endnoteRef" type="CT_Empty" minOccurs="0"/> + <xsd:element name="separator" type="CT_Empty" minOccurs="0"/> + <xsd:element name="continuationSeparator" type="CT_Empty" minOccurs="0"/> + <xsd:element name="sym" type="CT_Sym" minOccurs="0"/> + <xsd:element name="pgNum" type="CT_Empty" minOccurs="0"/> + <xsd:element name="cr" type="CT_Empty" minOccurs="0"/> + <xsd:element name="tab" type="CT_Empty" minOccurs="0"/> + <xsd:element name="object" type="CT_Object"/> + <xsd:element name="pict" type="CT_Picture"/> + <xsd:element name="fldChar" type="CT_FldChar"/> + <xsd:element name="ruby" type="CT_Ruby"/> + <xsd:element name="footnoteReference" type="CT_FtnEdnRef"/> + <xsd:element name="endnoteReference" type="CT_FtnEdnRef"/> + <xsd:element name="commentReference" type="CT_Markup"/> + <xsd:element name="drawing" type="CT_Drawing"/> + <xsd:element name="ptab" type="CT_PTab" minOccurs="0"/> + <xsd:element name="lastRenderedPageBreak" type="CT_Empty" minOccurs="0" maxOccurs="1"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_R"> + <xsd:sequence> + <xsd:group ref="EG_RPr" minOccurs="0"/> + <xsd:group ref="EG_RunInnerContent" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="rsidRPr" type="ST_LongHexNumber"/> + <xsd:attribute name="rsidDel" type="ST_LongHexNumber"/> + <xsd:attribute name="rsidR" type="ST_LongHexNumber"/> + </xsd:complexType> + <xsd:simpleType name="ST_Hint"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="default"/> + <xsd:enumeration value="eastAsia"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_Theme"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="majorEastAsia"/> + <xsd:enumeration value="majorBidi"/> + <xsd:enumeration value="majorAscii"/> + <xsd:enumeration value="majorHAnsi"/> + <xsd:enumeration value="minorEastAsia"/> + <xsd:enumeration value="minorBidi"/> + <xsd:enumeration value="minorAscii"/> + <xsd:enumeration value="minorHAnsi"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Fonts"> + <xsd:attribute name="hint" type="ST_Hint"/> + <xsd:attribute name="ascii" type="s:ST_String"/> + <xsd:attribute name="hAnsi" type="s:ST_String"/> + <xsd:attribute name="eastAsia" type="s:ST_String"/> + <xsd:attribute name="cs" type="s:ST_String"/> + <xsd:attribute name="asciiTheme" type="ST_Theme"/> + <xsd:attribute name="hAnsiTheme" type="ST_Theme"/> + <xsd:attribute name="eastAsiaTheme" type="ST_Theme"/> + <xsd:attribute name="cstheme" type="ST_Theme"/> + </xsd:complexType> + <xsd:group name="EG_RPrBase"> + <xsd:choice> + <xsd:element name="rStyle" type="CT_String"/> + <xsd:element name="rFonts" type="CT_Fonts"/> + <xsd:element name="b" type="CT_OnOff"/> + <xsd:element name="bCs" type="CT_OnOff"/> + <xsd:element name="i" type="CT_OnOff"/> + <xsd:element name="iCs" type="CT_OnOff"/> + <xsd:element name="caps" type="CT_OnOff"/> + <xsd:element name="smallCaps" type="CT_OnOff"/> + <xsd:element name="strike" type="CT_OnOff"/> + <xsd:element name="dstrike" type="CT_OnOff"/> + <xsd:element name="outline" type="CT_OnOff"/> + <xsd:element name="shadow" type="CT_OnOff"/> + <xsd:element name="emboss" type="CT_OnOff"/> + <xsd:element name="imprint" type="CT_OnOff"/> + <xsd:element name="noProof" type="CT_OnOff"/> + <xsd:element name="snapToGrid" type="CT_OnOff"/> + <xsd:element name="vanish" type="CT_OnOff"/> + <xsd:element name="webHidden" type="CT_OnOff"/> + <xsd:element name="color" type="CT_Color"/> + <xsd:element name="spacing" type="CT_SignedTwipsMeasure"/> + <xsd:element name="w" type="CT_TextScale"/> + <xsd:element name="kern" type="CT_HpsMeasure"/> + <xsd:element name="position" type="CT_SignedHpsMeasure"/> + <xsd:element name="sz" type="CT_HpsMeasure"/> + <xsd:element name="szCs" type="CT_HpsMeasure"/> + <xsd:element name="highlight" type="CT_Highlight"/> + <xsd:element name="u" type="CT_Underline"/> + <xsd:element name="effect" type="CT_TextEffect"/> + <xsd:element name="bdr" type="CT_Border"/> + <xsd:element name="shd" type="CT_Shd"/> + <xsd:element name="fitText" type="CT_FitText"/> + <xsd:element name="vertAlign" type="CT_VerticalAlignRun"/> + <xsd:element name="rtl" type="CT_OnOff"/> + <xsd:element name="cs" type="CT_OnOff"/> + <xsd:element name="em" type="CT_Em"/> + <xsd:element name="lang" type="CT_Language"/> + <xsd:element name="eastAsianLayout" type="CT_EastAsianLayout"/> + <xsd:element name="specVanish" type="CT_OnOff"/> + <xsd:element name="oMath" type="CT_OnOff"/> + </xsd:choice> + </xsd:group> + <xsd:group name="EG_RPrContent"> + <xsd:sequence> + <xsd:group ref="EG_RPrBase" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="rPrChange" type="CT_RPrChange" minOccurs="0"/> + </xsd:sequence> + </xsd:group> + <xsd:complexType name="CT_RPr"> + <xsd:sequence> + <xsd:group ref="EG_RPrContent" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:group name="EG_RPr"> + <xsd:sequence> + <xsd:element name="rPr" type="CT_RPr" minOccurs="0"/> + </xsd:sequence> + </xsd:group> + <xsd:group name="EG_RPrMath"> + <xsd:choice> + <xsd:group ref="EG_RPr"/> + <xsd:element name="ins" type="CT_MathCtrlIns"/> + <xsd:element name="del" type="CT_MathCtrlDel"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_MathCtrlIns"> + <xsd:complexContent> + <xsd:extension base="CT_TrackChange"> + <xsd:choice minOccurs="0"> + <xsd:element name="del" type="CT_RPrChange" minOccurs="1"/> + <xsd:element name="rPr" type="CT_RPr" minOccurs="1"/> + </xsd:choice> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_MathCtrlDel"> + <xsd:complexContent> + <xsd:extension base="CT_TrackChange"> + <xsd:choice minOccurs="0"> + <xsd:element name="rPr" type="CT_RPr" minOccurs="1"/> + </xsd:choice> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_RPrOriginal"> + <xsd:sequence> + <xsd:group ref="EG_RPrBase" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_ParaRPrOriginal"> + <xsd:sequence> + <xsd:group ref="EG_ParaRPrTrackChanges" minOccurs="0"/> + <xsd:group ref="EG_RPrBase" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_ParaRPr"> + <xsd:sequence> + <xsd:group ref="EG_ParaRPrTrackChanges" minOccurs="0"/> + <xsd:group ref="EG_RPrBase" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="rPrChange" type="CT_ParaRPrChange" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:group name="EG_ParaRPrTrackChanges"> + <xsd:sequence> + <xsd:element name="ins" type="CT_TrackChange" minOccurs="0"/> + <xsd:element name="del" type="CT_TrackChange" minOccurs="0"/> + <xsd:element name="moveFrom" type="CT_TrackChange" minOccurs="0"/> + <xsd:element name="moveTo" type="CT_TrackChange" minOccurs="0"/> + </xsd:sequence> + </xsd:group> + <xsd:complexType name="CT_AltChunk"> + <xsd:sequence> + <xsd:element name="altChunkPr" type="CT_AltChunkPr" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute ref="r:id" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_AltChunkPr"> + <xsd:sequence> + <xsd:element name="matchSrc" type="CT_OnOff" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_RubyAlign"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="center"/> + <xsd:enumeration value="distributeLetter"/> + <xsd:enumeration value="distributeSpace"/> + <xsd:enumeration value="left"/> + <xsd:enumeration value="right"/> + <xsd:enumeration value="rightVertical"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_RubyAlign"> + <xsd:attribute name="val" type="ST_RubyAlign" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_RubyPr"> + <xsd:sequence> + <xsd:element name="rubyAlign" type="CT_RubyAlign"/> + <xsd:element name="hps" type="CT_HpsMeasure"/> + <xsd:element name="hpsRaise" type="CT_HpsMeasure"/> + <xsd:element name="hpsBaseText" type="CT_HpsMeasure"/> + <xsd:element name="lid" type="CT_Lang"/> + <xsd:element name="dirty" type="CT_OnOff" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:group name="EG_RubyContent"> + <xsd:choice> + <xsd:element name="r" type="CT_R"/> + <xsd:group ref="EG_RunLevelElts" minOccurs="0" maxOccurs="unbounded"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_RubyContent"> + <xsd:group ref="EG_RubyContent" minOccurs="0" maxOccurs="unbounded"/> + </xsd:complexType> + <xsd:complexType name="CT_Ruby"> + <xsd:sequence> + <xsd:element name="rubyPr" type="CT_RubyPr"/> + <xsd:element name="rt" type="CT_RubyContent"/> + <xsd:element name="rubyBase" type="CT_RubyContent"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_Lock"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="sdtLocked"/> + <xsd:enumeration value="contentLocked"/> + <xsd:enumeration value="unlocked"/> + <xsd:enumeration value="sdtContentLocked"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Lock"> + <xsd:attribute name="val" type="ST_Lock"/> + </xsd:complexType> + <xsd:complexType name="CT_SdtListItem"> + <xsd:attribute name="displayText" type="s:ST_String"/> + <xsd:attribute name="value" type="s:ST_String"/> + </xsd:complexType> + <xsd:simpleType name="ST_SdtDateMappingType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="text"/> + <xsd:enumeration value="date"/> + <xsd:enumeration value="dateTime"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_SdtDateMappingType"> + <xsd:attribute name="val" type="ST_SdtDateMappingType"/> + </xsd:complexType> + <xsd:complexType name="CT_CalendarType"> + <xsd:attribute name="val" type="s:ST_CalendarType"/> + </xsd:complexType> + <xsd:complexType name="CT_SdtDate"> + <xsd:sequence> + <xsd:element name="dateFormat" type="CT_String" minOccurs="0"/> + <xsd:element name="lid" type="CT_Lang" minOccurs="0"/> + <xsd:element name="storeMappedDataAs" type="CT_SdtDateMappingType" minOccurs="0"/> + <xsd:element name="calendar" type="CT_CalendarType" minOccurs="0"/> + </xsd:sequence> + <xsd:attribute name="fullDate" type="ST_DateTime" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_SdtComboBox"> + <xsd:sequence> + <xsd:element name="listItem" type="CT_SdtListItem" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="lastValue" type="s:ST_String" use="optional" default=""/> + </xsd:complexType> + <xsd:complexType name="CT_SdtDocPart"> + <xsd:sequence> + <xsd:element name="docPartGallery" type="CT_String" minOccurs="0"/> + <xsd:element name="docPartCategory" type="CT_String" minOccurs="0"/> + <xsd:element name="docPartUnique" type="CT_OnOff" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SdtDropDownList"> + <xsd:sequence> + <xsd:element name="listItem" type="CT_SdtListItem" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="lastValue" type="s:ST_String" use="optional" default=""/> + </xsd:complexType> + <xsd:complexType name="CT_Placeholder"> + <xsd:sequence> + <xsd:element name="docPart" type="CT_String"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SdtText"> + <xsd:attribute name="multiLine" type="s:ST_OnOff"/> + </xsd:complexType> + <xsd:complexType name="CT_DataBinding"> + <xsd:attribute name="prefixMappings" type="s:ST_String"/> + <xsd:attribute name="xpath" type="s:ST_String" use="required"/> + <xsd:attribute name="storeItemID" type="s:ST_String" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_SdtPr"> + <xsd:sequence> + <xsd:element name="rPr" type="CT_RPr" minOccurs="0"/> + <xsd:element name="alias" type="CT_String" minOccurs="0"/> + <xsd:element name="tag" type="CT_String" minOccurs="0"/> + <xsd:element name="id" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="lock" type="CT_Lock" minOccurs="0"/> + <xsd:element name="placeholder" type="CT_Placeholder" minOccurs="0"/> + <xsd:element name="temporary" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="showingPlcHdr" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="dataBinding" type="CT_DataBinding" minOccurs="0"/> + <xsd:element name="label" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="tabIndex" type="CT_UnsignedDecimalNumber" minOccurs="0"/> + <xsd:choice minOccurs="0" maxOccurs="1"> + <xsd:element name="equation" type="CT_Empty"/> + <xsd:element name="comboBox" type="CT_SdtComboBox"/> + <xsd:element name="date" type="CT_SdtDate"/> + <xsd:element name="docPartObj" type="CT_SdtDocPart"/> + <xsd:element name="docPartList" type="CT_SdtDocPart"/> + <xsd:element name="dropDownList" type="CT_SdtDropDownList"/> + <xsd:element name="picture" type="CT_Empty"/> + <xsd:element name="richText" type="CT_Empty"/> + <xsd:element name="text" type="CT_SdtText"/> + <xsd:element name="citation" type="CT_Empty"/> + <xsd:element name="group" type="CT_Empty"/> + <xsd:element name="bibliography" type="CT_Empty"/> + </xsd:choice> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SdtEndPr"> + <xsd:choice maxOccurs="unbounded"> + <xsd:element name="rPr" type="CT_RPr" minOccurs="0"/> + </xsd:choice> + </xsd:complexType> + <xsd:group name="EG_ContentRunContent"> + <xsd:choice> + <xsd:element name="customXml" type="CT_CustomXmlRun"/> + <xsd:element name="smartTag" type="CT_SmartTagRun"/> + <xsd:element name="sdt" type="CT_SdtRun"/> + <xsd:element name="dir" type="CT_DirContentRun"/> + <xsd:element name="bdo" type="CT_BdoContentRun"/> + <xsd:element name="r" type="CT_R"/> + <xsd:group ref="EG_RunLevelElts" minOccurs="0" maxOccurs="unbounded"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_DirContentRun"> + <xsd:group ref="EG_PContent" minOccurs="0" maxOccurs="unbounded"/> + <xsd:attribute name="val" type="ST_Direction" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_BdoContentRun"> + <xsd:group ref="EG_PContent" minOccurs="0" maxOccurs="unbounded"/> + <xsd:attribute name="val" type="ST_Direction" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_Direction"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="ltr"/> + <xsd:enumeration value="rtl"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_SdtContentRun"> + <xsd:group ref="EG_PContent" minOccurs="0" maxOccurs="unbounded"/> + </xsd:complexType> + <xsd:group name="EG_ContentBlockContent"> + <xsd:choice> + <xsd:element name="customXml" type="CT_CustomXmlBlock"/> + <xsd:element name="sdt" type="CT_SdtBlock"/> + <xsd:element name="p" type="CT_P" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="tbl" type="CT_Tbl" minOccurs="0" maxOccurs="unbounded"/> + <xsd:group ref="EG_RunLevelElts" minOccurs="0" maxOccurs="unbounded"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_SdtContentBlock"> + <xsd:group ref="EG_ContentBlockContent" minOccurs="0" maxOccurs="unbounded"/> + </xsd:complexType> + <xsd:group name="EG_ContentRowContent"> + <xsd:choice> + <xsd:element name="tr" type="CT_Row" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="customXml" type="CT_CustomXmlRow"/> + <xsd:element name="sdt" type="CT_SdtRow"/> + <xsd:group ref="EG_RunLevelElts" minOccurs="0" maxOccurs="unbounded"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_SdtContentRow"> + <xsd:group ref="EG_ContentRowContent" minOccurs="0" maxOccurs="unbounded"/> + </xsd:complexType> + <xsd:group name="EG_ContentCellContent"> + <xsd:choice> + <xsd:element name="tc" type="CT_Tc" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="customXml" type="CT_CustomXmlCell"/> + <xsd:element name="sdt" type="CT_SdtCell"/> + <xsd:group ref="EG_RunLevelElts" minOccurs="0" maxOccurs="unbounded"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_SdtContentCell"> + <xsd:group ref="EG_ContentCellContent" minOccurs="0" maxOccurs="unbounded"/> + </xsd:complexType> + <xsd:complexType name="CT_SdtBlock"> + <xsd:sequence> + <xsd:element name="sdtPr" type="CT_SdtPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sdtEndPr" type="CT_SdtEndPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sdtContent" type="CT_SdtContentBlock" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SdtRun"> + <xsd:sequence> + <xsd:element name="sdtPr" type="CT_SdtPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sdtEndPr" type="CT_SdtEndPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sdtContent" type="CT_SdtContentRun" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SdtCell"> + <xsd:sequence> + <xsd:element name="sdtPr" type="CT_SdtPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sdtEndPr" type="CT_SdtEndPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sdtContent" type="CT_SdtContentCell" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_SdtRow"> + <xsd:sequence> + <xsd:element name="sdtPr" type="CT_SdtPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sdtEndPr" type="CT_SdtEndPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sdtContent" type="CT_SdtContentRow" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Attr"> + <xsd:attribute name="uri" type="s:ST_String"/> + <xsd:attribute name="name" type="s:ST_String" use="required"/> + <xsd:attribute name="val" type="s:ST_String" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_CustomXmlRun"> + <xsd:sequence> + <xsd:element name="customXmlPr" type="CT_CustomXmlPr" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_PContent" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="uri" type="s:ST_String"/> + <xsd:attribute name="element" type="s:ST_XmlName" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_SmartTagRun"> + <xsd:sequence> + <xsd:element name="smartTagPr" type="CT_SmartTagPr" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_PContent" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="uri" type="s:ST_String"/> + <xsd:attribute name="element" type="s:ST_XmlName" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_CustomXmlBlock"> + <xsd:sequence> + <xsd:element name="customXmlPr" type="CT_CustomXmlPr" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_ContentBlockContent" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="uri" type="s:ST_String"/> + <xsd:attribute name="element" type="s:ST_XmlName" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_CustomXmlPr"> + <xsd:sequence> + <xsd:element name="placeholder" type="CT_String" minOccurs="0"/> + <xsd:element name="attr" type="CT_Attr" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_CustomXmlRow"> + <xsd:sequence> + <xsd:element name="customXmlPr" type="CT_CustomXmlPr" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_ContentRowContent" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="uri" type="s:ST_String"/> + <xsd:attribute name="element" type="s:ST_XmlName" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_CustomXmlCell"> + <xsd:sequence> + <xsd:element name="customXmlPr" type="CT_CustomXmlPr" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_ContentCellContent" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="uri" type="s:ST_String"/> + <xsd:attribute name="element" type="s:ST_XmlName" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_SmartTagPr"> + <xsd:sequence> + <xsd:element name="attr" type="CT_Attr" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:group name="EG_PContent"> + <xsd:choice> + <xsd:group ref="EG_ContentRunContent" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="fldSimple" type="CT_SimpleField" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="hyperlink" type="CT_Hyperlink"/> + <xsd:element name="subDoc" type="CT_Rel"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_P"> + <xsd:sequence> + <xsd:element name="pPr" type="CT_PPr" minOccurs="0"/> + <xsd:group ref="EG_PContent" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="rsidRPr" type="ST_LongHexNumber"/> + <xsd:attribute name="rsidR" type="ST_LongHexNumber"/> + <xsd:attribute name="rsidDel" type="ST_LongHexNumber"/> + <xsd:attribute name="rsidP" type="ST_LongHexNumber"/> + <xsd:attribute name="rsidRDefault" type="ST_LongHexNumber"/> + </xsd:complexType> + <xsd:simpleType name="ST_TblWidth"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="nil"/> + <xsd:enumeration value="pct"/> + <xsd:enumeration value="dxa"/> + <xsd:enumeration value="auto"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Height"> + <xsd:attribute name="val" type="s:ST_TwipsMeasure"/> + <xsd:attribute name="hRule" type="ST_HeightRule"/> + </xsd:complexType> + <xsd:simpleType name="ST_MeasurementOrPercent"> + <xsd:union memberTypes="ST_DecimalNumberOrPercent s:ST_UniversalMeasure"/> + </xsd:simpleType> + <xsd:complexType name="CT_TblWidth"> + <xsd:attribute name="w" type="ST_MeasurementOrPercent"/> + <xsd:attribute name="type" type="ST_TblWidth"/> + </xsd:complexType> + <xsd:complexType name="CT_TblGridCol"> + <xsd:attribute name="w" type="s:ST_TwipsMeasure"/> + </xsd:complexType> + <xsd:complexType name="CT_TblGridBase"> + <xsd:sequence> + <xsd:element name="gridCol" type="CT_TblGridCol" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TblGrid"> + <xsd:complexContent> + <xsd:extension base="CT_TblGridBase"> + <xsd:sequence> + <xsd:element name="tblGridChange" type="CT_TblGridChange" minOccurs="0"/> + </xsd:sequence> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_TcBorders"> + <xsd:sequence> + <xsd:element name="top" type="CT_Border" minOccurs="0"/> + <xsd:element name="start" type="CT_Border" minOccurs="0"/> + <xsd:element name="left" type="CT_Border" minOccurs="0"/> + <xsd:element name="bottom" type="CT_Border" minOccurs="0"/> + <xsd:element name="end" type="CT_Border" minOccurs="0"/> + <xsd:element name="right" type="CT_Border" minOccurs="0"/> + <xsd:element name="insideH" type="CT_Border" minOccurs="0"/> + <xsd:element name="insideV" type="CT_Border" minOccurs="0"/> + <xsd:element name="tl2br" type="CT_Border" minOccurs="0"/> + <xsd:element name="tr2bl" type="CT_Border" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TcMar"> + <xsd:sequence> + <xsd:element name="top" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/> + <xsd:element name="start" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/> + <xsd:element name="left" type="CT_TblWidth" minOccurs="0"/> + <xsd:element name="bottom" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/> + <xsd:element name="end" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/> + <xsd:element name="right" type="CT_TblWidth" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_Merge"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="continue"/> + <xsd:enumeration value="restart"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_VMerge"> + <xsd:attribute name="val" type="ST_Merge"/> + </xsd:complexType> + <xsd:complexType name="CT_HMerge"> + <xsd:attribute name="val" type="ST_Merge"/> + </xsd:complexType> + <xsd:complexType name="CT_TcPrBase"> + <xsd:sequence> + <xsd:element name="cnfStyle" type="CT_Cnf" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tcW" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/> + <xsd:element name="gridSpan" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="hMerge" type="CT_HMerge" minOccurs="0"/> + <xsd:element name="vMerge" type="CT_VMerge" minOccurs="0"/> + <xsd:element name="tcBorders" type="CT_TcBorders" minOccurs="0" maxOccurs="1"/> + <xsd:element name="shd" type="CT_Shd" minOccurs="0"/> + <xsd:element name="noWrap" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="tcMar" type="CT_TcMar" minOccurs="0" maxOccurs="1"/> + <xsd:element name="textDirection" type="CT_TextDirection" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tcFitText" type="CT_OnOff" minOccurs="0" maxOccurs="1"/> + <xsd:element name="vAlign" type="CT_VerticalJc" minOccurs="0"/> + <xsd:element name="hideMark" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="headers" type="CT_Headers" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TcPr"> + <xsd:complexContent> + <xsd:extension base="CT_TcPrInner"> + <xsd:sequence> + <xsd:element name="tcPrChange" type="CT_TcPrChange" minOccurs="0"/> + </xsd:sequence> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_TcPrInner"> + <xsd:complexContent> + <xsd:extension base="CT_TcPrBase"> + <xsd:sequence> + <xsd:group ref="EG_CellMarkupElements" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_Tc"> + <xsd:sequence> + <xsd:element name="tcPr" type="CT_TcPr" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_BlockLevelElts" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="id" type="s:ST_String" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_Cnf"> + <xsd:restriction base="xsd:string"> + <xsd:length value="12"/> + <xsd:pattern value="[01]*"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Cnf"> + <xsd:attribute name="val" type="ST_Cnf"/> + <xsd:attribute name="firstRow" type="s:ST_OnOff"/> + <xsd:attribute name="lastRow" type="s:ST_OnOff"/> + <xsd:attribute name="firstColumn" type="s:ST_OnOff"/> + <xsd:attribute name="lastColumn" type="s:ST_OnOff"/> + <xsd:attribute name="oddVBand" type="s:ST_OnOff"/> + <xsd:attribute name="evenVBand" type="s:ST_OnOff"/> + <xsd:attribute name="oddHBand" type="s:ST_OnOff"/> + <xsd:attribute name="evenHBand" type="s:ST_OnOff"/> + <xsd:attribute name="firstRowFirstColumn" type="s:ST_OnOff"/> + <xsd:attribute name="firstRowLastColumn" type="s:ST_OnOff"/> + <xsd:attribute name="lastRowFirstColumn" type="s:ST_OnOff"/> + <xsd:attribute name="lastRowLastColumn" type="s:ST_OnOff"/> + </xsd:complexType> + <xsd:complexType name="CT_Headers"> + <xsd:sequence minOccurs="0" maxOccurs="unbounded"> + <xsd:element name="header" type="CT_String"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TrPrBase"> + <xsd:choice maxOccurs="unbounded"> + <xsd:element name="cnfStyle" type="CT_Cnf" minOccurs="0" maxOccurs="1"/> + <xsd:element name="divId" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="gridBefore" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="gridAfter" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="wBefore" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/> + <xsd:element name="wAfter" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/> + <xsd:element name="cantSplit" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="trHeight" type="CT_Height" minOccurs="0"/> + <xsd:element name="tblHeader" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="tblCellSpacing" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/> + <xsd:element name="jc" type="CT_JcTable" minOccurs="0" maxOccurs="1"/> + <xsd:element name="hidden" type="CT_OnOff" minOccurs="0"/> + </xsd:choice> + </xsd:complexType> + <xsd:complexType name="CT_TrPr"> + <xsd:complexContent> + <xsd:extension base="CT_TrPrBase"> + <xsd:sequence> + <xsd:element name="ins" type="CT_TrackChange" minOccurs="0"/> + <xsd:element name="del" type="CT_TrackChange" minOccurs="0"/> + <xsd:element name="trPrChange" type="CT_TrPrChange" minOccurs="0"/> + </xsd:sequence> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_Row"> + <xsd:sequence> + <xsd:element name="tblPrEx" type="CT_TblPrEx" minOccurs="0" maxOccurs="1"/> + <xsd:element name="trPr" type="CT_TrPr" minOccurs="0" maxOccurs="1"/> + <xsd:group ref="EG_ContentCellContent" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="rsidRPr" type="ST_LongHexNumber"/> + <xsd:attribute name="rsidR" type="ST_LongHexNumber"/> + <xsd:attribute name="rsidDel" type="ST_LongHexNumber"/> + <xsd:attribute name="rsidTr" type="ST_LongHexNumber"/> + </xsd:complexType> + <xsd:simpleType name="ST_TblLayoutType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="fixed"/> + <xsd:enumeration value="autofit"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TblLayoutType"> + <xsd:attribute name="type" type="ST_TblLayoutType"/> + </xsd:complexType> + <xsd:simpleType name="ST_TblOverlap"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="never"/> + <xsd:enumeration value="overlap"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TblOverlap"> + <xsd:attribute name="val" type="ST_TblOverlap" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_TblPPr"> + <xsd:attribute name="leftFromText" type="s:ST_TwipsMeasure"/> + <xsd:attribute name="rightFromText" type="s:ST_TwipsMeasure"/> + <xsd:attribute name="topFromText" type="s:ST_TwipsMeasure"/> + <xsd:attribute name="bottomFromText" type="s:ST_TwipsMeasure"/> + <xsd:attribute name="vertAnchor" type="ST_VAnchor"/> + <xsd:attribute name="horzAnchor" type="ST_HAnchor"/> + <xsd:attribute name="tblpXSpec" type="s:ST_XAlign"/> + <xsd:attribute name="tblpX" type="ST_SignedTwipsMeasure"/> + <xsd:attribute name="tblpYSpec" type="s:ST_YAlign"/> + <xsd:attribute name="tblpY" type="ST_SignedTwipsMeasure"/> + </xsd:complexType> + <xsd:complexType name="CT_TblCellMar"> + <xsd:sequence> + <xsd:element name="top" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/> + <xsd:element name="start" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/> + <xsd:element name="left" type="CT_TblWidth" minOccurs="0"/> + <xsd:element name="bottom" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/> + <xsd:element name="end" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/> + <xsd:element name="right" type="CT_TblWidth" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TblBorders"> + <xsd:sequence> + <xsd:element name="top" type="CT_Border" minOccurs="0"/> + <xsd:element name="start" type="CT_Border" minOccurs="0"/> + <xsd:element name="left" type="CT_Border" minOccurs="0"/> + <xsd:element name="bottom" type="CT_Border" minOccurs="0"/> + <xsd:element name="end" type="CT_Border" minOccurs="0"/> + <xsd:element name="right" type="CT_Border" minOccurs="0"/> + <xsd:element name="insideH" type="CT_Border" minOccurs="0"/> + <xsd:element name="insideV" type="CT_Border" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TblPrBase"> + <xsd:sequence> + <xsd:element name="tblStyle" type="CT_String" minOccurs="0"/> + <xsd:element name="tblpPr" type="CT_TblPPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tblOverlap" type="CT_TblOverlap" minOccurs="0" maxOccurs="1"/> + <xsd:element name="bidiVisual" type="CT_OnOff" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tblStyleRowBandSize" type="CT_DecimalNumber" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tblStyleColBandSize" type="CT_DecimalNumber" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tblW" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/> + <xsd:element name="jc" type="CT_JcTable" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tblCellSpacing" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tblInd" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tblBorders" type="CT_TblBorders" minOccurs="0" maxOccurs="1"/> + <xsd:element name="shd" type="CT_Shd" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tblLayout" type="CT_TblLayoutType" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tblCellMar" type="CT_TblCellMar" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tblLook" type="CT_TblLook" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tblCaption" type="CT_String" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tblDescription" type="CT_String" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TblPr"> + <xsd:complexContent> + <xsd:extension base="CT_TblPrBase"> + <xsd:sequence> + <xsd:element name="tblPrChange" type="CT_TblPrChange" minOccurs="0"/> + </xsd:sequence> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_TblPrExBase"> + <xsd:sequence> + <xsd:element name="tblW" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/> + <xsd:element name="jc" type="CT_JcTable" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tblCellSpacing" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tblInd" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tblBorders" type="CT_TblBorders" minOccurs="0" maxOccurs="1"/> + <xsd:element name="shd" type="CT_Shd" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tblLayout" type="CT_TblLayoutType" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tblCellMar" type="CT_TblCellMar" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tblLook" type="CT_TblLook" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TblPrEx"> + <xsd:complexContent> + <xsd:extension base="CT_TblPrExBase"> + <xsd:sequence> + <xsd:element name="tblPrExChange" type="CT_TblPrExChange" minOccurs="0"/> + </xsd:sequence> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_Tbl"> + <xsd:sequence> + <xsd:group ref="EG_RangeMarkupElements" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="tblPr" type="CT_TblPr"/> + <xsd:element name="tblGrid" type="CT_TblGrid"/> + <xsd:group ref="EG_ContentRowContent" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TblLook"> + <xsd:attribute name="firstRow" type="s:ST_OnOff"/> + <xsd:attribute name="lastRow" type="s:ST_OnOff"/> + <xsd:attribute name="firstColumn" type="s:ST_OnOff"/> + <xsd:attribute name="lastColumn" type="s:ST_OnOff"/> + <xsd:attribute name="noHBand" type="s:ST_OnOff"/> + <xsd:attribute name="noVBand" type="s:ST_OnOff"/> + <xsd:attribute name="val" type="ST_ShortHexNumber"/> + </xsd:complexType> + <xsd:simpleType name="ST_FtnPos"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="pageBottom"/> + <xsd:enumeration value="beneathText"/> + <xsd:enumeration value="sectEnd"/> + <xsd:enumeration value="docEnd"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_FtnPos"> + <xsd:attribute name="val" type="ST_FtnPos" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_EdnPos"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="sectEnd"/> + <xsd:enumeration value="docEnd"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_EdnPos"> + <xsd:attribute name="val" type="ST_EdnPos" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_NumFmt"> + <xsd:attribute name="val" type="ST_NumberFormat" use="required"/> + <xsd:attribute name="format" type="s:ST_String" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_RestartNumber"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="continuous"/> + <xsd:enumeration value="eachSect"/> + <xsd:enumeration value="eachPage"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_NumRestart"> + <xsd:attribute name="val" type="ST_RestartNumber" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_FtnEdnRef"> + <xsd:attribute name="customMarkFollows" type="s:ST_OnOff" use="optional"/> + <xsd:attribute name="id" use="required" type="ST_DecimalNumber"/> + </xsd:complexType> + <xsd:complexType name="CT_FtnEdnSepRef"> + <xsd:attribute name="id" type="ST_DecimalNumber" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_FtnEdn"> + <xsd:sequence> + <xsd:group ref="EG_BlockLevelElts" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="type" type="ST_FtnEdn" use="optional"/> + <xsd:attribute name="id" type="ST_DecimalNumber" use="required"/> + </xsd:complexType> + <xsd:group name="EG_FtnEdnNumProps"> + <xsd:sequence> + <xsd:element name="numStart" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="numRestart" type="CT_NumRestart" minOccurs="0"/> + </xsd:sequence> + </xsd:group> + <xsd:complexType name="CT_FtnProps"> + <xsd:sequence> + <xsd:element name="pos" type="CT_FtnPos" minOccurs="0"/> + <xsd:element name="numFmt" type="CT_NumFmt" minOccurs="0"/> + <xsd:group ref="EG_FtnEdnNumProps" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_EdnProps"> + <xsd:sequence> + <xsd:element name="pos" type="CT_EdnPos" minOccurs="0"/> + <xsd:element name="numFmt" type="CT_NumFmt" minOccurs="0"/> + <xsd:group ref="EG_FtnEdnNumProps" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_FtnDocProps"> + <xsd:complexContent> + <xsd:extension base="CT_FtnProps"> + <xsd:sequence> + <xsd:element name="footnote" type="CT_FtnEdnSepRef" minOccurs="0" maxOccurs="3"/> + </xsd:sequence> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_EdnDocProps"> + <xsd:complexContent> + <xsd:extension base="CT_EdnProps"> + <xsd:sequence> + <xsd:element name="endnote" type="CT_FtnEdnSepRef" minOccurs="0" maxOccurs="3"/> + </xsd:sequence> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_RecipientData"> + <xsd:sequence> + <xsd:element name="active" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="column" type="CT_DecimalNumber" minOccurs="1"/> + <xsd:element name="uniqueTag" type="CT_Base64Binary" minOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Base64Binary"> + <xsd:attribute name="val" type="xsd:base64Binary" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Recipients"> + <xsd:sequence> + <xsd:element name="recipientData" type="CT_RecipientData" minOccurs="1" maxOccurs="unbounded" + /> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="recipients" type="CT_Recipients"/> + <xsd:complexType name="CT_OdsoFieldMapData"> + <xsd:sequence> + <xsd:element name="type" type="CT_MailMergeOdsoFMDFieldType" minOccurs="0"/> + <xsd:element name="name" type="CT_String" minOccurs="0"/> + <xsd:element name="mappedName" type="CT_String" minOccurs="0"/> + <xsd:element name="column" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="lid" type="CT_Lang" minOccurs="0"/> + <xsd:element name="dynamicAddress" type="CT_OnOff" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_MailMergeSourceType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="database"/> + <xsd:enumeration value="addressBook"/> + <xsd:enumeration value="document1"/> + <xsd:enumeration value="document2"/> + <xsd:enumeration value="text"/> + <xsd:enumeration value="email"/> + <xsd:enumeration value="native"/> + <xsd:enumeration value="legacy"/> + <xsd:enumeration value="master"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_MailMergeSourceType"> + <xsd:attribute name="val" use="required" type="ST_MailMergeSourceType"/> + </xsd:complexType> + <xsd:complexType name="CT_Odso"> + <xsd:sequence> + <xsd:element name="udl" type="CT_String" minOccurs="0"/> + <xsd:element name="table" type="CT_String" minOccurs="0"/> + <xsd:element name="src" type="CT_Rel" minOccurs="0"/> + <xsd:element name="colDelim" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="type" type="CT_MailMergeSourceType" minOccurs="0"/> + <xsd:element name="fHdr" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="fieldMapData" type="CT_OdsoFieldMapData" minOccurs="0" + maxOccurs="unbounded"/> + <xsd:element name="recipientData" type="CT_Rel" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_MailMerge"> + <xsd:sequence> + <xsd:element name="mainDocumentType" type="CT_MailMergeDocType" minOccurs="1"/> + <xsd:element name="linkToQuery" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="dataType" type="CT_MailMergeDataType" minOccurs="1"/> + <xsd:element name="connectString" type="CT_String" minOccurs="0"/> + <xsd:element name="query" type="CT_String" minOccurs="0"/> + <xsd:element name="dataSource" type="CT_Rel" minOccurs="0"/> + <xsd:element name="headerSource" type="CT_Rel" minOccurs="0"/> + <xsd:element name="doNotSuppressBlankLines" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="destination" type="CT_MailMergeDest" minOccurs="0"/> + <xsd:element name="addressFieldName" type="CT_String" minOccurs="0"/> + <xsd:element name="mailSubject" type="CT_String" minOccurs="0"/> + <xsd:element name="mailAsAttachment" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="viewMergedData" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="activeRecord" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="checkErrors" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="odso" type="CT_Odso" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_TargetScreenSz"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="544x376"/> + <xsd:enumeration value="640x480"/> + <xsd:enumeration value="720x512"/> + <xsd:enumeration value="800x600"/> + <xsd:enumeration value="1024x768"/> + <xsd:enumeration value="1152x882"/> + <xsd:enumeration value="1152x900"/> + <xsd:enumeration value="1280x1024"/> + <xsd:enumeration value="1600x1200"/> + <xsd:enumeration value="1800x1440"/> + <xsd:enumeration value="1920x1200"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TargetScreenSz"> + <xsd:attribute name="val" type="ST_TargetScreenSz" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Compat"> + <xsd:sequence> + <xsd:element name="useSingleBorderforContiguousCells" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="wpJustification" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="noTabHangInd" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="noLeading" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="spaceForUL" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="noColumnBalance" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="balanceSingleByteDoubleByteWidth" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="noExtraLineSpacing" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="doNotLeaveBackslashAlone" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="ulTrailSpace" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="doNotExpandShiftReturn" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="spacingInWholePoints" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="lineWrapLikeWord6" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="printBodyTextBeforeHeader" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="printColBlack" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="wpSpaceWidth" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="showBreaksInFrames" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="subFontBySize" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="suppressBottomSpacing" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="suppressTopSpacing" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="suppressSpacingAtTopOfPage" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="suppressTopSpacingWP" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="suppressSpBfAfterPgBrk" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="swapBordersFacingPages" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="convMailMergeEsc" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="truncateFontHeightsLikeWP6" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="mwSmallCaps" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="usePrinterMetrics" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="doNotSuppressParagraphBorders" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="wrapTrailSpaces" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="footnoteLayoutLikeWW8" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="shapeLayoutLikeWW8" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="alignTablesRowByRow" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="forgetLastTabAlignment" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="adjustLineHeightInTable" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="autoSpaceLikeWord95" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="noSpaceRaiseLower" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="doNotUseHTMLParagraphAutoSpacing" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="layoutRawTableWidth" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="layoutTableRowsApart" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="useWord97LineBreakRules" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="doNotBreakWrappedTables" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="doNotSnapToGridInCell" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="selectFldWithFirstOrLastChar" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="applyBreakingRules" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="doNotWrapTextWithPunct" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="doNotUseEastAsianBreakRules" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="useWord2002TableStyleRules" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="growAutofit" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="useFELayout" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="useNormalStyleForList" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="doNotUseIndentAsNumberingTabStop" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="useAltKinsokuLineBreakRules" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="allowSpaceOfSameStyleInTable" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="doNotSuppressIndentation" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="doNotAutofitConstrainedTables" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="autofitToFirstFixedWidthCell" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="underlineTabInNumList" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="displayHangulFixedWidth" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="splitPgBreakAndParaMark" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="doNotVertAlignCellWithSp" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="doNotBreakConstrainedForcedTable" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="doNotVertAlignInTxbx" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="useAnsiKerningPairs" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="cachedColBalance" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="compatSetting" type="CT_CompatSetting" minOccurs="0" maxOccurs="unbounded" + /> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_CompatSetting"> + <xsd:attribute name="name" type="s:ST_String"/> + <xsd:attribute name="uri" type="s:ST_String"/> + <xsd:attribute name="val" type="s:ST_String"/> + </xsd:complexType> + <xsd:complexType name="CT_DocVar"> + <xsd:attribute name="name" type="s:ST_String" use="required"/> + <xsd:attribute name="val" type="s:ST_String" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_DocVars"> + <xsd:sequence> + <xsd:element name="docVar" type="CT_DocVar" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_DocRsids"> + <xsd:sequence> + <xsd:element name="rsidRoot" type="CT_LongHexNumber" minOccurs="0" maxOccurs="1"/> + <xsd:element name="rsid" type="CT_LongHexNumber" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_CharacterSpacing"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="doNotCompress"/> + <xsd:enumeration value="compressPunctuation"/> + <xsd:enumeration value="compressPunctuationAndJapaneseKana"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_CharacterSpacing"> + <xsd:attribute name="val" type="ST_CharacterSpacing" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_SaveThroughXslt"> + <xsd:attribute ref="r:id" use="optional"/> + <xsd:attribute name="solutionID" type="s:ST_String" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_RPrDefault"> + <xsd:sequence> + <xsd:element name="rPr" type="CT_RPr" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_PPrDefault"> + <xsd:sequence> + <xsd:element name="pPr" type="CT_PPrGeneral" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_DocDefaults"> + <xsd:sequence> + <xsd:element name="rPrDefault" type="CT_RPrDefault" minOccurs="0"/> + <xsd:element name="pPrDefault" type="CT_PPrDefault" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_WmlColorSchemeIndex"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="dark1"/> + <xsd:enumeration value="light1"/> + <xsd:enumeration value="dark2"/> + <xsd:enumeration value="light2"/> + <xsd:enumeration value="accent1"/> + <xsd:enumeration value="accent2"/> + <xsd:enumeration value="accent3"/> + <xsd:enumeration value="accent4"/> + <xsd:enumeration value="accent5"/> + <xsd:enumeration value="accent6"/> + <xsd:enumeration value="hyperlink"/> + <xsd:enumeration value="followedHyperlink"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_ColorSchemeMapping"> + <xsd:attribute name="bg1" type="ST_WmlColorSchemeIndex"/> + <xsd:attribute name="t1" type="ST_WmlColorSchemeIndex"/> + <xsd:attribute name="bg2" type="ST_WmlColorSchemeIndex"/> + <xsd:attribute name="t2" type="ST_WmlColorSchemeIndex"/> + <xsd:attribute name="accent1" type="ST_WmlColorSchemeIndex"/> + <xsd:attribute name="accent2" type="ST_WmlColorSchemeIndex"/> + <xsd:attribute name="accent3" type="ST_WmlColorSchemeIndex"/> + <xsd:attribute name="accent4" type="ST_WmlColorSchemeIndex"/> + <xsd:attribute name="accent5" type="ST_WmlColorSchemeIndex"/> + <xsd:attribute name="accent6" type="ST_WmlColorSchemeIndex"/> + <xsd:attribute name="hyperlink" type="ST_WmlColorSchemeIndex"/> + <xsd:attribute name="followedHyperlink" type="ST_WmlColorSchemeIndex"/> + </xsd:complexType> + <xsd:complexType name="CT_ReadingModeInkLockDown"> + <xsd:attribute name="actualPg" type="s:ST_OnOff" use="required"/> + <xsd:attribute name="w" type="ST_PixelsMeasure" use="required"/> + <xsd:attribute name="h" type="ST_PixelsMeasure" use="required"/> + <xsd:attribute name="fontSz" type="ST_DecimalNumberOrPercent" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_WriteProtection"> + <xsd:attribute name="recommended" type="s:ST_OnOff" use="optional"/> + <xsd:attributeGroup ref="AG_Password"/> + <xsd:attributeGroup ref="AG_TransitionalPassword"/> + </xsd:complexType> + <xsd:complexType name="CT_Settings"> + <xsd:sequence> + <xsd:element name="writeProtection" type="CT_WriteProtection" minOccurs="0"/> + <xsd:element name="view" type="CT_View" minOccurs="0"/> + <xsd:element name="zoom" type="CT_Zoom" minOccurs="0"/> + <xsd:element name="removePersonalInformation" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="removeDateAndTime" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="doNotDisplayPageBoundaries" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="displayBackgroundShape" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="printPostScriptOverText" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="printFractionalCharacterWidth" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="printFormsData" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="embedTrueTypeFonts" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="embedSystemFonts" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="saveSubsetFonts" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="saveFormsData" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="mirrorMargins" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="alignBordersAndEdges" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="bordersDoNotSurroundHeader" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="bordersDoNotSurroundFooter" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="gutterAtTop" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="hideSpellingErrors" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="hideGrammaticalErrors" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="activeWritingStyle" type="CT_WritingStyle" minOccurs="0" + maxOccurs="unbounded"/> + <xsd:element name="proofState" type="CT_Proof" minOccurs="0"/> + <xsd:element name="formsDesign" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="attachedTemplate" type="CT_Rel" minOccurs="0"/> + <xsd:element name="linkStyles" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="stylePaneFormatFilter" type="CT_StylePaneFilter" minOccurs="0"/> + <xsd:element name="stylePaneSortMethod" type="CT_StyleSort" minOccurs="0"/> + <xsd:element name="documentType" type="CT_DocType" minOccurs="0"/> + <xsd:element name="mailMerge" type="CT_MailMerge" minOccurs="0"/> + <xsd:element name="revisionView" type="CT_TrackChangesView" minOccurs="0"/> + <xsd:element name="trackRevisions" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="doNotTrackMoves" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="doNotTrackFormatting" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="documentProtection" type="CT_DocProtect" minOccurs="0"/> + <xsd:element name="autoFormatOverride" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="styleLockTheme" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="styleLockQFSet" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="defaultTabStop" type="CT_TwipsMeasure" minOccurs="0"/> + <xsd:element name="autoHyphenation" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="consecutiveHyphenLimit" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="hyphenationZone" type="CT_TwipsMeasure" minOccurs="0"/> + <xsd:element name="doNotHyphenateCaps" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="showEnvelope" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="summaryLength" type="CT_DecimalNumberOrPrecent" minOccurs="0"/> + <xsd:element name="clickAndTypeStyle" type="CT_String" minOccurs="0"/> + <xsd:element name="defaultTableStyle" type="CT_String" minOccurs="0"/> + <xsd:element name="evenAndOddHeaders" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="bookFoldRevPrinting" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="bookFoldPrinting" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="bookFoldPrintingSheets" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="drawingGridHorizontalSpacing" type="CT_TwipsMeasure" minOccurs="0"/> + <xsd:element name="drawingGridVerticalSpacing" type="CT_TwipsMeasure" minOccurs="0"/> + <xsd:element name="displayHorizontalDrawingGridEvery" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="displayVerticalDrawingGridEvery" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="doNotUseMarginsForDrawingGridOrigin" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="drawingGridHorizontalOrigin" type="CT_TwipsMeasure" minOccurs="0"/> + <xsd:element name="drawingGridVerticalOrigin" type="CT_TwipsMeasure" minOccurs="0"/> + <xsd:element name="doNotShadeFormData" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="noPunctuationKerning" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="characterSpacingControl" type="CT_CharacterSpacing" minOccurs="0"/> + <xsd:element name="printTwoOnOne" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="strictFirstAndLastChars" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="noLineBreaksAfter" type="CT_Kinsoku" minOccurs="0"/> + <xsd:element name="noLineBreaksBefore" type="CT_Kinsoku" minOccurs="0"/> + <xsd:element name="savePreviewPicture" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="doNotValidateAgainstSchema" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="saveInvalidXml" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="ignoreMixedContent" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="alwaysShowPlaceholderText" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="doNotDemarcateInvalidXml" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="saveXmlDataOnly" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="useXSLTWhenSaving" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="saveThroughXslt" type="CT_SaveThroughXslt" minOccurs="0"/> + <xsd:element name="showXMLTags" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="alwaysMergeEmptyNamespace" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="updateFields" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="hdrShapeDefaults" type="CT_ShapeDefaults" minOccurs="0"/> + <xsd:element name="footnotePr" type="CT_FtnDocProps" minOccurs="0"/> + <xsd:element name="endnotePr" type="CT_EdnDocProps" minOccurs="0"/> + <xsd:element name="compat" type="CT_Compat" minOccurs="0"/> + <xsd:element name="docVars" type="CT_DocVars" minOccurs="0"/> + <xsd:element name="rsids" type="CT_DocRsids" minOccurs="0"/> + <xsd:element ref="m:mathPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="attachedSchema" type="CT_String" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="themeFontLang" type="CT_Language" minOccurs="0" maxOccurs="1"/> + <xsd:element name="clrSchemeMapping" type="CT_ColorSchemeMapping" minOccurs="0"/> + <xsd:element name="doNotIncludeSubdocsInStats" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="doNotAutoCompressPictures" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="forceUpgrade" type="CT_Empty" minOccurs="0" maxOccurs="1"/> + <xsd:element name="captions" type="CT_Captions" minOccurs="0" maxOccurs="1"/> + <xsd:element name="readModeInkLockDown" type="CT_ReadingModeInkLockDown" minOccurs="0"/> + <xsd:element name="smartTagType" type="CT_SmartTagType" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element ref="sl:schemaLibrary" minOccurs="0" maxOccurs="1"/> + <xsd:element name="shapeDefaults" type="CT_ShapeDefaults" minOccurs="0"/> + <xsd:element name="doNotEmbedSmartTags" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="decimalSymbol" type="CT_String" minOccurs="0" maxOccurs="1"/> + <xsd:element name="listSeparator" type="CT_String" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_StyleSort"> + <xsd:attribute name="val" type="ST_StyleSort" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_StylePaneFilter"> + <xsd:attribute name="allStyles" type="s:ST_OnOff"/> + <xsd:attribute name="customStyles" type="s:ST_OnOff"/> + <xsd:attribute name="latentStyles" type="s:ST_OnOff"/> + <xsd:attribute name="stylesInUse" type="s:ST_OnOff"/> + <xsd:attribute name="headingStyles" type="s:ST_OnOff"/> + <xsd:attribute name="numberingStyles" type="s:ST_OnOff"/> + <xsd:attribute name="tableStyles" type="s:ST_OnOff"/> + <xsd:attribute name="directFormattingOnRuns" type="s:ST_OnOff"/> + <xsd:attribute name="directFormattingOnParagraphs" type="s:ST_OnOff"/> + <xsd:attribute name="directFormattingOnNumbering" type="s:ST_OnOff"/> + <xsd:attribute name="directFormattingOnTables" type="s:ST_OnOff"/> + <xsd:attribute name="clearFormatting" type="s:ST_OnOff"/> + <xsd:attribute name="top3HeadingStyles" type="s:ST_OnOff"/> + <xsd:attribute name="visibleStyles" type="s:ST_OnOff"/> + <xsd:attribute name="alternateStyleNames" type="s:ST_OnOff"/> + <xsd:attribute name="val" type="ST_ShortHexNumber"/> + </xsd:complexType> + <xsd:simpleType name="ST_StyleSort"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="name"/> + <xsd:enumeration value="priority"/> + <xsd:enumeration value="default"/> + <xsd:enumeration value="font"/> + <xsd:enumeration value="basedOn"/> + <xsd:enumeration value="type"/> + <xsd:enumeration value="0000"/> + <xsd:enumeration value="0001"/> + <xsd:enumeration value="0002"/> + <xsd:enumeration value="0003"/> + <xsd:enumeration value="0004"/> + <xsd:enumeration value="0005"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_WebSettings"> + <xsd:sequence> + <xsd:element name="frameset" type="CT_Frameset" minOccurs="0"/> + <xsd:element name="divs" type="CT_Divs" minOccurs="0"/> + <xsd:element name="encoding" type="CT_String" minOccurs="0"/> + <xsd:element name="optimizeForBrowser" type="CT_OptimizeForBrowser" minOccurs="0"/> + <xsd:element name="relyOnVML" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="allowPNG" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="doNotRelyOnCSS" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="doNotSaveAsSingleFile" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="doNotOrganizeInFolder" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="doNotUseLongFileNames" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="pixelsPerInch" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="targetScreenSz" type="CT_TargetScreenSz" minOccurs="0"/> + <xsd:element name="saveSmartTagsAsXml" type="CT_OnOff" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_FrameScrollbar"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="on"/> + <xsd:enumeration value="off"/> + <xsd:enumeration value="auto"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_FrameScrollbar"> + <xsd:attribute name="val" type="ST_FrameScrollbar" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_OptimizeForBrowser"> + <xsd:complexContent> + <xsd:extension base="CT_OnOff"> + <xsd:attribute name="target" type="s:ST_String" use="optional"/> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_Frame"> + <xsd:sequence> + <xsd:element name="sz" type="CT_String" minOccurs="0"/> + <xsd:element name="name" type="CT_String" minOccurs="0"/> + <xsd:element name="title" type="CT_String" minOccurs="0"/> + <xsd:element name="longDesc" type="CT_Rel" minOccurs="0"/> + <xsd:element name="sourceFileName" type="CT_Rel" minOccurs="0"/> + <xsd:element name="marW" type="CT_PixelsMeasure" minOccurs="0"/> + <xsd:element name="marH" type="CT_PixelsMeasure" minOccurs="0"/> + <xsd:element name="scrollbar" type="CT_FrameScrollbar" minOccurs="0"/> + <xsd:element name="noResizeAllowed" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="linkedToFile" type="CT_OnOff" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_FrameLayout"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="rows"/> + <xsd:enumeration value="cols"/> + <xsd:enumeration value="none"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_FrameLayout"> + <xsd:attribute name="val" type="ST_FrameLayout" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_FramesetSplitbar"> + <xsd:sequence> + <xsd:element name="w" type="CT_TwipsMeasure" minOccurs="0"/> + <xsd:element name="color" type="CT_Color" minOccurs="0"/> + <xsd:element name="noBorder" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="flatBorders" type="CT_OnOff" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Frameset"> + <xsd:sequence> + <xsd:element name="sz" type="CT_String" minOccurs="0"/> + <xsd:element name="framesetSplitbar" type="CT_FramesetSplitbar" minOccurs="0"/> + <xsd:element name="frameLayout" type="CT_FrameLayout" minOccurs="0"/> + <xsd:element name="title" type="CT_String" minOccurs="0"/> + <xsd:choice minOccurs="0" maxOccurs="unbounded"> + <xsd:element name="frameset" type="CT_Frameset" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="frame" type="CT_Frame" minOccurs="0" maxOccurs="unbounded"/> + </xsd:choice> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_NumPicBullet"> + <xsd:choice> + <xsd:element name="pict" type="CT_Picture"/> + <xsd:element name="drawing" type="CT_Drawing"/> + </xsd:choice> + <xsd:attribute name="numPicBulletId" type="ST_DecimalNumber" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_LevelSuffix"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="tab"/> + <xsd:enumeration value="space"/> + <xsd:enumeration value="nothing"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_LevelSuffix"> + <xsd:attribute name="val" type="ST_LevelSuffix" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_LevelText"> + <xsd:attribute name="val" type="s:ST_String" use="optional"/> + <xsd:attribute name="null" type="s:ST_OnOff" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_LvlLegacy"> + <xsd:attribute name="legacy" type="s:ST_OnOff" use="optional"/> + <xsd:attribute name="legacySpace" type="s:ST_TwipsMeasure" use="optional"/> + <xsd:attribute name="legacyIndent" type="ST_SignedTwipsMeasure" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_Lvl"> + <xsd:sequence> + <xsd:element name="start" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="numFmt" type="CT_NumFmt" minOccurs="0"/> + <xsd:element name="lvlRestart" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="pStyle" type="CT_String" minOccurs="0"/> + <xsd:element name="isLgl" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="suff" type="CT_LevelSuffix" minOccurs="0"/> + <xsd:element name="lvlText" type="CT_LevelText" minOccurs="0"/> + <xsd:element name="lvlPicBulletId" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="legacy" type="CT_LvlLegacy" minOccurs="0"/> + <xsd:element name="lvlJc" type="CT_Jc" minOccurs="0"/> + <xsd:element name="pPr" type="CT_PPrGeneral" minOccurs="0"/> + <xsd:element name="rPr" type="CT_RPr" minOccurs="0"/> + </xsd:sequence> + <xsd:attribute name="ilvl" type="ST_DecimalNumber" use="required"/> + <xsd:attribute name="tplc" type="ST_LongHexNumber" use="optional"/> + <xsd:attribute name="tentative" type="s:ST_OnOff" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_MultiLevelType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="singleLevel"/> + <xsd:enumeration value="multilevel"/> + <xsd:enumeration value="hybridMultilevel"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_MultiLevelType"> + <xsd:attribute name="val" type="ST_MultiLevelType" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_AbstractNum"> + <xsd:sequence> + <xsd:element name="nsid" type="CT_LongHexNumber" minOccurs="0"/> + <xsd:element name="multiLevelType" type="CT_MultiLevelType" minOccurs="0"/> + <xsd:element name="tmpl" type="CT_LongHexNumber" minOccurs="0"/> + <xsd:element name="name" type="CT_String" minOccurs="0"/> + <xsd:element name="styleLink" type="CT_String" minOccurs="0"/> + <xsd:element name="numStyleLink" type="CT_String" minOccurs="0"/> + <xsd:element name="lvl" type="CT_Lvl" minOccurs="0" maxOccurs="9"/> + </xsd:sequence> + <xsd:attribute name="abstractNumId" type="ST_DecimalNumber" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_NumLvl"> + <xsd:sequence> + <xsd:element name="startOverride" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="lvl" type="CT_Lvl" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="ilvl" type="ST_DecimalNumber" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Num"> + <xsd:sequence> + <xsd:element name="abstractNumId" type="CT_DecimalNumber" minOccurs="1"/> + <xsd:element name="lvlOverride" type="CT_NumLvl" minOccurs="0" maxOccurs="9"/> + </xsd:sequence> + <xsd:attribute name="numId" type="ST_DecimalNumber" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Numbering"> + <xsd:sequence> + <xsd:element name="numPicBullet" type="CT_NumPicBullet" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="abstractNum" type="CT_AbstractNum" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="num" type="CT_Num" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="numIdMacAtCleanup" type="CT_DecimalNumber" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_TblStyleOverrideType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="wholeTable"/> + <xsd:enumeration value="firstRow"/> + <xsd:enumeration value="lastRow"/> + <xsd:enumeration value="firstCol"/> + <xsd:enumeration value="lastCol"/> + <xsd:enumeration value="band1Vert"/> + <xsd:enumeration value="band2Vert"/> + <xsd:enumeration value="band1Horz"/> + <xsd:enumeration value="band2Horz"/> + <xsd:enumeration value="neCell"/> + <xsd:enumeration value="nwCell"/> + <xsd:enumeration value="seCell"/> + <xsd:enumeration value="swCell"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_TblStylePr"> + <xsd:sequence> + <xsd:element name="pPr" type="CT_PPrGeneral" minOccurs="0"/> + <xsd:element name="rPr" type="CT_RPr" minOccurs="0"/> + <xsd:element name="tblPr" type="CT_TblPrBase" minOccurs="0"/> + <xsd:element name="trPr" type="CT_TrPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tcPr" type="CT_TcPr" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="type" type="ST_TblStyleOverrideType" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_StyleType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="paragraph"/> + <xsd:enumeration value="character"/> + <xsd:enumeration value="table"/> + <xsd:enumeration value="numbering"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Style"> + <xsd:sequence> + <xsd:element name="name" type="CT_String" minOccurs="0" maxOccurs="1"/> + <xsd:element name="aliases" type="CT_String" minOccurs="0"/> + <xsd:element name="basedOn" type="CT_String" minOccurs="0"/> + <xsd:element name="next" type="CT_String" minOccurs="0"/> + <xsd:element name="link" type="CT_String" minOccurs="0"/> + <xsd:element name="autoRedefine" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="hidden" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="uiPriority" type="CT_DecimalNumber" minOccurs="0"/> + <xsd:element name="semiHidden" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="unhideWhenUsed" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="qFormat" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="locked" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="personal" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="personalCompose" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="personalReply" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="rsid" type="CT_LongHexNumber" minOccurs="0"/> + <xsd:element name="pPr" type="CT_PPrGeneral" minOccurs="0" maxOccurs="1"/> + <xsd:element name="rPr" type="CT_RPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tblPr" type="CT_TblPrBase" minOccurs="0" maxOccurs="1"/> + <xsd:element name="trPr" type="CT_TrPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tcPr" type="CT_TcPr" minOccurs="0" maxOccurs="1"/> + <xsd:element name="tblStylePr" type="CT_TblStylePr" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="type" type="ST_StyleType" use="optional"/> + <xsd:attribute name="styleId" type="s:ST_String" use="optional"/> + <xsd:attribute name="default" type="s:ST_OnOff" use="optional"/> + <xsd:attribute name="customStyle" type="s:ST_OnOff" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_LsdException"> + <xsd:attribute name="name" type="s:ST_String" use="required"/> + <xsd:attribute name="locked" type="s:ST_OnOff"/> + <xsd:attribute name="uiPriority" type="ST_DecimalNumber"/> + <xsd:attribute name="semiHidden" type="s:ST_OnOff"/> + <xsd:attribute name="unhideWhenUsed" type="s:ST_OnOff"/> + <xsd:attribute name="qFormat" type="s:ST_OnOff"/> + </xsd:complexType> + <xsd:complexType name="CT_LatentStyles"> + <xsd:sequence> + <xsd:element name="lsdException" type="CT_LsdException" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="defLockedState" type="s:ST_OnOff"/> + <xsd:attribute name="defUIPriority" type="ST_DecimalNumber"/> + <xsd:attribute name="defSemiHidden" type="s:ST_OnOff"/> + <xsd:attribute name="defUnhideWhenUsed" type="s:ST_OnOff"/> + <xsd:attribute name="defQFormat" type="s:ST_OnOff"/> + <xsd:attribute name="count" type="ST_DecimalNumber"/> + </xsd:complexType> + <xsd:complexType name="CT_Styles"> + <xsd:sequence> + <xsd:element name="docDefaults" type="CT_DocDefaults" minOccurs="0"/> + <xsd:element name="latentStyles" type="CT_LatentStyles" minOccurs="0" maxOccurs="1"/> + <xsd:element name="style" type="CT_Style" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Panose"> + <xsd:attribute name="val" type="s:ST_Panose" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_FontFamily"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="decorative"/> + <xsd:enumeration value="modern"/> + <xsd:enumeration value="roman"/> + <xsd:enumeration value="script"/> + <xsd:enumeration value="swiss"/> + <xsd:enumeration value="auto"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_FontFamily"> + <xsd:attribute name="val" type="ST_FontFamily" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_Pitch"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="fixed"/> + <xsd:enumeration value="variable"/> + <xsd:enumeration value="default"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Pitch"> + <xsd:attribute name="val" type="ST_Pitch" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_FontSig"> + <xsd:attribute name="usb0" use="required" type="ST_LongHexNumber"/> + <xsd:attribute name="usb1" use="required" type="ST_LongHexNumber"/> + <xsd:attribute name="usb2" use="required" type="ST_LongHexNumber"/> + <xsd:attribute name="usb3" use="required" type="ST_LongHexNumber"/> + <xsd:attribute name="csb0" use="required" type="ST_LongHexNumber"/> + <xsd:attribute name="csb1" use="required" type="ST_LongHexNumber"/> + </xsd:complexType> + <xsd:complexType name="CT_FontRel"> + <xsd:complexContent> + <xsd:extension base="CT_Rel"> + <xsd:attribute name="fontKey" type="s:ST_Guid"/> + <xsd:attribute name="subsetted" type="s:ST_OnOff"/> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_Font"> + <xsd:sequence> + <xsd:element name="altName" type="CT_String" minOccurs="0" maxOccurs="1"/> + <xsd:element name="panose1" type="CT_Panose" minOccurs="0" maxOccurs="1"/> + <xsd:element name="charset" type="CT_Charset" minOccurs="0" maxOccurs="1"/> + <xsd:element name="family" type="CT_FontFamily" minOccurs="0" maxOccurs="1"/> + <xsd:element name="notTrueType" type="CT_OnOff" minOccurs="0" maxOccurs="1"/> + <xsd:element name="pitch" type="CT_Pitch" minOccurs="0" maxOccurs="1"/> + <xsd:element name="sig" type="CT_FontSig" minOccurs="0" maxOccurs="1"/> + <xsd:element name="embedRegular" type="CT_FontRel" minOccurs="0" maxOccurs="1"/> + <xsd:element name="embedBold" type="CT_FontRel" minOccurs="0" maxOccurs="1"/> + <xsd:element name="embedItalic" type="CT_FontRel" minOccurs="0" maxOccurs="1"/> + <xsd:element name="embedBoldItalic" type="CT_FontRel" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="name" type="s:ST_String" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_FontsList"> + <xsd:sequence> + <xsd:element name="font" type="CT_Font" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_DivBdr"> + <xsd:sequence> + <xsd:element name="top" type="CT_Border" minOccurs="0"/> + <xsd:element name="left" type="CT_Border" minOccurs="0"/> + <xsd:element name="bottom" type="CT_Border" minOccurs="0"/> + <xsd:element name="right" type="CT_Border" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Div"> + <xsd:sequence> + <xsd:element name="blockQuote" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="bodyDiv" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="marLeft" type="CT_SignedTwipsMeasure"/> + <xsd:element name="marRight" type="CT_SignedTwipsMeasure"/> + <xsd:element name="marTop" type="CT_SignedTwipsMeasure"/> + <xsd:element name="marBottom" type="CT_SignedTwipsMeasure"/> + <xsd:element name="divBdr" type="CT_DivBdr" minOccurs="0"/> + <xsd:element name="divsChild" type="CT_Divs" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="id" type="ST_DecimalNumber" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Divs"> + <xsd:sequence minOccurs="1" maxOccurs="unbounded"> + <xsd:element name="div" type="CT_Div"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TxbxContent"> + <xsd:group ref="EG_BlockLevelElts" minOccurs="1" maxOccurs="unbounded"/> + </xsd:complexType> + <xsd:element name="txbxContent" type="CT_TxbxContent"/> + <xsd:group name="EG_MathContent"> + <xsd:choice> + <xsd:element ref="m:oMathPara"/> + <xsd:element ref="m:oMath"/> + </xsd:choice> + </xsd:group> + <xsd:group name="EG_BlockLevelChunkElts"> + <xsd:choice> + <xsd:group ref="EG_ContentBlockContent" minOccurs="0" maxOccurs="unbounded"/> + </xsd:choice> + </xsd:group> + <xsd:group name="EG_BlockLevelElts"> + <xsd:choice> + <xsd:group ref="EG_BlockLevelChunkElts" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="altChunk" type="CT_AltChunk" minOccurs="0" maxOccurs="unbounded"/> + </xsd:choice> + </xsd:group> + <xsd:group name="EG_RunLevelElts"> + <xsd:choice> + <xsd:element name="proofErr" minOccurs="0" type="CT_ProofErr"/> + <xsd:element name="permStart" minOccurs="0" type="CT_PermStart"/> + <xsd:element name="permEnd" minOccurs="0" type="CT_Perm"/> + <xsd:group ref="EG_RangeMarkupElements" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="ins" type="CT_RunTrackChange" minOccurs="0"/> + <xsd:element name="del" type="CT_RunTrackChange" minOccurs="0"/> + <xsd:element name="moveFrom" type="CT_RunTrackChange"/> + <xsd:element name="moveTo" type="CT_RunTrackChange"/> + <xsd:group ref="EG_MathContent" minOccurs="0" maxOccurs="unbounded"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_Body"> + <xsd:sequence> + <xsd:group ref="EG_BlockLevelElts" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="sectPr" minOccurs="0" maxOccurs="1" type="CT_SectPr"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_ShapeDefaults"> + <xsd:choice maxOccurs="unbounded"> + <xsd:any processContents="lax" namespace="urn:schemas-microsoft-com:office:office" + minOccurs="0" maxOccurs="unbounded"/> + </xsd:choice> + </xsd:complexType> + <xsd:complexType name="CT_Comments"> + <xsd:sequence> + <xsd:element name="comment" type="CT_Comment" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="comments" type="CT_Comments"/> + <xsd:complexType name="CT_Footnotes"> + <xsd:sequence maxOccurs="unbounded"> + <xsd:element name="footnote" type="CT_FtnEdn" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="footnotes" type="CT_Footnotes"/> + <xsd:complexType name="CT_Endnotes"> + <xsd:sequence maxOccurs="unbounded"> + <xsd:element name="endnote" type="CT_FtnEdn" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="endnotes" type="CT_Endnotes"/> + <xsd:element name="hdr" type="CT_HdrFtr"/> + <xsd:element name="ftr" type="CT_HdrFtr"/> + <xsd:complexType name="CT_SmartTagType"> + <xsd:attribute name="namespaceuri" type="s:ST_String"/> + <xsd:attribute name="name" type="s:ST_String"/> + <xsd:attribute name="url" type="s:ST_String"/> + </xsd:complexType> + <xsd:simpleType name="ST_ThemeColor"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="dark1"/> + <xsd:enumeration value="light1"/> + <xsd:enumeration value="dark2"/> + <xsd:enumeration value="light2"/> + <xsd:enumeration value="accent1"/> + <xsd:enumeration value="accent2"/> + <xsd:enumeration value="accent3"/> + <xsd:enumeration value="accent4"/> + <xsd:enumeration value="accent5"/> + <xsd:enumeration value="accent6"/> + <xsd:enumeration value="hyperlink"/> + <xsd:enumeration value="followedHyperlink"/> + <xsd:enumeration value="none"/> + <xsd:enumeration value="background1"/> + <xsd:enumeration value="text1"/> + <xsd:enumeration value="background2"/> + <xsd:enumeration value="text2"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_DocPartBehavior"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="content"/> + <xsd:enumeration value="p"/> + <xsd:enumeration value="pg"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_DocPartBehavior"> + <xsd:attribute name="val" use="required" type="ST_DocPartBehavior"/> + </xsd:complexType> + <xsd:complexType name="CT_DocPartBehaviors"> + <xsd:choice> + <xsd:element name="behavior" type="CT_DocPartBehavior" maxOccurs="unbounded"/> + </xsd:choice> + </xsd:complexType> + <xsd:simpleType name="ST_DocPartType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="normal"/> + <xsd:enumeration value="autoExp"/> + <xsd:enumeration value="toolbar"/> + <xsd:enumeration value="speller"/> + <xsd:enumeration value="formFld"/> + <xsd:enumeration value="bbPlcHdr"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_DocPartType"> + <xsd:attribute name="val" use="required" type="ST_DocPartType"/> + </xsd:complexType> + <xsd:complexType name="CT_DocPartTypes"> + <xsd:choice> + <xsd:element name="type" type="CT_DocPartType" maxOccurs="unbounded"/> + </xsd:choice> + <xsd:attribute name="all" type="s:ST_OnOff" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_DocPartGallery"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="placeholder"/> + <xsd:enumeration value="any"/> + <xsd:enumeration value="default"/> + <xsd:enumeration value="docParts"/> + <xsd:enumeration value="coverPg"/> + <xsd:enumeration value="eq"/> + <xsd:enumeration value="ftrs"/> + <xsd:enumeration value="hdrs"/> + <xsd:enumeration value="pgNum"/> + <xsd:enumeration value="tbls"/> + <xsd:enumeration value="watermarks"/> + <xsd:enumeration value="autoTxt"/> + <xsd:enumeration value="txtBox"/> + <xsd:enumeration value="pgNumT"/> + <xsd:enumeration value="pgNumB"/> + <xsd:enumeration value="pgNumMargins"/> + <xsd:enumeration value="tblOfContents"/> + <xsd:enumeration value="bib"/> + <xsd:enumeration value="custQuickParts"/> + <xsd:enumeration value="custCoverPg"/> + <xsd:enumeration value="custEq"/> + <xsd:enumeration value="custFtrs"/> + <xsd:enumeration value="custHdrs"/> + <xsd:enumeration value="custPgNum"/> + <xsd:enumeration value="custTbls"/> + <xsd:enumeration value="custWatermarks"/> + <xsd:enumeration value="custAutoTxt"/> + <xsd:enumeration value="custTxtBox"/> + <xsd:enumeration value="custPgNumT"/> + <xsd:enumeration value="custPgNumB"/> + <xsd:enumeration value="custPgNumMargins"/> + <xsd:enumeration value="custTblOfContents"/> + <xsd:enumeration value="custBib"/> + <xsd:enumeration value="custom1"/> + <xsd:enumeration value="custom2"/> + <xsd:enumeration value="custom3"/> + <xsd:enumeration value="custom4"/> + <xsd:enumeration value="custom5"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_DocPartGallery"> + <xsd:attribute name="val" type="ST_DocPartGallery" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_DocPartCategory"> + <xsd:sequence> + <xsd:element name="name" type="CT_String" minOccurs="1" maxOccurs="1"/> + <xsd:element name="gallery" type="CT_DocPartGallery" minOccurs="1" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_DocPartName"> + <xsd:attribute name="val" type="s:ST_String" use="required"/> + <xsd:attribute name="decorated" type="s:ST_OnOff" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_DocPartPr"> + <xsd:all> + <xsd:element name="name" type="CT_DocPartName" minOccurs="1"/> + <xsd:element name="style" type="CT_String" minOccurs="0"/> + <xsd:element name="category" type="CT_DocPartCategory" minOccurs="0"/> + <xsd:element name="types" type="CT_DocPartTypes" minOccurs="0"/> + <xsd:element name="behaviors" type="CT_DocPartBehaviors" minOccurs="0"/> + <xsd:element name="description" type="CT_String" minOccurs="0"/> + <xsd:element name="guid" type="CT_Guid" minOccurs="0"/> + </xsd:all> + </xsd:complexType> + <xsd:complexType name="CT_DocPart"> + <xsd:sequence> + <xsd:element name="docPartPr" type="CT_DocPartPr" minOccurs="0"/> + <xsd:element name="docPartBody" type="CT_Body" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_DocParts"> + <xsd:choice> + <xsd:element name="docPart" type="CT_DocPart" minOccurs="1" maxOccurs="unbounded"/> + </xsd:choice> + </xsd:complexType> + <xsd:element name="settings" type="CT_Settings"/> + <xsd:element name="webSettings" type="CT_WebSettings"/> + <xsd:element name="fonts" type="CT_FontsList"/> + <xsd:element name="numbering" type="CT_Numbering"/> + <xsd:element name="styles" type="CT_Styles"/> + <xsd:simpleType name="ST_CaptionPos"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="above"/> + <xsd:enumeration value="below"/> + <xsd:enumeration value="left"/> + <xsd:enumeration value="right"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Caption"> + <xsd:attribute name="name" type="s:ST_String" use="required"/> + <xsd:attribute name="pos" type="ST_CaptionPos" use="optional"/> + <xsd:attribute name="chapNum" type="s:ST_OnOff" use="optional"/> + <xsd:attribute name="heading" type="ST_DecimalNumber" use="optional"/> + <xsd:attribute name="noLabel" type="s:ST_OnOff" use="optional"/> + <xsd:attribute name="numFmt" type="ST_NumberFormat" use="optional"/> + <xsd:attribute name="sep" type="ST_ChapterSep" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_AutoCaption"> + <xsd:attribute name="name" type="s:ST_String" use="required"/> + <xsd:attribute name="caption" type="s:ST_String" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_AutoCaptions"> + <xsd:sequence> + <xsd:element name="autoCaption" type="CT_AutoCaption" minOccurs="1" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Captions"> + <xsd:sequence> + <xsd:element name="caption" type="CT_Caption" minOccurs="1" maxOccurs="unbounded"/> + <xsd:element name="autoCaptions" type="CT_AutoCaptions" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_DocumentBase"> + <xsd:sequence> + <xsd:element name="background" type="CT_Background" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Document"> + <xsd:complexContent> + <xsd:extension base="CT_DocumentBase"> + <xsd:sequence> + <xsd:element name="body" type="CT_Body" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="conformance" type="s:ST_ConformanceClass"/> + <xsd:attribute ref="mc:Ignorable" use="optional" /> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:complexType name="CT_GlossaryDocument"> + <xsd:complexContent> + <xsd:extension base="CT_DocumentBase"> + <xsd:sequence> + <xsd:element name="docParts" type="CT_DocParts" minOccurs="0"/> + </xsd:sequence> + </xsd:extension> + </xsd:complexContent> + </xsd:complexType> + <xsd:element name="document" type="CT_Document"/> + <xsd:element name="glossaryDocument" type="CT_GlossaryDocument"/> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/xml.xsd b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/xml.xsd new file mode 100644 index 00000000..0f13678d --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ISO-IEC29500-4_2016/xml.xsd @@ -0,0 +1,116 @@ +<?xml version='1.0'?> +<xs:schema targetNamespace="http://www.w3.org/XML/1998/namespace" xmlns:xs="http://www.w3.org/2001/XMLSchema" xml:lang="en"> + + <xs:annotation> + <xs:documentation> + See http://www.w3.org/XML/1998/namespace.html and + http://www.w3.org/TR/REC-xml for information about this namespace. + + This schema document describes the XML namespace, in a form + suitable for import by other schema documents. + + Note that local names in this namespace are intended to be defined + only by the World Wide Web Consortium or its subgroups. The + following names are currently defined in this namespace and should + not be used with conflicting semantics by any Working Group, + specification, or document instance: + + base (as an attribute name): denotes an attribute whose value + provides a URI to be used as the base for interpreting any + relative URIs in the scope of the element on which it + appears; its value is inherited. This name is reserved + by virtue of its definition in the XML Base specification. + + lang (as an attribute name): denotes an attribute whose value + is a language code for the natural language of the content of + any element; its value is inherited. This name is reserved + by virtue of its definition in the XML specification. + + space (as an attribute name): denotes an attribute whose + value is a keyword indicating what whitespace processing + discipline is intended for the content of the element; its + value is inherited. This name is reserved by virtue of its + definition in the XML specification. + + Father (in any context at all): denotes Jon Bosak, the chair of + the original XML Working Group. This name is reserved by + the following decision of the W3C XML Plenary and + XML Coordination groups: + + In appreciation for his vision, leadership and dedication + the W3C XML Plenary on this 10th day of February, 2000 + reserves for Jon Bosak in perpetuity the XML name + xml:Father + </xs:documentation> + </xs:annotation> + + <xs:annotation> + <xs:documentation>This schema defines attributes and an attribute group + suitable for use by + schemas wishing to allow xml:base, xml:lang or xml:space attributes + on elements they define. + + To enable this, such a schema must import this schema + for the XML namespace, e.g. as follows: + <schema . . .> + . . . + <import namespace="http://www.w3.org/XML/1998/namespace" + schemaLocation="http://www.w3.org/2001/03/xml.xsd"/> + + Subsequently, qualified reference to any of the attributes + or the group defined below will have the desired effect, e.g. + + <type . . .> + . . . + <attributeGroup ref="xml:specialAttrs"/> + + will define a type which will schema-validate an instance + element with any of those attributes</xs:documentation> + </xs:annotation> + + <xs:annotation> + <xs:documentation>In keeping with the XML Schema WG's standard versioning + policy, this schema document will persist at + http://www.w3.org/2001/03/xml.xsd. + At the date of issue it can also be found at + http://www.w3.org/2001/xml.xsd. + The schema document at that URI may however change in the future, + in order to remain compatible with the latest version of XML Schema + itself. In other words, if the XML Schema namespace changes, the version + of this document at + http://www.w3.org/2001/xml.xsd will change + accordingly; the version at + http://www.w3.org/2001/03/xml.xsd will not change. + </xs:documentation> + </xs:annotation> + + <xs:attribute name="lang" type="xs:language"> + <xs:annotation> + <xs:documentation>In due course, we should install the relevant ISO 2- and 3-letter + codes as the enumerated possible values . . .</xs:documentation> + </xs:annotation> + </xs:attribute> + + <xs:attribute name="space" default="preserve"> + <xs:simpleType> + <xs:restriction base="xs:NCName"> + <xs:enumeration value="default"/> + <xs:enumeration value="preserve"/> + </xs:restriction> + </xs:simpleType> + </xs:attribute> + + <xs:attribute name="base" type="xs:anyURI"> + <xs:annotation> + <xs:documentation>See http://www.w3.org/TR/xmlbase/ for + information about this attribute.</xs:documentation> + </xs:annotation> + </xs:attribute> + + <xs:attributeGroup name="specialAttrs"> + <xs:attribute ref="xml:base"/> + <xs:attribute ref="xml:lang"/> + <xs:attribute ref="xml:space"/> + </xs:attributeGroup> + +</xs:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ecma/fouth-edition/opc-contentTypes.xsd b/.claude/skills/docx/scripts/office/schemas/ecma/fouth-edition/opc-contentTypes.xsd new file mode 100644 index 00000000..dff5513b --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ecma/fouth-edition/opc-contentTypes.xsd @@ -0,0 +1,42 @@ +<?xml version="1.0" encoding="UTF-8" standalone="no"?> +<xs:schema xmlns="http://schemas.openxmlformats.org/package/2006/content-types" + xmlns:xs="http://www.w3.org/2001/XMLSchema" + targetNamespace="http://schemas.openxmlformats.org/package/2006/content-types" + elementFormDefault="qualified" attributeFormDefault="unqualified" blockDefault="#all"> + + <xs:element name="Types" type="CT_Types"/> + <xs:element name="Default" type="CT_Default"/> + <xs:element name="Override" type="CT_Override"/> + + <xs:complexType name="CT_Types"> + <xs:choice minOccurs="0" maxOccurs="unbounded"> + <xs:element ref="Default"/> + <xs:element ref="Override"/> + </xs:choice> + </xs:complexType> + + <xs:complexType name="CT_Default"> + <xs:attribute name="Extension" type="ST_Extension" use="required"/> + <xs:attribute name="ContentType" type="ST_ContentType" use="required"/> + </xs:complexType> + + <xs:complexType name="CT_Override"> + <xs:attribute name="ContentType" type="ST_ContentType" use="required"/> + <xs:attribute name="PartName" type="xs:anyURI" use="required"/> + </xs:complexType> + + <xs:simpleType name="ST_ContentType"> + <xs:restriction base="xs:string"> + <xs:pattern + value="(((([\p{IsBasicLatin}-[\p{Cc}\(\)<>@,;:\\"/\[\]\?=\{\}\s\t]])+))/((([\p{IsBasicLatin}-[\p{Cc}\(\)<>@,;:\\"/\[\]\?=\{\}\s\t]])+))((\s+)*;(\s+)*(((([\p{IsBasicLatin}-[\p{Cc}\(\)<>@,;:\\"/\[\]\?=\{\}\s\t]])+))=((([\p{IsBasicLatin}-[\p{Cc}\(\)<>@,;:\\"/\[\]\?=\{\}\s\t]])+)|("(([\p{IsLatin-1Supplement}\p{IsBasicLatin}-[\p{Cc}"\n\r]]|(\s+))|(\\[\p{IsBasicLatin}]))*"))))*)" + /> + </xs:restriction> + </xs:simpleType> + + <xs:simpleType name="ST_Extension"> + <xs:restriction base="xs:string"> + <xs:pattern + value="([!$&'\(\)\*\+,:=]|(%[0-9a-fA-F][0-9a-fA-F])|[:@]|[a-zA-Z0-9\-_~])+"/> + </xs:restriction> + </xs:simpleType> +</xs:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ecma/fouth-edition/opc-coreProperties.xsd b/.claude/skills/docx/scripts/office/schemas/ecma/fouth-edition/opc-coreProperties.xsd new file mode 100644 index 00000000..7e922612 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ecma/fouth-edition/opc-coreProperties.xsd @@ -0,0 +1,50 @@ +<?xml version="1.0" encoding="UTF-8"?> +<xs:schema targetNamespace="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" + xmlns="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" + xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:dc="http://purl.org/dc/elements/1.1/" + xmlns:dcterms="http://purl.org/dc/terms/" elementFormDefault="qualified" blockDefault="#all"> + + <xs:import namespace="http://purl.org/dc/elements/1.1/" + schemaLocation="http://dublincore.org/schemas/xmls/qdc/2003/04/02/dc.xsd"/> + <xs:import namespace="http://purl.org/dc/terms/" + schemaLocation="http://dublincore.org/schemas/xmls/qdc/2003/04/02/dcterms.xsd"/> + <xs:import id="xml" namespace="http://www.w3.org/XML/1998/namespace"/> + + <xs:element name="coreProperties" type="CT_CoreProperties"/> + + <xs:complexType name="CT_CoreProperties"> + <xs:all> + <xs:element name="category" minOccurs="0" maxOccurs="1" type="xs:string"/> + <xs:element name="contentStatus" minOccurs="0" maxOccurs="1" type="xs:string"/> + <xs:element ref="dcterms:created" minOccurs="0" maxOccurs="1"/> + <xs:element ref="dc:creator" minOccurs="0" maxOccurs="1"/> + <xs:element ref="dc:description" minOccurs="0" maxOccurs="1"/> + <xs:element ref="dc:identifier" minOccurs="0" maxOccurs="1"/> + <xs:element name="keywords" minOccurs="0" maxOccurs="1" type="CT_Keywords"/> + <xs:element ref="dc:language" minOccurs="0" maxOccurs="1"/> + <xs:element name="lastModifiedBy" minOccurs="0" maxOccurs="1" type="xs:string"/> + <xs:element name="lastPrinted" minOccurs="0" maxOccurs="1" type="xs:dateTime"/> + <xs:element ref="dcterms:modified" minOccurs="0" maxOccurs="1"/> + <xs:element name="revision" minOccurs="0" maxOccurs="1" type="xs:string"/> + <xs:element ref="dc:subject" minOccurs="0" maxOccurs="1"/> + <xs:element ref="dc:title" minOccurs="0" maxOccurs="1"/> + <xs:element name="version" minOccurs="0" maxOccurs="1" type="xs:string"/> + </xs:all> + </xs:complexType> + + <xs:complexType name="CT_Keywords" mixed="true"> + <xs:sequence> + <xs:element name="value" minOccurs="0" maxOccurs="unbounded" type="CT_Keyword"/> + </xs:sequence> + <xs:attribute ref="xml:lang" use="optional"/> + </xs:complexType> + + <xs:complexType name="CT_Keyword"> + <xs:simpleContent> + <xs:extension base="xs:string"> + <xs:attribute ref="xml:lang" use="optional"/> + </xs:extension> + </xs:simpleContent> + </xs:complexType> + +</xs:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ecma/fouth-edition/opc-digSig.xsd b/.claude/skills/docx/scripts/office/schemas/ecma/fouth-edition/opc-digSig.xsd new file mode 100644 index 00000000..4248bf7a --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ecma/fouth-edition/opc-digSig.xsd @@ -0,0 +1,49 @@ +<?xml version="1.0" encoding="UTF-8"?> +<xsd:schema xmlns="http://schemas.openxmlformats.org/package/2006/digital-signature" + xmlns:xsd="http://www.w3.org/2001/XMLSchema" + targetNamespace="http://schemas.openxmlformats.org/package/2006/digital-signature" + elementFormDefault="qualified" attributeFormDefault="unqualified" blockDefault="#all"> + + <xsd:element name="SignatureTime" type="CT_SignatureTime"/> + <xsd:element name="RelationshipReference" type="CT_RelationshipReference"/> + <xsd:element name="RelationshipsGroupReference" type="CT_RelationshipsGroupReference"/> + + <xsd:complexType name="CT_SignatureTime"> + <xsd:sequence> + <xsd:element name="Format" type="ST_Format"/> + <xsd:element name="Value" type="ST_Value"/> + </xsd:sequence> + </xsd:complexType> + + <xsd:complexType name="CT_RelationshipReference"> + <xsd:simpleContent> + <xsd:extension base="xsd:string"> + <xsd:attribute name="SourceId" type="xsd:string" use="required"/> + </xsd:extension> + </xsd:simpleContent> + </xsd:complexType> + + <xsd:complexType name="CT_RelationshipsGroupReference"> + <xsd:simpleContent> + <xsd:extension base="xsd:string"> + <xsd:attribute name="SourceType" type="xsd:anyURI" use="required"/> + </xsd:extension> + </xsd:simpleContent> + </xsd:complexType> + + <xsd:simpleType name="ST_Format"> + <xsd:restriction base="xsd:string"> + <xsd:pattern + value="(YYYY)|(YYYY-MM)|(YYYY-MM-DD)|(YYYY-MM-DDThh:mmTZD)|(YYYY-MM-DDThh:mm:ssTZD)|(YYYY-MM-DDThh:mm:ss.sTZD)" + /> + </xsd:restriction> + </xsd:simpleType> + + <xsd:simpleType name="ST_Value"> + <xsd:restriction base="xsd:string"> + <xsd:pattern + value="(([0-9][0-9][0-9][0-9]))|(([0-9][0-9][0-9][0-9])-((0[1-9])|(1(0|1|2))))|(([0-9][0-9][0-9][0-9])-((0[1-9])|(1(0|1|2)))-((0[1-9])|(1[0-9])|(2[0-9])|(3(0|1))))|(([0-9][0-9][0-9][0-9])-((0[1-9])|(1(0|1|2)))-((0[1-9])|(1[0-9])|(2[0-9])|(3(0|1)))T((0[0-9])|(1[0-9])|(2(0|1|2|3))):((0[0-9])|(1[0-9])|(2[0-9])|(3[0-9])|(4[0-9])|(5[0-9]))(((\+|-)((0[0-9])|(1[0-9])|(2(0|1|2|3))):((0[0-9])|(1[0-9])|(2[0-9])|(3[0-9])|(4[0-9])|(5[0-9])))|Z))|(([0-9][0-9][0-9][0-9])-((0[1-9])|(1(0|1|2)))-((0[1-9])|(1[0-9])|(2[0-9])|(3(0|1)))T((0[0-9])|(1[0-9])|(2(0|1|2|3))):((0[0-9])|(1[0-9])|(2[0-9])|(3[0-9])|(4[0-9])|(5[0-9])):((0[0-9])|(1[0-9])|(2[0-9])|(3[0-9])|(4[0-9])|(5[0-9]))(((\+|-)((0[0-9])|(1[0-9])|(2(0|1|2|3))):((0[0-9])|(1[0-9])|(2[0-9])|(3[0-9])|(4[0-9])|(5[0-9])))|Z))|(([0-9][0-9][0-9][0-9])-((0[1-9])|(1(0|1|2)))-((0[1-9])|(1[0-9])|(2[0-9])|(3(0|1)))T((0[0-9])|(1[0-9])|(2(0|1|2|3))):((0[0-9])|(1[0-9])|(2[0-9])|(3[0-9])|(4[0-9])|(5[0-9])):(((0[0-9])|(1[0-9])|(2[0-9])|(3[0-9])|(4[0-9])|(5[0-9]))\.[0-9])(((\+|-)((0[0-9])|(1[0-9])|(2(0|1|2|3))):((0[0-9])|(1[0-9])|(2[0-9])|(3[0-9])|(4[0-9])|(5[0-9])))|Z))" + /> + </xsd:restriction> + </xsd:simpleType> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/ecma/fouth-edition/opc-relationships.xsd b/.claude/skills/docx/scripts/office/schemas/ecma/fouth-edition/opc-relationships.xsd new file mode 100644 index 00000000..9c2c17df --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/ecma/fouth-edition/opc-relationships.xsd @@ -0,0 +1,33 @@ +<?xml version="1.0" encoding="UTF-8" standalone="no"?> +<xsd:schema xmlns="http://schemas.openxmlformats.org/package/2006/relationships" + xmlns:xsd="http://www.w3.org/2001/XMLSchema" + targetNamespace="http://schemas.openxmlformats.org/package/2006/relationships" + elementFormDefault="qualified" attributeFormDefault="unqualified" blockDefault="#all"> + + <xsd:element name="Relationships" type="CT_Relationships"/> + <xsd:element name="Relationship" type="CT_Relationship"/> + + <xsd:complexType name="CT_Relationships"> + <xsd:sequence> + <xsd:element ref="Relationship" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + + <xsd:complexType name="CT_Relationship"> + <xsd:simpleContent> + <xsd:extension base="xsd:string"> + <xsd:attribute name="TargetMode" type="ST_TargetMode" use="optional"/> + <xsd:attribute name="Target" type="xsd:anyURI" use="required"/> + <xsd:attribute name="Type" type="xsd:anyURI" use="required"/> + <xsd:attribute name="Id" type="xsd:ID" use="required"/> + </xsd:extension> + </xsd:simpleContent> + </xsd:complexType> + + <xsd:simpleType name="ST_TargetMode"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="External"/> + <xsd:enumeration value="Internal"/> + </xsd:restriction> + </xsd:simpleType> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/mce/mc.xsd b/.claude/skills/docx/scripts/office/schemas/mce/mc.xsd new file mode 100644 index 00000000..ef725457 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/mce/mc.xsd @@ -0,0 +1,75 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsd:schema xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" + attributeFormDefault="unqualified" elementFormDefault="qualified" + targetNamespace="http://schemas.openxmlformats.org/markup-compatibility/2006" + xmlns:xsd="http://www.w3.org/2001/XMLSchema"> + + <!-- + This XSD is a modified version of the one found at: + https://github.com/plutext/docx4j/blob/master/xsd/mce/markup-compatibility-2006-MINIMAL.xsd + + This XSD has 2 objectives: + + 1. round tripping @mc:Ignorable + + <w:document + xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" + xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" + mc:Ignorable="w14 w15 wp14"> + + 2. enabling AlternateContent to be manipulated in certain elements + (in the unusual case where the content model is xsd:any, it doesn't have to be explicitly added) + + See further ECMA-376, 4th Edition, Office Open XML File Formats + Part 3 : Markup Compatibility and Extensibility + --> + + <!-- Objective 1 --> + <xsd:attribute name="Ignorable" type="xsd:string" /> + + <!-- Objective 2 --> + <xsd:attribute name="MustUnderstand" type="xsd:string" /> + <xsd:attribute name="ProcessContent" type="xsd:string" /> + +<!-- An AlternateContent element shall contain one or more Choice child elements, optionally followed by a +Fallback child element. If present, there shall be only one Fallback element, and it shall follow all Choice +elements. --> + <xsd:element name="AlternateContent"> + <xsd:complexType> + <xsd:sequence> + <xsd:element name="Choice" minOccurs="0" maxOccurs="unbounded"> + <xsd:complexType> + <xsd:sequence> + <xsd:any minOccurs="0" maxOccurs="unbounded" + processContents="strict"> + </xsd:any> + </xsd:sequence> + <xsd:attribute name="Requires" type="xsd:string" use="required" /> + <xsd:attribute ref="mc:Ignorable" use="optional" /> + <xsd:attribute ref="mc:MustUnderstand" use="optional" /> + <xsd:attribute ref="mc:ProcessContent" use="optional" /> + </xsd:complexType> + </xsd:element> + <xsd:element name="Fallback" minOccurs="0" maxOccurs="1"> + <xsd:complexType> + <xsd:sequence> + <xsd:any minOccurs="0" maxOccurs="unbounded" + processContents="strict"> + </xsd:any> + </xsd:sequence> + <xsd:attribute ref="mc:Ignorable" use="optional" /> + <xsd:attribute ref="mc:MustUnderstand" use="optional" /> + <xsd:attribute ref="mc:ProcessContent" use="optional" /> + </xsd:complexType> + </xsd:element> + </xsd:sequence> + <!-- AlternateContent elements might include the attributes Ignorable, + MustUnderstand and ProcessContent described in this Part of ECMA-376. These + attributes’ qualified names shall be prefixed when associated with an AlternateContent + element. --> + <xsd:attribute ref="mc:Ignorable" use="optional" /> + <xsd:attribute ref="mc:MustUnderstand" use="optional" /> + <xsd:attribute ref="mc:ProcessContent" use="optional" /> + </xsd:complexType> + </xsd:element> +</xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/microsoft/wml-2010.xsd b/.claude/skills/docx/scripts/office/schemas/microsoft/wml-2010.xsd new file mode 100644 index 00000000..f65f7777 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/microsoft/wml-2010.xsd @@ -0,0 +1,560 @@ + <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:w12="http://schemas.openxmlformats.org/wordprocessingml/2006/main" elementFormDefault="qualified" attributeFormDefault="qualified" blockDefault="#all" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:s="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns="http://schemas.microsoft.com/office/word/2010/wordml" targetNamespace="http://schemas.microsoft.com/office/word/2010/wordml"> + <!-- <xsd:import id="rel" namespace="http://schemas.openxmlformats.org/officeDocument/2006/relationships" schemaLocation="orel.xsd"/> --> + <xsd:import id="w" namespace="http://schemas.openxmlformats.org/wordprocessingml/2006/main" schemaLocation="../ISO-IEC29500-4_2016/wml.xsd"/> + <!-- <xsd:import namespace="http://schemas.openxmlformats.org/drawingml/2006/main" schemaLocation="oartbasetypes.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/drawingml/2006/main" schemaLocation="oartsplineproperties.xsd"/> --> + <xsd:complexType name="CT_LongHexNumber"> + <xsd:attribute name="val" type="w:ST_LongHexNumber" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_OnOff"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="true"/> + <xsd:enumeration value="false"/> + <xsd:enumeration value="0"/> + <xsd:enumeration value="1"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_OnOff"> + <xsd:attribute name="val" type="ST_OnOff"/> + </xsd:complexType> + <xsd:element name="docId" type="CT_LongHexNumber"/> + <xsd:element name="conflictMode" type="CT_OnOff"/> + <xsd:attributeGroup name="AG_Parids"> + <xsd:attribute name="paraId" type="w:ST_LongHexNumber"/> + <xsd:attribute name="textId" type="w:ST_LongHexNumber"/> + </xsd:attributeGroup> + <xsd:attribute name="anchorId" type="w:ST_LongHexNumber"/> + <xsd:attribute name="noSpellErr" type="ST_OnOff"/> + <xsd:element name="customXmlConflictInsRangeStart" type="w:CT_TrackChange"/> + <xsd:element name="customXmlConflictInsRangeEnd" type="w:CT_Markup"/> + <xsd:element name="customXmlConflictDelRangeStart" type="w:CT_TrackChange"/> + <xsd:element name="customXmlConflictDelRangeEnd" type="w:CT_Markup"/> + <xsd:group name="EG_RunLevelConflicts"> + <xsd:sequence> + <xsd:element name="conflictIns" type="w:CT_RunTrackChange" minOccurs="0"/> + <xsd:element name="conflictDel" type="w:CT_RunTrackChange" minOccurs="0"/> + </xsd:sequence> + </xsd:group> + <xsd:group name="EG_Conflicts"> + <xsd:choice> + <xsd:element name="conflictIns" type="w:CT_TrackChange" minOccurs="0"/> + <xsd:element name="conflictDel" type="w:CT_TrackChange" minOccurs="0"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_Percentage"> + <xsd:attribute name="val" type="a:ST_Percentage" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_PositiveFixedPercentage"> + <xsd:attribute name="val" type="a:ST_PositiveFixedPercentage" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_PositivePercentage"> + <xsd:attribute name="val" type="a:ST_PositivePercentage" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_SchemeColorVal"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="bg1"/> + <xsd:enumeration value="tx1"/> + <xsd:enumeration value="bg2"/> + <xsd:enumeration value="tx2"/> + <xsd:enumeration value="accent1"/> + <xsd:enumeration value="accent2"/> + <xsd:enumeration value="accent3"/> + <xsd:enumeration value="accent4"/> + <xsd:enumeration value="accent5"/> + <xsd:enumeration value="accent6"/> + <xsd:enumeration value="hlink"/> + <xsd:enumeration value="folHlink"/> + <xsd:enumeration value="dk1"/> + <xsd:enumeration value="lt1"/> + <xsd:enumeration value="dk2"/> + <xsd:enumeration value="lt2"/> + <xsd:enumeration value="phClr"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_RectAlignment"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="tl"/> + <xsd:enumeration value="t"/> + <xsd:enumeration value="tr"/> + <xsd:enumeration value="l"/> + <xsd:enumeration value="ctr"/> + <xsd:enumeration value="r"/> + <xsd:enumeration value="bl"/> + <xsd:enumeration value="b"/> + <xsd:enumeration value="br"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_PathShadeType"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="shape"/> + <xsd:enumeration value="circle"/> + <xsd:enumeration value="rect"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_LineCap"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="rnd"/> + <xsd:enumeration value="sq"/> + <xsd:enumeration value="flat"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_PresetLineDashVal"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="solid"/> + <xsd:enumeration value="dot"/> + <xsd:enumeration value="sysDot"/> + <xsd:enumeration value="dash"/> + <xsd:enumeration value="sysDash"/> + <xsd:enumeration value="lgDash"/> + <xsd:enumeration value="dashDot"/> + <xsd:enumeration value="sysDashDot"/> + <xsd:enumeration value="lgDashDot"/> + <xsd:enumeration value="lgDashDotDot"/> + <xsd:enumeration value="sysDashDotDot"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_PenAlignment"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="ctr"/> + <xsd:enumeration value="in"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_CompoundLine"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="sng"/> + <xsd:enumeration value="dbl"/> + <xsd:enumeration value="thickThin"/> + <xsd:enumeration value="thinThick"/> + <xsd:enumeration value="tri"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_RelativeRect"> + <xsd:attribute name="l" use="optional" type="a:ST_Percentage"/> + <xsd:attribute name="t" use="optional" type="a:ST_Percentage"/> + <xsd:attribute name="r" use="optional" type="a:ST_Percentage"/> + <xsd:attribute name="b" use="optional" type="a:ST_Percentage"/> + </xsd:complexType> + <xsd:group name="EG_ColorTransform"> + <xsd:choice> + <xsd:element name="tint" type="CT_PositiveFixedPercentage"/> + <xsd:element name="shade" type="CT_PositiveFixedPercentage"/> + <xsd:element name="alpha" type="CT_PositiveFixedPercentage"/> + <xsd:element name="hueMod" type="CT_PositivePercentage"/> + <xsd:element name="sat" type="CT_Percentage"/> + <xsd:element name="satOff" type="CT_Percentage"/> + <xsd:element name="satMod" type="CT_Percentage"/> + <xsd:element name="lum" type="CT_Percentage"/> + <xsd:element name="lumOff" type="CT_Percentage"/> + <xsd:element name="lumMod" type="CT_Percentage"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_SRgbColor"> + <xsd:sequence> + <xsd:group ref="EG_ColorTransform" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="val" type="s:ST_HexColorRGB" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_SchemeColor"> + <xsd:sequence> + <xsd:group ref="EG_ColorTransform" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + <xsd:attribute name="val" type="ST_SchemeColorVal" use="required"/> + </xsd:complexType> + <xsd:group name="EG_ColorChoice"> + <xsd:choice> + <xsd:element name="srgbClr" type="CT_SRgbColor"/> + <xsd:element name="schemeClr" type="CT_SchemeColor"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_Color"> + <xsd:sequence> + <xsd:group ref="EG_ColorChoice"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_GradientStop"> + <xsd:sequence> + <xsd:group ref="EG_ColorChoice"/> + </xsd:sequence> + <xsd:attribute name="pos" type="a:ST_PositiveFixedPercentage" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_GradientStopList"> + <xsd:sequence> + <xsd:element name="gs" type="CT_GradientStop" minOccurs="2" maxOccurs="10"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_LinearShadeProperties"> + <xsd:attribute name="ang" type="a:ST_PositiveFixedAngle" use="optional"/> + <xsd:attribute name="scaled" type="ST_OnOff" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_PathShadeProperties"> + <xsd:sequence> + <xsd:element name="fillToRect" type="CT_RelativeRect" minOccurs="0"/> + </xsd:sequence> + <xsd:attribute name="path" type="ST_PathShadeType" use="optional"/> + </xsd:complexType> + <xsd:group name="EG_ShadeProperties"> + <xsd:choice> + <xsd:element name="lin" type="CT_LinearShadeProperties"/> + <xsd:element name="path" type="CT_PathShadeProperties"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_SolidColorFillProperties"> + <xsd:sequence> + <xsd:group ref="EG_ColorChoice" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_GradientFillProperties"> + <xsd:sequence> + <xsd:element name="gsLst" type="CT_GradientStopList" minOccurs="0"/> + <xsd:group ref="EG_ShadeProperties" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:group name="EG_FillProperties"> + <xsd:choice> + <xsd:element name="noFill" type="w:CT_Empty"/> + <xsd:element name="solidFill" type="CT_SolidColorFillProperties"/> + <xsd:element name="gradFill" type="CT_GradientFillProperties"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_PresetLineDashProperties"> + <xsd:attribute name="val" type="ST_PresetLineDashVal" use="optional"/> + </xsd:complexType> + <xsd:group name="EG_LineDashProperties"> + <xsd:choice> + <xsd:element name="prstDash" type="CT_PresetLineDashProperties"/> + </xsd:choice> + </xsd:group> + <xsd:complexType name="CT_LineJoinMiterProperties"> + <xsd:attribute name="lim" type="a:ST_PositivePercentage" use="optional"/> + </xsd:complexType> + <xsd:group name="EG_LineJoinProperties"> + <xsd:choice> + <xsd:element name="round" type="w:CT_Empty"/> + <xsd:element name="bevel" type="w:CT_Empty"/> + <xsd:element name="miter" type="CT_LineJoinMiterProperties"/> + </xsd:choice> + </xsd:group> + <xsd:simpleType name="ST_PresetCameraType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="legacyObliqueTopLeft"/> + <xsd:enumeration value="legacyObliqueTop"/> + <xsd:enumeration value="legacyObliqueTopRight"/> + <xsd:enumeration value="legacyObliqueLeft"/> + <xsd:enumeration value="legacyObliqueFront"/> + <xsd:enumeration value="legacyObliqueRight"/> + <xsd:enumeration value="legacyObliqueBottomLeft"/> + <xsd:enumeration value="legacyObliqueBottom"/> + <xsd:enumeration value="legacyObliqueBottomRight"/> + <xsd:enumeration value="legacyPerspectiveTopLeft"/> + <xsd:enumeration value="legacyPerspectiveTop"/> + <xsd:enumeration value="legacyPerspectiveTopRight"/> + <xsd:enumeration value="legacyPerspectiveLeft"/> + <xsd:enumeration value="legacyPerspectiveFront"/> + <xsd:enumeration value="legacyPerspectiveRight"/> + <xsd:enumeration value="legacyPerspectiveBottomLeft"/> + <xsd:enumeration value="legacyPerspectiveBottom"/> + <xsd:enumeration value="legacyPerspectiveBottomRight"/> + <xsd:enumeration value="orthographicFront"/> + <xsd:enumeration value="isometricTopUp"/> + <xsd:enumeration value="isometricTopDown"/> + <xsd:enumeration value="isometricBottomUp"/> + <xsd:enumeration value="isometricBottomDown"/> + <xsd:enumeration value="isometricLeftUp"/> + <xsd:enumeration value="isometricLeftDown"/> + <xsd:enumeration value="isometricRightUp"/> + <xsd:enumeration value="isometricRightDown"/> + <xsd:enumeration value="isometricOffAxis1Left"/> + <xsd:enumeration value="isometricOffAxis1Right"/> + <xsd:enumeration value="isometricOffAxis1Top"/> + <xsd:enumeration value="isometricOffAxis2Left"/> + <xsd:enumeration value="isometricOffAxis2Right"/> + <xsd:enumeration value="isometricOffAxis2Top"/> + <xsd:enumeration value="isometricOffAxis3Left"/> + <xsd:enumeration value="isometricOffAxis3Right"/> + <xsd:enumeration value="isometricOffAxis3Bottom"/> + <xsd:enumeration value="isometricOffAxis4Left"/> + <xsd:enumeration value="isometricOffAxis4Right"/> + <xsd:enumeration value="isometricOffAxis4Bottom"/> + <xsd:enumeration value="obliqueTopLeft"/> + <xsd:enumeration value="obliqueTop"/> + <xsd:enumeration value="obliqueTopRight"/> + <xsd:enumeration value="obliqueLeft"/> + <xsd:enumeration value="obliqueRight"/> + <xsd:enumeration value="obliqueBottomLeft"/> + <xsd:enumeration value="obliqueBottom"/> + <xsd:enumeration value="obliqueBottomRight"/> + <xsd:enumeration value="perspectiveFront"/> + <xsd:enumeration value="perspectiveLeft"/> + <xsd:enumeration value="perspectiveRight"/> + <xsd:enumeration value="perspectiveAbove"/> + <xsd:enumeration value="perspectiveBelow"/> + <xsd:enumeration value="perspectiveAboveLeftFacing"/> + <xsd:enumeration value="perspectiveAboveRightFacing"/> + <xsd:enumeration value="perspectiveContrastingLeftFacing"/> + <xsd:enumeration value="perspectiveContrastingRightFacing"/> + <xsd:enumeration value="perspectiveHeroicLeftFacing"/> + <xsd:enumeration value="perspectiveHeroicRightFacing"/> + <xsd:enumeration value="perspectiveHeroicExtremeLeftFacing"/> + <xsd:enumeration value="perspectiveHeroicExtremeRightFacing"/> + <xsd:enumeration value="perspectiveRelaxed"/> + <xsd:enumeration value="perspectiveRelaxedModerately"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Camera"> + <xsd:attribute name="prst" use="required" type="ST_PresetCameraType"/> + </xsd:complexType> + <xsd:complexType name="CT_SphereCoords"> + <xsd:attribute name="lat" type="a:ST_PositiveFixedAngle" use="required"/> + <xsd:attribute name="lon" type="a:ST_PositiveFixedAngle" use="required"/> + <xsd:attribute name="rev" type="a:ST_PositiveFixedAngle" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_LightRigType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="legacyFlat1"/> + <xsd:enumeration value="legacyFlat2"/> + <xsd:enumeration value="legacyFlat3"/> + <xsd:enumeration value="legacyFlat4"/> + <xsd:enumeration value="legacyNormal1"/> + <xsd:enumeration value="legacyNormal2"/> + <xsd:enumeration value="legacyNormal3"/> + <xsd:enumeration value="legacyNormal4"/> + <xsd:enumeration value="legacyHarsh1"/> + <xsd:enumeration value="legacyHarsh2"/> + <xsd:enumeration value="legacyHarsh3"/> + <xsd:enumeration value="legacyHarsh4"/> + <xsd:enumeration value="threePt"/> + <xsd:enumeration value="balanced"/> + <xsd:enumeration value="soft"/> + <xsd:enumeration value="harsh"/> + <xsd:enumeration value="flood"/> + <xsd:enumeration value="contrasting"/> + <xsd:enumeration value="morning"/> + <xsd:enumeration value="sunrise"/> + <xsd:enumeration value="sunset"/> + <xsd:enumeration value="chilly"/> + <xsd:enumeration value="freezing"/> + <xsd:enumeration value="flat"/> + <xsd:enumeration value="twoPt"/> + <xsd:enumeration value="glow"/> + <xsd:enumeration value="brightRoom"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:simpleType name="ST_LightRigDirection"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="tl"/> + <xsd:enumeration value="t"/> + <xsd:enumeration value="tr"/> + <xsd:enumeration value="l"/> + <xsd:enumeration value="r"/> + <xsd:enumeration value="bl"/> + <xsd:enumeration value="b"/> + <xsd:enumeration value="br"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_LightRig"> + <xsd:sequence> + <xsd:element name="rot" type="CT_SphereCoords" minOccurs="0"/> + </xsd:sequence> + <xsd:attribute name="rig" type="ST_LightRigType" use="required"/> + <xsd:attribute name="dir" type="ST_LightRigDirection" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_BevelPresetType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="relaxedInset"/> + <xsd:enumeration value="circle"/> + <xsd:enumeration value="slope"/> + <xsd:enumeration value="cross"/> + <xsd:enumeration value="angle"/> + <xsd:enumeration value="softRound"/> + <xsd:enumeration value="convex"/> + <xsd:enumeration value="coolSlant"/> + <xsd:enumeration value="divot"/> + <xsd:enumeration value="riblet"/> + <xsd:enumeration value="hardEdge"/> + <xsd:enumeration value="artDeco"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Bevel"> + <xsd:attribute name="w" type="a:ST_PositiveCoordinate" use="optional"/> + <xsd:attribute name="h" type="a:ST_PositiveCoordinate" use="optional"/> + <xsd:attribute name="prst" type="ST_BevelPresetType" use="optional"/> + </xsd:complexType> + <xsd:simpleType name="ST_PresetMaterialType"> + <xsd:restriction base="xsd:token"> + <xsd:enumeration value="legacyMatte"/> + <xsd:enumeration value="legacyPlastic"/> + <xsd:enumeration value="legacyMetal"/> + <xsd:enumeration value="legacyWireframe"/> + <xsd:enumeration value="matte"/> + <xsd:enumeration value="plastic"/> + <xsd:enumeration value="metal"/> + <xsd:enumeration value="warmMatte"/> + <xsd:enumeration value="translucentPowder"/> + <xsd:enumeration value="powder"/> + <xsd:enumeration value="dkEdge"/> + <xsd:enumeration value="softEdge"/> + <xsd:enumeration value="clear"/> + <xsd:enumeration value="flat"/> + <xsd:enumeration value="softmetal"/> + <xsd:enumeration value="none"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Glow"> + <xsd:sequence> + <xsd:group ref="EG_ColorChoice"/> + </xsd:sequence> + <xsd:attribute name="rad" use="optional" type="a:ST_PositiveCoordinate"/> + </xsd:complexType> + <xsd:complexType name="CT_Shadow"> + <xsd:sequence> + <xsd:group ref="EG_ColorChoice"/> + </xsd:sequence> + <xsd:attribute name="blurRad" use="optional" type="a:ST_PositiveCoordinate"/> + <xsd:attribute name="dist" use="optional" type="a:ST_PositiveCoordinate"/> + <xsd:attribute name="dir" use="optional" type="a:ST_PositiveFixedAngle"/> + <xsd:attribute name="sx" use="optional" type="a:ST_Percentage"/> + <xsd:attribute name="sy" use="optional" type="a:ST_Percentage"/> + <xsd:attribute name="kx" use="optional" type="a:ST_FixedAngle"/> + <xsd:attribute name="ky" use="optional" type="a:ST_FixedAngle"/> + <xsd:attribute name="algn" use="optional" type="ST_RectAlignment"/> + </xsd:complexType> + <xsd:complexType name="CT_Reflection"> + <xsd:attribute name="blurRad" use="optional" type="a:ST_PositiveCoordinate"/> + <xsd:attribute name="stA" use="optional" type="a:ST_PositiveFixedPercentage"/> + <xsd:attribute name="stPos" use="optional" type="a:ST_PositiveFixedPercentage"/> + <xsd:attribute name="endA" use="optional" type="a:ST_PositiveFixedPercentage"/> + <xsd:attribute name="endPos" use="optional" type="a:ST_PositiveFixedPercentage"/> + <xsd:attribute name="dist" use="optional" type="a:ST_PositiveCoordinate"/> + <xsd:attribute name="dir" use="optional" type="a:ST_PositiveFixedAngle"/> + <xsd:attribute name="fadeDir" use="optional" type="a:ST_PositiveFixedAngle"/> + <xsd:attribute name="sx" use="optional" type="a:ST_Percentage"/> + <xsd:attribute name="sy" use="optional" type="a:ST_Percentage"/> + <xsd:attribute name="kx" use="optional" type="a:ST_FixedAngle"/> + <xsd:attribute name="ky" use="optional" type="a:ST_FixedAngle"/> + <xsd:attribute name="algn" use="optional" type="ST_RectAlignment"/> + </xsd:complexType> + <xsd:complexType name="CT_FillTextEffect"> + <xsd:sequence> + <xsd:group ref="EG_FillProperties" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_TextOutlineEffect"> + <xsd:sequence> + <xsd:group ref="EG_FillProperties" minOccurs="0"/> + <xsd:group ref="EG_LineDashProperties" minOccurs="0"/> + <xsd:group ref="EG_LineJoinProperties" minOccurs="0"/> + </xsd:sequence> + <xsd:attribute name="w" use="optional" type="a:ST_LineWidth"/> + <xsd:attribute name="cap" use="optional" type="ST_LineCap"/> + <xsd:attribute name="cmpd" use="optional" type="ST_CompoundLine"/> + <xsd:attribute name="algn" use="optional" type="ST_PenAlignment"/> + </xsd:complexType> + <xsd:complexType name="CT_Scene3D"> + <xsd:sequence> + <xsd:element name="camera" type="CT_Camera"/> + <xsd:element name="lightRig" type="CT_LightRig"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_Props3D"> + <xsd:sequence> + <xsd:element name="bevelT" type="CT_Bevel" minOccurs="0"/> + <xsd:element name="bevelB" type="CT_Bevel" minOccurs="0"/> + <xsd:element name="extrusionClr" type="CT_Color" minOccurs="0"/> + <xsd:element name="contourClr" type="CT_Color" minOccurs="0"/> + </xsd:sequence> + <xsd:attribute name="extrusionH" type="a:ST_PositiveCoordinate" use="optional"/> + <xsd:attribute name="contourW" type="a:ST_PositiveCoordinate" use="optional"/> + <xsd:attribute name="prstMaterial" type="ST_PresetMaterialType" use="optional"/> + </xsd:complexType> + <xsd:group name="EG_RPrTextEffects"> + <xsd:sequence> + <xsd:element name="glow" minOccurs="0" type="CT_Glow"/> + <xsd:element name="shadow" minOccurs="0" type="CT_Shadow"/> + <xsd:element name="reflection" minOccurs="0" type="CT_Reflection"/> + <xsd:element name="textOutline" minOccurs="0" type="CT_TextOutlineEffect"/> + <xsd:element name="textFill" minOccurs="0" type="CT_FillTextEffect"/> + <xsd:element name="scene3d" minOccurs="0" type="CT_Scene3D"/> + <xsd:element name="props3d" minOccurs="0" type="CT_Props3D"/> + </xsd:sequence> + </xsd:group> + <xsd:simpleType name="ST_Ligatures"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="none"/> + <xsd:enumeration value="standard"/> + <xsd:enumeration value="contextual"/> + <xsd:enumeration value="historical"/> + <xsd:enumeration value="discretional"/> + <xsd:enumeration value="standardContextual"/> + <xsd:enumeration value="standardHistorical"/> + <xsd:enumeration value="contextualHistorical"/> + <xsd:enumeration value="standardDiscretional"/> + <xsd:enumeration value="contextualDiscretional"/> + <xsd:enumeration value="historicalDiscretional"/> + <xsd:enumeration value="standardContextualHistorical"/> + <xsd:enumeration value="standardContextualDiscretional"/> + <xsd:enumeration value="standardHistoricalDiscretional"/> + <xsd:enumeration value="contextualHistoricalDiscretional"/> + <xsd:enumeration value="all"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Ligatures"> + <xsd:attribute name="val" type="ST_Ligatures" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_NumForm"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="default"/> + <xsd:enumeration value="lining"/> + <xsd:enumeration value="oldStyle"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_NumForm"> + <xsd:attribute name="val" type="ST_NumForm" use="required"/> + </xsd:complexType> + <xsd:simpleType name="ST_NumSpacing"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="default"/> + <xsd:enumeration value="proportional"/> + <xsd:enumeration value="tabular"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_NumSpacing"> + <xsd:attribute name="val" type="ST_NumSpacing" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_StyleSet"> + <xsd:attribute name="id" type="s:ST_UnsignedDecimalNumber" use="required"/> + <xsd:attribute name="val" type="ST_OnOff" use="optional"/> + </xsd:complexType> + <xsd:complexType name="CT_StylisticSets"> + <xsd:sequence minOccurs="0"> + <xsd:element name="styleSet" minOccurs="0" maxOccurs="unbounded" type="CT_StyleSet"/> + </xsd:sequence> + </xsd:complexType> + <xsd:group name="EG_RPrOpenType"> + <xsd:sequence> + <xsd:element name="ligatures" minOccurs="0" type="CT_Ligatures"/> + <xsd:element name="numForm" minOccurs="0" type="CT_NumForm"/> + <xsd:element name="numSpacing" minOccurs="0" type="CT_NumSpacing"/> + <xsd:element name="stylisticSets" minOccurs="0" type="CT_StylisticSets"/> + <xsd:element name="cntxtAlts" minOccurs="0" type="CT_OnOff"/> + </xsd:sequence> + </xsd:group> + <xsd:element name="discardImageEditingData" type="CT_OnOff"/> + <xsd:element name="defaultImageDpi" type="CT_DefaultImageDpi"/> + <xsd:complexType name="CT_DefaultImageDpi"> + <xsd:attribute name="val" type="w:ST_DecimalNumber" use="required"/> + </xsd:complexType> + <xsd:element name="entityPicker" type="w:CT_Empty"/> + <xsd:complexType name="CT_SdtCheckboxSymbol"> + <xsd:attribute name="font" type="s:ST_String"/> + <xsd:attribute name="val" type="w:ST_ShortHexNumber"/> + </xsd:complexType> + <xsd:complexType name="CT_SdtCheckbox"> + <xsd:sequence> + <xsd:element name="checked" type="CT_OnOff" minOccurs="0"/> + <xsd:element name="checkedState" type="CT_SdtCheckboxSymbol" minOccurs="0"/> + <xsd:element name="uncheckedState" type="CT_SdtCheckboxSymbol" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:element name="checkbox" type="CT_SdtCheckbox"/> + </xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/microsoft/wml-2012.xsd b/.claude/skills/docx/scripts/office/schemas/microsoft/wml-2012.xsd new file mode 100644 index 00000000..6b00755a --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/microsoft/wml-2012.xsd @@ -0,0 +1,67 @@ + <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:w12="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:s="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" elementFormDefault="qualified" attributeFormDefault="qualified" blockDefault="#all" xmlns="http://schemas.microsoft.com/office/word/2012/wordml" targetNamespace="http://schemas.microsoft.com/office/word/2012/wordml"> + <xsd:import id="w12" namespace="http://schemas.openxmlformats.org/wordprocessingml/2006/main" schemaLocation="../ISO-IEC29500-4_2016/wml.xsd"/> + <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" schemaLocation="../ISO-IEC29500-4_2016/shared-commonSimpleTypes.xsd"/> + <xsd:element name="color" type="w12:CT_Color"/> + <xsd:simpleType name="ST_SdtAppearance"> + <xsd:restriction base="xsd:string"> + <xsd:enumeration value="boundingBox"/> + <xsd:enumeration value="tags"/> + <xsd:enumeration value="hidden"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:element name="dataBinding" type="w12:CT_DataBinding"/> + <xsd:complexType name="CT_SdtAppearance"> + <xsd:attribute name="val" type="ST_SdtAppearance"/> + </xsd:complexType> + <xsd:element name="appearance" type="CT_SdtAppearance"/> + <xsd:complexType name="CT_CommentsEx"> + <xsd:sequence> + <xsd:element name="commentEx" type="CT_CommentEx" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_CommentEx"> + <xsd:attribute name="paraId" type="w12:ST_LongHexNumber" use="required"/> + <xsd:attribute name="paraIdParent" type="w12:ST_LongHexNumber" use="optional"/> + <xsd:attribute name="done" type="s:ST_OnOff" use="optional"/> + </xsd:complexType> + <xsd:element name="commentsEx" type="CT_CommentsEx"/> + <xsd:complexType name="CT_People"> + <xsd:sequence> + <xsd:element name="person" type="CT_Person" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_PresenceInfo"> + <xsd:attribute name="providerId" type="xsd:string" use="required"/> + <xsd:attribute name="userId" type="xsd:string" use="required"/> + </xsd:complexType> + <xsd:complexType name="CT_Person"> + <xsd:sequence> + <xsd:element name="presenceInfo" type="CT_PresenceInfo" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="author" type="s:ST_String" use="required"/> + </xsd:complexType> + <xsd:element name="people" type="CT_People"/> + <xsd:complexType name="CT_SdtRepeatedSection"> + <xsd:sequence> + <xsd:element name="sectionTitle" type="w12:CT_String" minOccurs="0"/> + <xsd:element name="doNotAllowInsertDeleteSection" type="w12:CT_OnOff" minOccurs="0"/> + </xsd:sequence> + </xsd:complexType> + <xsd:simpleType name="ST_Guid"> + <xsd:restriction base="xsd:token"> + <xsd:pattern value="\{[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}\}"/> + </xsd:restriction> + </xsd:simpleType> + <xsd:complexType name="CT_Guid"> + <xsd:attribute name="val" type="ST_Guid"/> + </xsd:complexType> + <xsd:element name="repeatingSection" type="CT_SdtRepeatedSection"/> + <xsd:element name="repeatingSectionItem" type="w12:CT_Empty"/> + <xsd:element name="chartTrackingRefBased" type="w12:CT_OnOff"/> + <xsd:element name="collapsed" type="w12:CT_OnOff"/> + <xsd:element name="docId" type="CT_Guid"/> + <xsd:element name="footnoteColumns" type="w12:CT_DecimalNumber"/> + <xsd:element name="webExtensionLinked" type="w12:CT_OnOff"/> + <xsd:element name="webExtensionCreated" type="w12:CT_OnOff"/> + <xsd:attribute name="restartNumberingAfterBreak" type="s:ST_OnOff"/> + </xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/microsoft/wml-2018.xsd b/.claude/skills/docx/scripts/office/schemas/microsoft/wml-2018.xsd new file mode 100644 index 00000000..f321d333 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/microsoft/wml-2018.xsd @@ -0,0 +1,14 @@ + <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:w12="http://schemas.openxmlformats.org/wordprocessingml/2006/main" elementFormDefault="qualified" attributeFormDefault="qualified" blockDefault="#all" xmlns="http://schemas.microsoft.com/office/word/2018/wordml" targetNamespace="http://schemas.microsoft.com/office/word/2018/wordml"> + <xsd:import id="w12" namespace="http://schemas.openxmlformats.org/wordprocessingml/2006/main" schemaLocation="../ISO-IEC29500-4_2016/wml.xsd"/> + <xsd:complexType name="CT_Extension"> + <xsd:sequence> + <xsd:any processContents="lax"/> + </xsd:sequence> + <xsd:attribute name="uri" type="xsd:token"/> + </xsd:complexType> + <xsd:complexType name="CT_ExtensionList"> + <xsd:sequence> + <xsd:element name="ext" type="CT_Extension" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + </xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/microsoft/wml-cex-2018.xsd b/.claude/skills/docx/scripts/office/schemas/microsoft/wml-cex-2018.xsd new file mode 100644 index 00000000..364c6a9b --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/microsoft/wml-cex-2018.xsd @@ -0,0 +1,20 @@ + <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:s="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" xmlns:w16="http://schemas.microsoft.com/office/word/2018/wordml" elementFormDefault="qualified" attributeFormDefault="qualified" blockDefault="#all" xmlns="http://schemas.microsoft.com/office/word/2018/wordml/cex" targetNamespace="http://schemas.microsoft.com/office/word/2018/wordml/cex"> + <xsd:import id="w16" namespace="http://schemas.microsoft.com/office/word/2018/wordml" schemaLocation="wml-2018.xsd"/> + <xsd:import id="w" namespace="http://schemas.openxmlformats.org/wordprocessingml/2006/main" schemaLocation="../ISO-IEC29500-4_2016/wml.xsd"/> + <xsd:import id="s" namespace="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" schemaLocation="../ISO-IEC29500-4_2016/shared-commonSimpleTypes.xsd"/> + <xsd:complexType name="CT_CommentsExtensible"> + <xsd:sequence> + <xsd:element name="commentExtensible" type="CT_CommentExtensible" minOccurs="0" maxOccurs="unbounded"/> + <xsd:element name="extLst" type="w16:CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_CommentExtensible"> + <xsd:sequence> + <xsd:element name="extLst" type="w16:CT_ExtensionList" minOccurs="0" maxOccurs="1"/> + </xsd:sequence> + <xsd:attribute name="durableId" type="w:ST_LongHexNumber" use="required"/> + <xsd:attribute name="dateUtc" type="w:ST_DateTime" use="optional"/> + <xsd:attribute name="intelligentPlaceholder" type="s:ST_OnOff" use="optional"/> + </xsd:complexType> + <xsd:element name="commentsExtensible" type="CT_CommentsExtensible"/> + </xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/microsoft/wml-cid-2016.xsd b/.claude/skills/docx/scripts/office/schemas/microsoft/wml-cid-2016.xsd new file mode 100644 index 00000000..fed9d15b --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/microsoft/wml-cid-2016.xsd @@ -0,0 +1,13 @@ + <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:w12="http://schemas.openxmlformats.org/wordprocessingml/2006/main" elementFormDefault="qualified" attributeFormDefault="qualified" blockDefault="#all" xmlns="http://schemas.microsoft.com/office/word/2016/wordml/cid" targetNamespace="http://schemas.microsoft.com/office/word/2016/wordml/cid"> + <xsd:import id="w12" namespace="http://schemas.openxmlformats.org/wordprocessingml/2006/main" schemaLocation="../ISO-IEC29500-4_2016/wml.xsd"/> + <xsd:complexType name="CT_CommentsIds"> + <xsd:sequence> + <xsd:element name="commentId" type="CT_CommentId" minOccurs="0" maxOccurs="unbounded"/> + </xsd:sequence> + </xsd:complexType> + <xsd:complexType name="CT_CommentId"> + <xsd:attribute name="paraId" type="w12:ST_LongHexNumber" use="required"/> + <xsd:attribute name="durableId" type="w12:ST_LongHexNumber" use="required"/> + </xsd:complexType> + <xsd:element name="commentsIds" type="CT_CommentsIds"/> + </xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/microsoft/wml-sdtdatahash-2020.xsd b/.claude/skills/docx/scripts/office/schemas/microsoft/wml-sdtdatahash-2020.xsd new file mode 100644 index 00000000..680cf154 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/microsoft/wml-sdtdatahash-2020.xsd @@ -0,0 +1,4 @@ + <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:w12="http://schemas.openxmlformats.org/wordprocessingml/2006/main" elementFormDefault="qualified" attributeFormDefault="qualified" blockDefault="#all" xmlns="http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash" targetNamespace="http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash"> + <xsd:import id="w12" namespace="http://schemas.openxmlformats.org/wordprocessingml/2006/main" schemaLocation="../ISO-IEC29500-4_2016/wml.xsd"/> + <xsd:attribute name="storeItemChecksum" type="w12:ST_String"/> + </xsd:schema> diff --git a/.claude/skills/docx/scripts/office/schemas/microsoft/wml-symex-2015.xsd b/.claude/skills/docx/scripts/office/schemas/microsoft/wml-symex-2015.xsd new file mode 100644 index 00000000..89ada908 --- /dev/null +++ b/.claude/skills/docx/scripts/office/schemas/microsoft/wml-symex-2015.xsd @@ -0,0 +1,8 @@ + <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:w12="http://schemas.openxmlformats.org/wordprocessingml/2006/main" elementFormDefault="qualified" attributeFormDefault="qualified" blockDefault="#all" xmlns="http://schemas.microsoft.com/office/word/2015/wordml/symex" targetNamespace="http://schemas.microsoft.com/office/word/2015/wordml/symex"> + <xsd:import id="w12" namespace="http://schemas.openxmlformats.org/wordprocessingml/2006/main" schemaLocation="../ISO-IEC29500-4_2016/wml.xsd"/> + <xsd:complexType name="CT_SymEx"> + <xsd:attribute name="font" type="w12:ST_String"/> + <xsd:attribute name="char" type="w12:ST_LongHexNumber"/> + </xsd:complexType> + <xsd:element name="symEx" type="CT_SymEx"/> + </xsd:schema> diff --git a/.claude/skills/docx/scripts/office/soffice.py b/.claude/skills/docx/scripts/office/soffice.py new file mode 100644 index 00000000..c7f7e328 --- /dev/null +++ b/.claude/skills/docx/scripts/office/soffice.py @@ -0,0 +1,183 @@ +""" +Helper for running LibreOffice (soffice) in environments where AF_UNIX +sockets may be blocked (e.g., sandboxed VMs). Detects the restriction +at runtime and applies an LD_PRELOAD shim if needed. + +Usage: + from office.soffice import run_soffice, get_soffice_env + + # Option 1 – run soffice directly + result = run_soffice(["--headless", "--convert-to", "pdf", "input.docx"]) + + # Option 2 – get env dict for your own subprocess calls + env = get_soffice_env() + subprocess.run(["soffice", ...], env=env) +""" + +import os +import socket +import subprocess +import tempfile +from pathlib import Path + + +def get_soffice_env() -> dict: + env = os.environ.copy() + env["SAL_USE_VCLPLUGIN"] = "svp" + + if _needs_shim(): + shim = _ensure_shim() + env["LD_PRELOAD"] = str(shim) + + return env + + +def run_soffice(args: list[str], **kwargs) -> subprocess.CompletedProcess: + env = get_soffice_env() + return subprocess.run(["soffice"] + args, env=env, **kwargs) + + + +_SHIM_SO = Path(tempfile.gettempdir()) / "lo_socket_shim.so" + + +def _needs_shim() -> bool: + try: + s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + s.close() + return False + except OSError: + return True + + +def _ensure_shim() -> Path: + if _SHIM_SO.exists(): + return _SHIM_SO + + src = Path(tempfile.gettempdir()) / "lo_socket_shim.c" + src.write_text(_SHIM_SOURCE) + subprocess.run( + ["gcc", "-shared", "-fPIC", "-o", str(_SHIM_SO), str(src), "-ldl"], + check=True, + capture_output=True, + ) + src.unlink() + return _SHIM_SO + + + +_SHIM_SOURCE = r""" +#define _GNU_SOURCE +#include <dlfcn.h> +#include <errno.h> +#include <signal.h> +#include <stdio.h> +#include <stdlib.h> +#include <sys/socket.h> +#include <unistd.h> + +static int (*real_socket)(int, int, int); +static int (*real_socketpair)(int, int, int, int[2]); +static int (*real_listen)(int, int); +static int (*real_accept)(int, struct sockaddr *, socklen_t *); +static int (*real_close)(int); +static int (*real_read)(int, void *, size_t); + +/* Per-FD bookkeeping (FDs >= 1024 are passed through unshimmed). */ +static int is_shimmed[1024]; +static int peer_of[1024]; +static int wake_r[1024]; /* accept() blocks reading this */ +static int wake_w[1024]; /* close() writes to this */ +static int listener_fd = -1; /* FD that received listen() */ + +__attribute__((constructor)) +static void init(void) { + real_socket = dlsym(RTLD_NEXT, "socket"); + real_socketpair = dlsym(RTLD_NEXT, "socketpair"); + real_listen = dlsym(RTLD_NEXT, "listen"); + real_accept = dlsym(RTLD_NEXT, "accept"); + real_close = dlsym(RTLD_NEXT, "close"); + real_read = dlsym(RTLD_NEXT, "read"); + for (int i = 0; i < 1024; i++) { + peer_of[i] = -1; + wake_r[i] = -1; + wake_w[i] = -1; + } +} + +/* ---- socket ---------------------------------------------------------- */ +int socket(int domain, int type, int protocol) { + if (domain == AF_UNIX) { + int fd = real_socket(domain, type, protocol); + if (fd >= 0) return fd; + /* socket(AF_UNIX) blocked – fall back to socketpair(). */ + int sv[2]; + if (real_socketpair(domain, type, protocol, sv) == 0) { + if (sv[0] >= 0 && sv[0] < 1024) { + is_shimmed[sv[0]] = 1; + peer_of[sv[0]] = sv[1]; + int wp[2]; + if (pipe(wp) == 0) { + wake_r[sv[0]] = wp[0]; + wake_w[sv[0]] = wp[1]; + } + } + return sv[0]; + } + errno = EPERM; + return -1; + } + return real_socket(domain, type, protocol); +} + +/* ---- listen ---------------------------------------------------------- */ +int listen(int sockfd, int backlog) { + if (sockfd >= 0 && sockfd < 1024 && is_shimmed[sockfd]) { + listener_fd = sockfd; + return 0; + } + return real_listen(sockfd, backlog); +} + +/* ---- accept ---------------------------------------------------------- */ +int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen) { + if (sockfd >= 0 && sockfd < 1024 && is_shimmed[sockfd]) { + /* Block until close() writes to the wake pipe. */ + if (wake_r[sockfd] >= 0) { + char buf; + real_read(wake_r[sockfd], &buf, 1); + } + errno = ECONNABORTED; + return -1; + } + return real_accept(sockfd, addr, addrlen); +} + +/* ---- close ----------------------------------------------------------- */ +int close(int fd) { + if (fd >= 0 && fd < 1024 && is_shimmed[fd]) { + int was_listener = (fd == listener_fd); + is_shimmed[fd] = 0; + + if (wake_w[fd] >= 0) { /* unblock accept() */ + char c = 0; + write(wake_w[fd], &c, 1); + real_close(wake_w[fd]); + wake_w[fd] = -1; + } + if (wake_r[fd] >= 0) { real_close(wake_r[fd]); wake_r[fd] = -1; } + if (peer_of[fd] >= 0) { real_close(peer_of[fd]); peer_of[fd] = -1; } + + if (was_listener) + _exit(0); /* conversion done – exit */ + } + return real_close(fd); +} +""" + + + +if __name__ == "__main__": + import sys + result = run_soffice(sys.argv[1:]) + sys.exit(result.returncode) diff --git a/.claude/skills/docx/scripts/office/unpack.py b/.claude/skills/docx/scripts/office/unpack.py new file mode 100755 index 00000000..00152533 --- /dev/null +++ b/.claude/skills/docx/scripts/office/unpack.py @@ -0,0 +1,132 @@ +"""Unpack Office files (DOCX, PPTX, XLSX) for editing. + +Extracts the ZIP archive, pretty-prints XML files, and optionally: +- Merges adjacent runs with identical formatting (DOCX only) +- Simplifies adjacent tracked changes from same author (DOCX only) + +Usage: + python unpack.py <office_file> <output_dir> [options] + +Examples: + python unpack.py document.docx unpacked/ + python unpack.py presentation.pptx unpacked/ + python unpack.py document.docx unpacked/ --merge-runs false +""" + +import argparse +import sys +import zipfile +from pathlib import Path + +import defusedxml.minidom + +from helpers.merge_runs import merge_runs as do_merge_runs +from helpers.simplify_redlines import simplify_redlines as do_simplify_redlines + +SMART_QUOTE_REPLACEMENTS = { + "\u201c": "“", + "\u201d": "”", + "\u2018": "‘", + "\u2019": "’", +} + + +def unpack( + input_file: str, + output_directory: str, + merge_runs: bool = True, + simplify_redlines: bool = True, +) -> tuple[None, str]: + input_path = Path(input_file) + output_path = Path(output_directory) + suffix = input_path.suffix.lower() + + if not input_path.exists(): + return None, f"Error: {input_file} does not exist" + + if suffix not in {".docx", ".pptx", ".xlsx"}: + return None, f"Error: {input_file} must be a .docx, .pptx, or .xlsx file" + + try: + output_path.mkdir(parents=True, exist_ok=True) + + with zipfile.ZipFile(input_path, "r") as zf: + zf.extractall(output_path) + + xml_files = list(output_path.rglob("*.xml")) + list(output_path.rglob("*.rels")) + for xml_file in xml_files: + _pretty_print_xml(xml_file) + + message = f"Unpacked {input_file} ({len(xml_files)} XML files)" + + if suffix == ".docx": + if simplify_redlines: + simplify_count, _ = do_simplify_redlines(str(output_path)) + message += f", simplified {simplify_count} tracked changes" + + if merge_runs: + merge_count, _ = do_merge_runs(str(output_path)) + message += f", merged {merge_count} runs" + + for xml_file in xml_files: + _escape_smart_quotes(xml_file) + + return None, message + + except zipfile.BadZipFile: + return None, f"Error: {input_file} is not a valid Office file" + except Exception as e: + return None, f"Error unpacking: {e}" + + +def _pretty_print_xml(xml_file: Path) -> None: + try: + content = xml_file.read_text(encoding="utf-8") + dom = defusedxml.minidom.parseString(content) + xml_file.write_bytes(dom.toprettyxml(indent=" ", encoding="utf-8")) + except Exception: + pass + + +def _escape_smart_quotes(xml_file: Path) -> None: + try: + content = xml_file.read_text(encoding="utf-8") + for char, entity in SMART_QUOTE_REPLACEMENTS.items(): + content = content.replace(char, entity) + xml_file.write_text(content, encoding="utf-8") + except Exception: + pass + + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description="Unpack an Office file (DOCX, PPTX, XLSX) for editing" + ) + parser.add_argument("input_file", help="Office file to unpack") + parser.add_argument("output_directory", help="Output directory") + parser.add_argument( + "--merge-runs", + type=lambda x: x.lower() == "true", + default=True, + metavar="true|false", + help="Merge adjacent runs with identical formatting (DOCX only, default: true)", + ) + parser.add_argument( + "--simplify-redlines", + type=lambda x: x.lower() == "true", + default=True, + metavar="true|false", + help="Merge adjacent tracked changes from same author (DOCX only, default: true)", + ) + args = parser.parse_args() + + _, message = unpack( + args.input_file, + args.output_directory, + merge_runs=args.merge_runs, + simplify_redlines=args.simplify_redlines, + ) + print(message) + + if "Error" in message: + sys.exit(1) diff --git a/.claude/skills/docx/scripts/office/validate.py b/.claude/skills/docx/scripts/office/validate.py new file mode 100755 index 00000000..03b01f6e --- /dev/null +++ b/.claude/skills/docx/scripts/office/validate.py @@ -0,0 +1,111 @@ +""" +Command line tool to validate Office document XML files against XSD schemas and tracked changes. + +Usage: + python validate.py <path> [--original <original_file>] [--auto-repair] [--author NAME] + +The first argument can be either: +- An unpacked directory containing the Office document XML files +- A packed Office file (.docx/.pptx/.xlsx) which will be unpacked to a temp directory + +Auto-repair fixes: +- paraId/durableId values that exceed OOXML limits +- Missing xml:space="preserve" on w:t elements with whitespace +""" + +import argparse +import sys +import tempfile +import zipfile +from pathlib import Path + +from validators import DOCXSchemaValidator, PPTXSchemaValidator, RedliningValidator + + +def main(): + parser = argparse.ArgumentParser(description="Validate Office document XML files") + parser.add_argument( + "path", + help="Path to unpacked directory or packed Office file (.docx/.pptx/.xlsx)", + ) + parser.add_argument( + "--original", + required=False, + default=None, + help="Path to original file (.docx/.pptx/.xlsx). If omitted, all XSD errors are reported and redlining validation is skipped.", + ) + parser.add_argument( + "-v", + "--verbose", + action="store_true", + help="Enable verbose output", + ) + parser.add_argument( + "--auto-repair", + action="store_true", + help="Automatically repair common issues (hex IDs, whitespace preservation)", + ) + parser.add_argument( + "--author", + default="Claude", + help="Author name for redlining validation (default: Claude)", + ) + args = parser.parse_args() + + path = Path(args.path) + assert path.exists(), f"Error: {path} does not exist" + + original_file = None + if args.original: + original_file = Path(args.original) + assert original_file.is_file(), f"Error: {original_file} is not a file" + assert original_file.suffix.lower() in [".docx", ".pptx", ".xlsx"], ( + f"Error: {original_file} must be a .docx, .pptx, or .xlsx file" + ) + + file_extension = (original_file or path).suffix.lower() + assert file_extension in [".docx", ".pptx", ".xlsx"], ( + f"Error: Cannot determine file type from {path}. Use --original or provide a .docx/.pptx/.xlsx file." + ) + + if path.is_file() and path.suffix.lower() in [".docx", ".pptx", ".xlsx"]: + temp_dir = tempfile.mkdtemp() + with zipfile.ZipFile(path, "r") as zf: + zf.extractall(temp_dir) + unpacked_dir = Path(temp_dir) + else: + assert path.is_dir(), f"Error: {path} is not a directory or Office file" + unpacked_dir = path + + match file_extension: + case ".docx": + validators = [ + DOCXSchemaValidator(unpacked_dir, original_file, verbose=args.verbose), + ] + if original_file: + validators.append( + RedliningValidator(unpacked_dir, original_file, verbose=args.verbose, author=args.author) + ) + case ".pptx": + validators = [ + PPTXSchemaValidator(unpacked_dir, original_file, verbose=args.verbose), + ] + case _: + print(f"Error: Validation not supported for file type {file_extension}") + sys.exit(1) + + if args.auto_repair: + total_repairs = sum(v.repair() for v in validators) + if total_repairs: + print(f"Auto-repaired {total_repairs} issue(s)") + + success = all(v.validate() for v in validators) + + if success: + print("All validations PASSED!") + + sys.exit(0 if success else 1) + + +if __name__ == "__main__": + main() diff --git a/.claude/skills/docx/scripts/office/validators/__init__.py b/.claude/skills/docx/scripts/office/validators/__init__.py new file mode 100644 index 00000000..db092ece --- /dev/null +++ b/.claude/skills/docx/scripts/office/validators/__init__.py @@ -0,0 +1,15 @@ +""" +Validation modules for Word document processing. +""" + +from .base import BaseSchemaValidator +from .docx import DOCXSchemaValidator +from .pptx import PPTXSchemaValidator +from .redlining import RedliningValidator + +__all__ = [ + "BaseSchemaValidator", + "DOCXSchemaValidator", + "PPTXSchemaValidator", + "RedliningValidator", +] diff --git a/.claude/skills/docx/scripts/office/validators/base.py b/.claude/skills/docx/scripts/office/validators/base.py new file mode 100644 index 00000000..db4a06a2 --- /dev/null +++ b/.claude/skills/docx/scripts/office/validators/base.py @@ -0,0 +1,847 @@ +""" +Base validator with common validation logic for document files. +""" + +import re +from pathlib import Path + +import defusedxml.minidom +import lxml.etree + + +class BaseSchemaValidator: + + IGNORED_VALIDATION_ERRORS = [ + "hyphenationZone", + "purl.org/dc/terms", + ] + + UNIQUE_ID_REQUIREMENTS = { + "comment": ("id", "file"), + "commentrangestart": ("id", "file"), + "commentrangeend": ("id", "file"), + "bookmarkstart": ("id", "file"), + "bookmarkend": ("id", "file"), + "sldid": ("id", "file"), + "sldmasterid": ("id", "global"), + "sldlayoutid": ("id", "global"), + "cm": ("authorid", "file"), + "sheet": ("sheetid", "file"), + "definedname": ("id", "file"), + "cxnsp": ("id", "file"), + "sp": ("id", "file"), + "pic": ("id", "file"), + "grpsp": ("id", "file"), + } + + EXCLUDED_ID_CONTAINERS = { + "sectionlst", + } + + ELEMENT_RELATIONSHIP_TYPES = {} + + SCHEMA_MAPPINGS = { + "word": "ISO-IEC29500-4_2016/wml.xsd", + "ppt": "ISO-IEC29500-4_2016/pml.xsd", + "xl": "ISO-IEC29500-4_2016/sml.xsd", + "[Content_Types].xml": "ecma/fouth-edition/opc-contentTypes.xsd", + "app.xml": "ISO-IEC29500-4_2016/shared-documentPropertiesExtended.xsd", + "core.xml": "ecma/fouth-edition/opc-coreProperties.xsd", + "custom.xml": "ISO-IEC29500-4_2016/shared-documentPropertiesCustom.xsd", + ".rels": "ecma/fouth-edition/opc-relationships.xsd", + "people.xml": "microsoft/wml-2012.xsd", + "commentsIds.xml": "microsoft/wml-cid-2016.xsd", + "commentsExtensible.xml": "microsoft/wml-cex-2018.xsd", + "commentsExtended.xml": "microsoft/wml-2012.xsd", + "chart": "ISO-IEC29500-4_2016/dml-chart.xsd", + "theme": "ISO-IEC29500-4_2016/dml-main.xsd", + "drawing": "ISO-IEC29500-4_2016/dml-main.xsd", + } + + MC_NAMESPACE = "http://schemas.openxmlformats.org/markup-compatibility/2006" + XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace" + + PACKAGE_RELATIONSHIPS_NAMESPACE = ( + "http://schemas.openxmlformats.org/package/2006/relationships" + ) + OFFICE_RELATIONSHIPS_NAMESPACE = ( + "http://schemas.openxmlformats.org/officeDocument/2006/relationships" + ) + CONTENT_TYPES_NAMESPACE = ( + "http://schemas.openxmlformats.org/package/2006/content-types" + ) + + MAIN_CONTENT_FOLDERS = {"word", "ppt", "xl"} + + OOXML_NAMESPACES = { + "http://schemas.openxmlformats.org/officeDocument/2006/math", + "http://schemas.openxmlformats.org/officeDocument/2006/relationships", + "http://schemas.openxmlformats.org/schemaLibrary/2006/main", + "http://schemas.openxmlformats.org/drawingml/2006/main", + "http://schemas.openxmlformats.org/drawingml/2006/chart", + "http://schemas.openxmlformats.org/drawingml/2006/chartDrawing", + "http://schemas.openxmlformats.org/drawingml/2006/diagram", + "http://schemas.openxmlformats.org/drawingml/2006/picture", + "http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing", + "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing", + "http://schemas.openxmlformats.org/wordprocessingml/2006/main", + "http://schemas.openxmlformats.org/presentationml/2006/main", + "http://schemas.openxmlformats.org/spreadsheetml/2006/main", + "http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes", + "http://www.w3.org/XML/1998/namespace", + } + + def __init__(self, unpacked_dir, original_file=None, verbose=False): + self.unpacked_dir = Path(unpacked_dir).resolve() + self.original_file = Path(original_file) if original_file else None + self.verbose = verbose + + self.schemas_dir = Path(__file__).parent.parent / "schemas" + + patterns = ["*.xml", "*.rels"] + self.xml_files = [ + f for pattern in patterns for f in self.unpacked_dir.rglob(pattern) + ] + + if not self.xml_files: + print(f"Warning: No XML files found in {self.unpacked_dir}") + + def validate(self): + raise NotImplementedError("Subclasses must implement the validate method") + + def repair(self) -> int: + return self.repair_whitespace_preservation() + + def repair_whitespace_preservation(self) -> int: + repairs = 0 + + for xml_file in self.xml_files: + try: + content = xml_file.read_text(encoding="utf-8") + dom = defusedxml.minidom.parseString(content) + modified = False + + for elem in dom.getElementsByTagName("*"): + if elem.tagName.endswith(":t") and elem.firstChild: + text = elem.firstChild.nodeValue + if text and (text.startswith((' ', '\t')) or text.endswith((' ', '\t'))): + if elem.getAttribute("xml:space") != "preserve": + elem.setAttribute("xml:space", "preserve") + text_preview = repr(text[:30]) + "..." if len(text) > 30 else repr(text) + print(f" Repaired: {xml_file.name}: Added xml:space='preserve' to {elem.tagName}: {text_preview}") + repairs += 1 + modified = True + + if modified: + xml_file.write_bytes(dom.toxml(encoding="UTF-8")) + + except Exception: + pass + + return repairs + + def validate_xml(self): + errors = [] + + for xml_file in self.xml_files: + try: + lxml.etree.parse(str(xml_file)) + except lxml.etree.XMLSyntaxError as e: + errors.append( + f" {xml_file.relative_to(self.unpacked_dir)}: " + f"Line {e.lineno}: {e.msg}" + ) + except Exception as e: + errors.append( + f" {xml_file.relative_to(self.unpacked_dir)}: " + f"Unexpected error: {str(e)}" + ) + + if errors: + print(f"FAILED - Found {len(errors)} XML violations:") + for error in errors: + print(error) + return False + else: + if self.verbose: + print("PASSED - All XML files are well-formed") + return True + + def validate_namespaces(self): + errors = [] + + for xml_file in self.xml_files: + try: + root = lxml.etree.parse(str(xml_file)).getroot() + declared = set(root.nsmap.keys()) - {None} + + for attr_val in [ + v for k, v in root.attrib.items() if k.endswith("Ignorable") + ]: + undeclared = set(attr_val.split()) - declared + errors.extend( + f" {xml_file.relative_to(self.unpacked_dir)}: " + f"Namespace '{ns}' in Ignorable but not declared" + for ns in undeclared + ) + except lxml.etree.XMLSyntaxError: + continue + + if errors: + print(f"FAILED - {len(errors)} namespace issues:") + for error in errors: + print(error) + return False + if self.verbose: + print("PASSED - All namespace prefixes properly declared") + return True + + def validate_unique_ids(self): + errors = [] + global_ids = {} + + for xml_file in self.xml_files: + try: + root = lxml.etree.parse(str(xml_file)).getroot() + file_ids = {} + + mc_elements = root.xpath( + ".//mc:AlternateContent", namespaces={"mc": self.MC_NAMESPACE} + ) + for elem in mc_elements: + elem.getparent().remove(elem) + + for elem in root.iter(): + tag = ( + elem.tag.split("}")[-1].lower() + if "}" in elem.tag + else elem.tag.lower() + ) + + if tag in self.UNIQUE_ID_REQUIREMENTS: + in_excluded_container = any( + ancestor.tag.split("}")[-1].lower() in self.EXCLUDED_ID_CONTAINERS + for ancestor in elem.iterancestors() + ) + if in_excluded_container: + continue + + attr_name, scope = self.UNIQUE_ID_REQUIREMENTS[tag] + + id_value = None + for attr, value in elem.attrib.items(): + attr_local = ( + attr.split("}")[-1].lower() + if "}" in attr + else attr.lower() + ) + if attr_local == attr_name: + id_value = value + break + + if id_value is not None: + if scope == "global": + if id_value in global_ids: + prev_file, prev_line, prev_tag = global_ids[ + id_value + ] + errors.append( + f" {xml_file.relative_to(self.unpacked_dir)}: " + f"Line {elem.sourceline}: Global ID '{id_value}' in <{tag}> " + f"already used in {prev_file} at line {prev_line} in <{prev_tag}>" + ) + else: + global_ids[id_value] = ( + xml_file.relative_to(self.unpacked_dir), + elem.sourceline, + tag, + ) + elif scope == "file": + key = (tag, attr_name) + if key not in file_ids: + file_ids[key] = {} + + if id_value in file_ids[key]: + prev_line = file_ids[key][id_value] + errors.append( + f" {xml_file.relative_to(self.unpacked_dir)}: " + f"Line {elem.sourceline}: Duplicate {attr_name}='{id_value}' in <{tag}> " + f"(first occurrence at line {prev_line})" + ) + else: + file_ids[key][id_value] = elem.sourceline + + except (lxml.etree.XMLSyntaxError, Exception) as e: + errors.append( + f" {xml_file.relative_to(self.unpacked_dir)}: Error: {e}" + ) + + if errors: + print(f"FAILED - Found {len(errors)} ID uniqueness violations:") + for error in errors: + print(error) + return False + else: + if self.verbose: + print("PASSED - All required IDs are unique") + return True + + def validate_file_references(self): + errors = [] + + rels_files = list(self.unpacked_dir.rglob("*.rels")) + + if not rels_files: + if self.verbose: + print("PASSED - No .rels files found") + return True + + all_files = [] + for file_path in self.unpacked_dir.rglob("*"): + if ( + file_path.is_file() + and file_path.name != "[Content_Types].xml" + and not file_path.name.endswith(".rels") + ): + all_files.append(file_path.resolve()) + + all_referenced_files = set() + + if self.verbose: + print( + f"Found {len(rels_files)} .rels files and {len(all_files)} target files" + ) + + for rels_file in rels_files: + try: + rels_root = lxml.etree.parse(str(rels_file)).getroot() + + rels_dir = rels_file.parent + + referenced_files = set() + broken_refs = [] + + for rel in rels_root.findall( + ".//ns:Relationship", + namespaces={"ns": self.PACKAGE_RELATIONSHIPS_NAMESPACE}, + ): + target = rel.get("Target") + if target and not target.startswith( + ("http", "mailto:") + ): + if target.startswith("/"): + target_path = self.unpacked_dir / target.lstrip("/") + elif rels_file.name == ".rels": + target_path = self.unpacked_dir / target + else: + base_dir = rels_dir.parent + target_path = base_dir / target + + try: + target_path = target_path.resolve() + if target_path.exists() and target_path.is_file(): + referenced_files.add(target_path) + all_referenced_files.add(target_path) + else: + broken_refs.append((target, rel.sourceline)) + except (OSError, ValueError): + broken_refs.append((target, rel.sourceline)) + + if broken_refs: + rel_path = rels_file.relative_to(self.unpacked_dir) + for broken_ref, line_num in broken_refs: + errors.append( + f" {rel_path}: Line {line_num}: Broken reference to {broken_ref}" + ) + + except Exception as e: + rel_path = rels_file.relative_to(self.unpacked_dir) + errors.append(f" Error parsing {rel_path}: {e}") + + unreferenced_files = set(all_files) - all_referenced_files + + if unreferenced_files: + for unref_file in sorted(unreferenced_files): + unref_rel_path = unref_file.relative_to(self.unpacked_dir) + errors.append(f" Unreferenced file: {unref_rel_path}") + + if errors: + print(f"FAILED - Found {len(errors)} relationship validation errors:") + for error in errors: + print(error) + print( + "CRITICAL: These errors will cause the document to appear corrupt. " + + "Broken references MUST be fixed, " + + "and unreferenced files MUST be referenced or removed." + ) + return False + else: + if self.verbose: + print( + "PASSED - All references are valid and all files are properly referenced" + ) + return True + + def validate_all_relationship_ids(self): + import lxml.etree + + errors = [] + + for xml_file in self.xml_files: + if xml_file.suffix == ".rels": + continue + + rels_dir = xml_file.parent / "_rels" + rels_file = rels_dir / f"{xml_file.name}.rels" + + if not rels_file.exists(): + continue + + try: + rels_root = lxml.etree.parse(str(rels_file)).getroot() + rid_to_type = {} + + for rel in rels_root.findall( + f".//{{{self.PACKAGE_RELATIONSHIPS_NAMESPACE}}}Relationship" + ): + rid = rel.get("Id") + rel_type = rel.get("Type", "") + if rid: + if rid in rid_to_type: + rels_rel_path = rels_file.relative_to(self.unpacked_dir) + errors.append( + f" {rels_rel_path}: Line {rel.sourceline}: " + f"Duplicate relationship ID '{rid}' (IDs must be unique)" + ) + type_name = ( + rel_type.split("/")[-1] if "/" in rel_type else rel_type + ) + rid_to_type[rid] = type_name + + xml_root = lxml.etree.parse(str(xml_file)).getroot() + + r_ns = self.OFFICE_RELATIONSHIPS_NAMESPACE + rid_attrs_to_check = ["id", "embed", "link"] + for elem in xml_root.iter(): + for attr_name in rid_attrs_to_check: + rid_attr = elem.get(f"{{{r_ns}}}{attr_name}") + if not rid_attr: + continue + xml_rel_path = xml_file.relative_to(self.unpacked_dir) + elem_name = ( + elem.tag.split("}")[-1] if "}" in elem.tag else elem.tag + ) + + if rid_attr not in rid_to_type: + errors.append( + f" {xml_rel_path}: Line {elem.sourceline}: " + f"<{elem_name}> r:{attr_name} references non-existent relationship '{rid_attr}' " + f"(valid IDs: {', '.join(sorted(rid_to_type.keys())[:5])}{'...' if len(rid_to_type) > 5 else ''})" + ) + elif attr_name == "id" and self.ELEMENT_RELATIONSHIP_TYPES: + expected_type = self._get_expected_relationship_type( + elem_name + ) + if expected_type: + actual_type = rid_to_type[rid_attr] + if expected_type not in actual_type.lower(): + errors.append( + f" {xml_rel_path}: Line {elem.sourceline}: " + f"<{elem_name}> references '{rid_attr}' which points to '{actual_type}' " + f"but should point to a '{expected_type}' relationship" + ) + + except Exception as e: + xml_rel_path = xml_file.relative_to(self.unpacked_dir) + errors.append(f" Error processing {xml_rel_path}: {e}") + + if errors: + print(f"FAILED - Found {len(errors)} relationship ID reference errors:") + for error in errors: + print(error) + print("\nThese ID mismatches will cause the document to appear corrupt!") + return False + else: + if self.verbose: + print("PASSED - All relationship ID references are valid") + return True + + def _get_expected_relationship_type(self, element_name): + elem_lower = element_name.lower() + + if elem_lower in self.ELEMENT_RELATIONSHIP_TYPES: + return self.ELEMENT_RELATIONSHIP_TYPES[elem_lower] + + if elem_lower.endswith("id") and len(elem_lower) > 2: + prefix = elem_lower[:-2] + if prefix.endswith("master"): + return prefix.lower() + elif prefix.endswith("layout"): + return prefix.lower() + else: + if prefix == "sld": + return "slide" + return prefix.lower() + + if elem_lower.endswith("reference") and len(elem_lower) > 9: + prefix = elem_lower[:-9] + return prefix.lower() + + return None + + def validate_content_types(self): + errors = [] + + content_types_file = self.unpacked_dir / "[Content_Types].xml" + if not content_types_file.exists(): + print("FAILED - [Content_Types].xml file not found") + return False + + try: + root = lxml.etree.parse(str(content_types_file)).getroot() + declared_parts = set() + declared_extensions = set() + + for override in root.findall( + f".//{{{self.CONTENT_TYPES_NAMESPACE}}}Override" + ): + part_name = override.get("PartName") + if part_name is not None: + declared_parts.add(part_name.lstrip("/")) + + for default in root.findall( + f".//{{{self.CONTENT_TYPES_NAMESPACE}}}Default" + ): + extension = default.get("Extension") + if extension is not None: + declared_extensions.add(extension.lower()) + + declarable_roots = { + "sld", + "sldLayout", + "sldMaster", + "presentation", + "document", + "workbook", + "worksheet", + "theme", + } + + media_extensions = { + "png": "image/png", + "jpg": "image/jpeg", + "jpeg": "image/jpeg", + "gif": "image/gif", + "bmp": "image/bmp", + "tiff": "image/tiff", + "wmf": "image/x-wmf", + "emf": "image/x-emf", + } + + all_files = list(self.unpacked_dir.rglob("*")) + all_files = [f for f in all_files if f.is_file()] + + for xml_file in self.xml_files: + path_str = str(xml_file.relative_to(self.unpacked_dir)).replace( + "\\", "/" + ) + + if any( + skip in path_str + for skip in [".rels", "[Content_Types]", "docProps/", "_rels/"] + ): + continue + + try: + root_tag = lxml.etree.parse(str(xml_file)).getroot().tag + root_name = root_tag.split("}")[-1] if "}" in root_tag else root_tag + + if root_name in declarable_roots and path_str not in declared_parts: + errors.append( + f" {path_str}: File with <{root_name}> root not declared in [Content_Types].xml" + ) + + except Exception: + continue + + for file_path in all_files: + if file_path.suffix.lower() in {".xml", ".rels"}: + continue + if file_path.name == "[Content_Types].xml": + continue + if "_rels" in file_path.parts or "docProps" in file_path.parts: + continue + + extension = file_path.suffix.lstrip(".").lower() + if extension and extension not in declared_extensions: + if extension in media_extensions: + relative_path = file_path.relative_to(self.unpacked_dir) + errors.append( + f' {relative_path}: File with extension \'{extension}\' not declared in [Content_Types].xml - should add: <Default Extension="{extension}" ContentType="{media_extensions[extension]}"/>' + ) + + except Exception as e: + errors.append(f" Error parsing [Content_Types].xml: {e}") + + if errors: + print(f"FAILED - Found {len(errors)} content type declaration errors:") + for error in errors: + print(error) + return False + else: + if self.verbose: + print( + "PASSED - All content files are properly declared in [Content_Types].xml" + ) + return True + + def validate_file_against_xsd(self, xml_file, verbose=False): + xml_file = Path(xml_file).resolve() + unpacked_dir = self.unpacked_dir.resolve() + + is_valid, current_errors = self._validate_single_file_xsd( + xml_file, unpacked_dir + ) + + if is_valid is None: + return None, set() + elif is_valid: + return True, set() + + original_errors = self._get_original_file_errors(xml_file) + + assert current_errors is not None + new_errors = current_errors - original_errors + + new_errors = { + e for e in new_errors + if not any(pattern in e for pattern in self.IGNORED_VALIDATION_ERRORS) + } + + if new_errors: + if verbose: + relative_path = xml_file.relative_to(unpacked_dir) + print(f"FAILED - {relative_path}: {len(new_errors)} new error(s)") + for error in list(new_errors)[:3]: + truncated = error[:250] + "..." if len(error) > 250 else error + print(f" - {truncated}") + return False, new_errors + else: + if verbose: + print( + f"PASSED - No new errors (original had {len(current_errors)} errors)" + ) + return True, set() + + def validate_against_xsd(self): + new_errors = [] + original_error_count = 0 + valid_count = 0 + skipped_count = 0 + + for xml_file in self.xml_files: + relative_path = str(xml_file.relative_to(self.unpacked_dir)) + is_valid, new_file_errors = self.validate_file_against_xsd( + xml_file, verbose=False + ) + + if is_valid is None: + skipped_count += 1 + continue + elif is_valid and not new_file_errors: + valid_count += 1 + continue + elif is_valid: + original_error_count += 1 + valid_count += 1 + continue + + new_errors.append(f" {relative_path}: {len(new_file_errors)} new error(s)") + for error in list(new_file_errors)[:3]: + new_errors.append( + f" - {error[:250]}..." if len(error) > 250 else f" - {error}" + ) + + if self.verbose: + print(f"Validated {len(self.xml_files)} files:") + print(f" - Valid: {valid_count}") + print(f" - Skipped (no schema): {skipped_count}") + if original_error_count: + print(f" - With original errors (ignored): {original_error_count}") + print( + f" - With NEW errors: {len(new_errors) > 0 and len([e for e in new_errors if not e.startswith(' ')]) or 0}" + ) + + if new_errors: + print("\nFAILED - Found NEW validation errors:") + for error in new_errors: + print(error) + return False + else: + if self.verbose: + print("\nPASSED - No new XSD validation errors introduced") + return True + + def _get_schema_path(self, xml_file): + if xml_file.name in self.SCHEMA_MAPPINGS: + return self.schemas_dir / self.SCHEMA_MAPPINGS[xml_file.name] + + if xml_file.suffix == ".rels": + return self.schemas_dir / self.SCHEMA_MAPPINGS[".rels"] + + if "charts/" in str(xml_file) and xml_file.name.startswith("chart"): + return self.schemas_dir / self.SCHEMA_MAPPINGS["chart"] + + if "theme/" in str(xml_file) and xml_file.name.startswith("theme"): + return self.schemas_dir / self.SCHEMA_MAPPINGS["theme"] + + if xml_file.parent.name in self.MAIN_CONTENT_FOLDERS: + return self.schemas_dir / self.SCHEMA_MAPPINGS[xml_file.parent.name] + + return None + + def _clean_ignorable_namespaces(self, xml_doc): + xml_string = lxml.etree.tostring(xml_doc, encoding="unicode") + xml_copy = lxml.etree.fromstring(xml_string) + + for elem in xml_copy.iter(): + attrs_to_remove = [] + + for attr in elem.attrib: + if "{" in attr: + ns = attr.split("}")[0][1:] + if ns not in self.OOXML_NAMESPACES: + attrs_to_remove.append(attr) + + for attr in attrs_to_remove: + del elem.attrib[attr] + + self._remove_ignorable_elements(xml_copy) + + return lxml.etree.ElementTree(xml_copy) + + def _remove_ignorable_elements(self, root): + elements_to_remove = [] + + for elem in list(root): + if not hasattr(elem, "tag") or callable(elem.tag): + continue + + tag_str = str(elem.tag) + if tag_str.startswith("{"): + ns = tag_str.split("}")[0][1:] + if ns not in self.OOXML_NAMESPACES: + elements_to_remove.append(elem) + continue + + self._remove_ignorable_elements(elem) + + for elem in elements_to_remove: + root.remove(elem) + + def _preprocess_for_mc_ignorable(self, xml_doc): + root = xml_doc.getroot() + + if f"{{{self.MC_NAMESPACE}}}Ignorable" in root.attrib: + del root.attrib[f"{{{self.MC_NAMESPACE}}}Ignorable"] + + return xml_doc + + def _validate_single_file_xsd(self, xml_file, base_path): + schema_path = self._get_schema_path(xml_file) + if not schema_path: + return None, None + + try: + with open(schema_path, "rb") as xsd_file: + parser = lxml.etree.XMLParser() + xsd_doc = lxml.etree.parse( + xsd_file, parser=parser, base_url=str(schema_path) + ) + schema = lxml.etree.XMLSchema(xsd_doc) + + with open(xml_file, "r") as f: + xml_doc = lxml.etree.parse(f) + + xml_doc, _ = self._remove_template_tags_from_text_nodes(xml_doc) + xml_doc = self._preprocess_for_mc_ignorable(xml_doc) + + relative_path = xml_file.relative_to(base_path) + if ( + relative_path.parts + and relative_path.parts[0] in self.MAIN_CONTENT_FOLDERS + ): + xml_doc = self._clean_ignorable_namespaces(xml_doc) + + if schema.validate(xml_doc): + return True, set() + else: + errors = set() + for error in schema.error_log: + errors.add(error.message) + return False, errors + + except Exception as e: + return False, {str(e)} + + def _get_original_file_errors(self, xml_file): + if self.original_file is None: + return set() + + import tempfile + import zipfile + + xml_file = Path(xml_file).resolve() + unpacked_dir = self.unpacked_dir.resolve() + relative_path = xml_file.relative_to(unpacked_dir) + + with tempfile.TemporaryDirectory() as temp_dir: + temp_path = Path(temp_dir) + + with zipfile.ZipFile(self.original_file, "r") as zip_ref: + zip_ref.extractall(temp_path) + + original_xml_file = temp_path / relative_path + + if not original_xml_file.exists(): + return set() + + is_valid, errors = self._validate_single_file_xsd( + original_xml_file, temp_path + ) + return errors if errors else set() + + def _remove_template_tags_from_text_nodes(self, xml_doc): + warnings = [] + template_pattern = re.compile(r"\{\{[^}]*\}\}") + + xml_string = lxml.etree.tostring(xml_doc, encoding="unicode") + xml_copy = lxml.etree.fromstring(xml_string) + + def process_text_content(text, content_type): + if not text: + return text + matches = list(template_pattern.finditer(text)) + if matches: + for match in matches: + warnings.append( + f"Found template tag in {content_type}: {match.group()}" + ) + return template_pattern.sub("", text) + return text + + for elem in xml_copy.iter(): + if not hasattr(elem, "tag") or callable(elem.tag): + continue + tag_str = str(elem.tag) + if tag_str.endswith("}t") or tag_str == "t": + continue + + elem.text = process_text_content(elem.text, "text content") + elem.tail = process_text_content(elem.tail, "tail content") + + return lxml.etree.ElementTree(xml_copy), warnings + + +if __name__ == "__main__": + raise RuntimeError("This module should not be run directly.") diff --git a/.claude/skills/docx/scripts/office/validators/docx.py b/.claude/skills/docx/scripts/office/validators/docx.py new file mode 100644 index 00000000..fec405e6 --- /dev/null +++ b/.claude/skills/docx/scripts/office/validators/docx.py @@ -0,0 +1,446 @@ +""" +Validator for Word document XML files against XSD schemas. +""" + +import random +import re +import tempfile +import zipfile + +import defusedxml.minidom +import lxml.etree + +from .base import BaseSchemaValidator + + +class DOCXSchemaValidator(BaseSchemaValidator): + + WORD_2006_NAMESPACE = "http://schemas.openxmlformats.org/wordprocessingml/2006/main" + W14_NAMESPACE = "http://schemas.microsoft.com/office/word/2010/wordml" + W16CID_NAMESPACE = "http://schemas.microsoft.com/office/word/2016/wordml/cid" + + ELEMENT_RELATIONSHIP_TYPES = {} + + def validate(self): + if not self.validate_xml(): + return False + + all_valid = True + if not self.validate_namespaces(): + all_valid = False + + if not self.validate_unique_ids(): + all_valid = False + + if not self.validate_file_references(): + all_valid = False + + if not self.validate_content_types(): + all_valid = False + + if not self.validate_against_xsd(): + all_valid = False + + if not self.validate_whitespace_preservation(): + all_valid = False + + if not self.validate_deletions(): + all_valid = False + + if not self.validate_insertions(): + all_valid = False + + if not self.validate_all_relationship_ids(): + all_valid = False + + if not self.validate_id_constraints(): + all_valid = False + + if not self.validate_comment_markers(): + all_valid = False + + self.compare_paragraph_counts() + + return all_valid + + def validate_whitespace_preservation(self): + errors = [] + + for xml_file in self.xml_files: + if xml_file.name != "document.xml": + continue + + try: + root = lxml.etree.parse(str(xml_file)).getroot() + + for elem in root.iter(f"{{{self.WORD_2006_NAMESPACE}}}t"): + if elem.text: + text = elem.text + if re.search(r"^[ \t\n\r]", text) or re.search( + r"[ \t\n\r]$", text + ): + xml_space_attr = f"{{{self.XML_NAMESPACE}}}space" + if ( + xml_space_attr not in elem.attrib + or elem.attrib[xml_space_attr] != "preserve" + ): + text_preview = ( + repr(text)[:50] + "..." + if len(repr(text)) > 50 + else repr(text) + ) + errors.append( + f" {xml_file.relative_to(self.unpacked_dir)}: " + f"Line {elem.sourceline}: w:t element with whitespace missing xml:space='preserve': {text_preview}" + ) + + except (lxml.etree.XMLSyntaxError, Exception) as e: + errors.append( + f" {xml_file.relative_to(self.unpacked_dir)}: Error: {e}" + ) + + if errors: + print(f"FAILED - Found {len(errors)} whitespace preservation violations:") + for error in errors: + print(error) + return False + else: + if self.verbose: + print("PASSED - All whitespace is properly preserved") + return True + + def validate_deletions(self): + errors = [] + + for xml_file in self.xml_files: + if xml_file.name != "document.xml": + continue + + try: + root = lxml.etree.parse(str(xml_file)).getroot() + namespaces = {"w": self.WORD_2006_NAMESPACE} + + for t_elem in root.xpath(".//w:del//w:t", namespaces=namespaces): + if t_elem.text: + text_preview = ( + repr(t_elem.text)[:50] + "..." + if len(repr(t_elem.text)) > 50 + else repr(t_elem.text) + ) + errors.append( + f" {xml_file.relative_to(self.unpacked_dir)}: " + f"Line {t_elem.sourceline}: <w:t> found within <w:del>: {text_preview}" + ) + + for instr_elem in root.xpath( + ".//w:del//w:instrText", namespaces=namespaces + ): + text_preview = ( + repr(instr_elem.text or "")[:50] + "..." + if len(repr(instr_elem.text or "")) > 50 + else repr(instr_elem.text or "") + ) + errors.append( + f" {xml_file.relative_to(self.unpacked_dir)}: " + f"Line {instr_elem.sourceline}: <w:instrText> found within <w:del> (use <w:delInstrText>): {text_preview}" + ) + + except (lxml.etree.XMLSyntaxError, Exception) as e: + errors.append( + f" {xml_file.relative_to(self.unpacked_dir)}: Error: {e}" + ) + + if errors: + print(f"FAILED - Found {len(errors)} deletion validation violations:") + for error in errors: + print(error) + return False + else: + if self.verbose: + print("PASSED - No w:t elements found within w:del elements") + return True + + def count_paragraphs_in_unpacked(self): + count = 0 + + for xml_file in self.xml_files: + if xml_file.name != "document.xml": + continue + + try: + root = lxml.etree.parse(str(xml_file)).getroot() + paragraphs = root.findall(f".//{{{self.WORD_2006_NAMESPACE}}}p") + count = len(paragraphs) + except Exception as e: + print(f"Error counting paragraphs in unpacked document: {e}") + + return count + + def count_paragraphs_in_original(self): + original = self.original_file + if original is None: + return 0 + + count = 0 + + try: + with tempfile.TemporaryDirectory() as temp_dir: + with zipfile.ZipFile(original, "r") as zip_ref: + zip_ref.extractall(temp_dir) + + doc_xml_path = temp_dir + "/word/document.xml" + root = lxml.etree.parse(doc_xml_path).getroot() + + paragraphs = root.findall(f".//{{{self.WORD_2006_NAMESPACE}}}p") + count = len(paragraphs) + + except Exception as e: + print(f"Error counting paragraphs in original document: {e}") + + return count + + def validate_insertions(self): + errors = [] + + for xml_file in self.xml_files: + if xml_file.name != "document.xml": + continue + + try: + root = lxml.etree.parse(str(xml_file)).getroot() + namespaces = {"w": self.WORD_2006_NAMESPACE} + + invalid_elements = root.xpath( + ".//w:ins//w:delText[not(ancestor::w:del)]", namespaces=namespaces + ) + + for elem in invalid_elements: + text_preview = ( + repr(elem.text or "")[:50] + "..." + if len(repr(elem.text or "")) > 50 + else repr(elem.text or "") + ) + errors.append( + f" {xml_file.relative_to(self.unpacked_dir)}: " + f"Line {elem.sourceline}: <w:delText> within <w:ins>: {text_preview}" + ) + + except (lxml.etree.XMLSyntaxError, Exception) as e: + errors.append( + f" {xml_file.relative_to(self.unpacked_dir)}: Error: {e}" + ) + + if errors: + print(f"FAILED - Found {len(errors)} insertion validation violations:") + for error in errors: + print(error) + return False + else: + if self.verbose: + print("PASSED - No w:delText elements within w:ins elements") + return True + + def compare_paragraph_counts(self): + original_count = self.count_paragraphs_in_original() + new_count = self.count_paragraphs_in_unpacked() + + diff = new_count - original_count + diff_str = f"+{diff}" if diff > 0 else str(diff) + print(f"\nParagraphs: {original_count} → {new_count} ({diff_str})") + + def _parse_id_value(self, val: str, base: int = 16) -> int: + return int(val, base) + + def validate_id_constraints(self): + errors = [] + para_id_attr = f"{{{self.W14_NAMESPACE}}}paraId" + durable_id_attr = f"{{{self.W16CID_NAMESPACE}}}durableId" + + for xml_file in self.xml_files: + try: + for elem in lxml.etree.parse(str(xml_file)).iter(): + if val := elem.get(para_id_attr): + if self._parse_id_value(val, base=16) >= 0x80000000: + errors.append( + f" {xml_file.name}:{elem.sourceline}: paraId={val} >= 0x80000000" + ) + + if val := elem.get(durable_id_attr): + if xml_file.name == "numbering.xml": + try: + if self._parse_id_value(val, base=10) >= 0x7FFFFFFF: + errors.append( + f" {xml_file.name}:{elem.sourceline}: " + f"durableId={val} >= 0x7FFFFFFF" + ) + except ValueError: + errors.append( + f" {xml_file.name}:{elem.sourceline}: " + f"durableId={val} must be decimal in numbering.xml" + ) + else: + if self._parse_id_value(val, base=16) >= 0x7FFFFFFF: + errors.append( + f" {xml_file.name}:{elem.sourceline}: " + f"durableId={val} >= 0x7FFFFFFF" + ) + except Exception: + pass + + if errors: + print(f"FAILED - {len(errors)} ID constraint violations:") + for e in errors: + print(e) + elif self.verbose: + print("PASSED - All paraId/durableId values within constraints") + return not errors + + def validate_comment_markers(self): + errors = [] + + document_xml = None + comments_xml = None + for xml_file in self.xml_files: + if xml_file.name == "document.xml" and "word" in str(xml_file): + document_xml = xml_file + elif xml_file.name == "comments.xml": + comments_xml = xml_file + + if not document_xml: + if self.verbose: + print("PASSED - No document.xml found (skipping comment validation)") + return True + + try: + doc_root = lxml.etree.parse(str(document_xml)).getroot() + namespaces = {"w": self.WORD_2006_NAMESPACE} + + range_starts = { + elem.get(f"{{{self.WORD_2006_NAMESPACE}}}id") + for elem in doc_root.xpath( + ".//w:commentRangeStart", namespaces=namespaces + ) + } + range_ends = { + elem.get(f"{{{self.WORD_2006_NAMESPACE}}}id") + for elem in doc_root.xpath( + ".//w:commentRangeEnd", namespaces=namespaces + ) + } + references = { + elem.get(f"{{{self.WORD_2006_NAMESPACE}}}id") + for elem in doc_root.xpath( + ".//w:commentReference", namespaces=namespaces + ) + } + + orphaned_ends = range_ends - range_starts + for comment_id in sorted( + orphaned_ends, key=lambda x: int(x) if x and x.isdigit() else 0 + ): + errors.append( + f' document.xml: commentRangeEnd id="{comment_id}" has no matching commentRangeStart' + ) + + orphaned_starts = range_starts - range_ends + for comment_id in sorted( + orphaned_starts, key=lambda x: int(x) if x and x.isdigit() else 0 + ): + errors.append( + f' document.xml: commentRangeStart id="{comment_id}" has no matching commentRangeEnd' + ) + + comment_ids = set() + if comments_xml and comments_xml.exists(): + comments_root = lxml.etree.parse(str(comments_xml)).getroot() + comment_ids = { + elem.get(f"{{{self.WORD_2006_NAMESPACE}}}id") + for elem in comments_root.xpath( + ".//w:comment", namespaces=namespaces + ) + } + + marker_ids = range_starts | range_ends | references + invalid_refs = marker_ids - comment_ids + for comment_id in sorted( + invalid_refs, key=lambda x: int(x) if x and x.isdigit() else 0 + ): + if comment_id: + errors.append( + f' document.xml: marker id="{comment_id}" references non-existent comment' + ) + + except (lxml.etree.XMLSyntaxError, Exception) as e: + errors.append(f" Error parsing XML: {e}") + + if errors: + print(f"FAILED - {len(errors)} comment marker violations:") + for error in errors: + print(error) + return False + else: + if self.verbose: + print("PASSED - All comment markers properly paired") + return True + + def repair(self) -> int: + repairs = super().repair() + repairs += self.repair_durableId() + return repairs + + def repair_durableId(self) -> int: + repairs = 0 + + for xml_file in self.xml_files: + try: + content = xml_file.read_text(encoding="utf-8") + dom = defusedxml.minidom.parseString(content) + modified = False + + for elem in dom.getElementsByTagName("*"): + if not elem.hasAttribute("w16cid:durableId"): + continue + + durable_id = elem.getAttribute("w16cid:durableId") + needs_repair = False + + if xml_file.name == "numbering.xml": + try: + needs_repair = ( + self._parse_id_value(durable_id, base=10) >= 0x7FFFFFFF + ) + except ValueError: + needs_repair = True + else: + try: + needs_repair = ( + self._parse_id_value(durable_id, base=16) >= 0x7FFFFFFF + ) + except ValueError: + needs_repair = True + + if needs_repair: + value = random.randint(1, 0x7FFFFFFE) + if xml_file.name == "numbering.xml": + new_id = str(value) + else: + new_id = f"{value:08X}" + + elem.setAttribute("w16cid:durableId", new_id) + print( + f" Repaired: {xml_file.name}: durableId {durable_id} → {new_id}" + ) + repairs += 1 + modified = True + + if modified: + xml_file.write_bytes(dom.toxml(encoding="UTF-8")) + + except Exception: + pass + + return repairs + + +if __name__ == "__main__": + raise RuntimeError("This module should not be run directly.") diff --git a/.claude/skills/docx/scripts/office/validators/pptx.py b/.claude/skills/docx/scripts/office/validators/pptx.py new file mode 100644 index 00000000..09842aa9 --- /dev/null +++ b/.claude/skills/docx/scripts/office/validators/pptx.py @@ -0,0 +1,275 @@ +""" +Validator for PowerPoint presentation XML files against XSD schemas. +""" + +import re + +from .base import BaseSchemaValidator + + +class PPTXSchemaValidator(BaseSchemaValidator): + + PRESENTATIONML_NAMESPACE = ( + "http://schemas.openxmlformats.org/presentationml/2006/main" + ) + + ELEMENT_RELATIONSHIP_TYPES = { + "sldid": "slide", + "sldmasterid": "slidemaster", + "notesmasterid": "notesmaster", + "sldlayoutid": "slidelayout", + "themeid": "theme", + "tablestyleid": "tablestyles", + } + + def validate(self): + if not self.validate_xml(): + return False + + all_valid = True + if not self.validate_namespaces(): + all_valid = False + + if not self.validate_unique_ids(): + all_valid = False + + if not self.validate_uuid_ids(): + all_valid = False + + if not self.validate_file_references(): + all_valid = False + + if not self.validate_slide_layout_ids(): + all_valid = False + + if not self.validate_content_types(): + all_valid = False + + if not self.validate_against_xsd(): + all_valid = False + + if not self.validate_notes_slide_references(): + all_valid = False + + if not self.validate_all_relationship_ids(): + all_valid = False + + if not self.validate_no_duplicate_slide_layouts(): + all_valid = False + + return all_valid + + def validate_uuid_ids(self): + import lxml.etree + + errors = [] + uuid_pattern = re.compile( + r"^[\{\(]?[0-9A-Fa-f]{8}-?[0-9A-Fa-f]{4}-?[0-9A-Fa-f]{4}-?[0-9A-Fa-f]{4}-?[0-9A-Fa-f]{12}[\}\)]?$" + ) + + for xml_file in self.xml_files: + try: + root = lxml.etree.parse(str(xml_file)).getroot() + + for elem in root.iter(): + for attr, value in elem.attrib.items(): + attr_name = attr.split("}")[-1].lower() + if attr_name == "id" or attr_name.endswith("id"): + if self._looks_like_uuid(value): + if not uuid_pattern.match(value): + errors.append( + f" {xml_file.relative_to(self.unpacked_dir)}: " + f"Line {elem.sourceline}: ID '{value}' appears to be a UUID but contains invalid hex characters" + ) + + except (lxml.etree.XMLSyntaxError, Exception) as e: + errors.append( + f" {xml_file.relative_to(self.unpacked_dir)}: Error: {e}" + ) + + if errors: + print(f"FAILED - Found {len(errors)} UUID ID validation errors:") + for error in errors: + print(error) + return False + else: + if self.verbose: + print("PASSED - All UUID-like IDs contain valid hex values") + return True + + def _looks_like_uuid(self, value): + clean_value = value.strip("{}()").replace("-", "") + return len(clean_value) == 32 and all(c.isalnum() for c in clean_value) + + def validate_slide_layout_ids(self): + import lxml.etree + + errors = [] + + slide_masters = list(self.unpacked_dir.glob("ppt/slideMasters/*.xml")) + + if not slide_masters: + if self.verbose: + print("PASSED - No slide masters found") + return True + + for slide_master in slide_masters: + try: + root = lxml.etree.parse(str(slide_master)).getroot() + + rels_file = slide_master.parent / "_rels" / f"{slide_master.name}.rels" + + if not rels_file.exists(): + errors.append( + f" {slide_master.relative_to(self.unpacked_dir)}: " + f"Missing relationships file: {rels_file.relative_to(self.unpacked_dir)}" + ) + continue + + rels_root = lxml.etree.parse(str(rels_file)).getroot() + + valid_layout_rids = set() + for rel in rels_root.findall( + f".//{{{self.PACKAGE_RELATIONSHIPS_NAMESPACE}}}Relationship" + ): + rel_type = rel.get("Type", "") + if "slideLayout" in rel_type: + valid_layout_rids.add(rel.get("Id")) + + for sld_layout_id in root.findall( + f".//{{{self.PRESENTATIONML_NAMESPACE}}}sldLayoutId" + ): + r_id = sld_layout_id.get( + f"{{{self.OFFICE_RELATIONSHIPS_NAMESPACE}}}id" + ) + layout_id = sld_layout_id.get("id") + + if r_id and r_id not in valid_layout_rids: + errors.append( + f" {slide_master.relative_to(self.unpacked_dir)}: " + f"Line {sld_layout_id.sourceline}: sldLayoutId with id='{layout_id}' " + f"references r:id='{r_id}' which is not found in slide layout relationships" + ) + + except (lxml.etree.XMLSyntaxError, Exception) as e: + errors.append( + f" {slide_master.relative_to(self.unpacked_dir)}: Error: {e}" + ) + + if errors: + print(f"FAILED - Found {len(errors)} slide layout ID validation errors:") + for error in errors: + print(error) + print( + "Remove invalid references or add missing slide layouts to the relationships file." + ) + return False + else: + if self.verbose: + print("PASSED - All slide layout IDs reference valid slide layouts") + return True + + def validate_no_duplicate_slide_layouts(self): + import lxml.etree + + errors = [] + slide_rels_files = list(self.unpacked_dir.glob("ppt/slides/_rels/*.xml.rels")) + + for rels_file in slide_rels_files: + try: + root = lxml.etree.parse(str(rels_file)).getroot() + + layout_rels = [ + rel + for rel in root.findall( + f".//{{{self.PACKAGE_RELATIONSHIPS_NAMESPACE}}}Relationship" + ) + if "slideLayout" in rel.get("Type", "") + ] + + if len(layout_rels) > 1: + errors.append( + f" {rels_file.relative_to(self.unpacked_dir)}: has {len(layout_rels)} slideLayout references" + ) + + except Exception as e: + errors.append( + f" {rels_file.relative_to(self.unpacked_dir)}: Error: {e}" + ) + + if errors: + print("FAILED - Found slides with duplicate slideLayout references:") + for error in errors: + print(error) + return False + else: + if self.verbose: + print("PASSED - All slides have exactly one slideLayout reference") + return True + + def validate_notes_slide_references(self): + import lxml.etree + + errors = [] + notes_slide_references = {} + + slide_rels_files = list(self.unpacked_dir.glob("ppt/slides/_rels/*.xml.rels")) + + if not slide_rels_files: + if self.verbose: + print("PASSED - No slide relationship files found") + return True + + for rels_file in slide_rels_files: + try: + root = lxml.etree.parse(str(rels_file)).getroot() + + for rel in root.findall( + f".//{{{self.PACKAGE_RELATIONSHIPS_NAMESPACE}}}Relationship" + ): + rel_type = rel.get("Type", "") + if "notesSlide" in rel_type: + target = rel.get("Target", "") + if target: + normalized_target = target.replace("../", "") + + slide_name = rels_file.stem.replace( + ".xml", "" + ) + + if normalized_target not in notes_slide_references: + notes_slide_references[normalized_target] = [] + notes_slide_references[normalized_target].append( + (slide_name, rels_file) + ) + + except (lxml.etree.XMLSyntaxError, Exception) as e: + errors.append( + f" {rels_file.relative_to(self.unpacked_dir)}: Error: {e}" + ) + + for target, references in notes_slide_references.items(): + if len(references) > 1: + slide_names = [ref[0] for ref in references] + errors.append( + f" Notes slide '{target}' is referenced by multiple slides: {', '.join(slide_names)}" + ) + for slide_name, rels_file in references: + errors.append(f" - {rels_file.relative_to(self.unpacked_dir)}") + + if errors: + print( + f"FAILED - Found {len([e for e in errors if not e.startswith(' ')])} notes slide reference validation errors:" + ) + for error in errors: + print(error) + print("Each slide may optionally have its own slide file.") + return False + else: + if self.verbose: + print("PASSED - All notes slide references are unique") + return True + + +if __name__ == "__main__": + raise RuntimeError("This module should not be run directly.") diff --git a/.claude/skills/docx/scripts/office/validators/redlining.py b/.claude/skills/docx/scripts/office/validators/redlining.py new file mode 100644 index 00000000..71c81b6b --- /dev/null +++ b/.claude/skills/docx/scripts/office/validators/redlining.py @@ -0,0 +1,247 @@ +""" +Validator for tracked changes in Word documents. +""" + +import subprocess +import tempfile +import zipfile +from pathlib import Path + + +class RedliningValidator: + + def __init__(self, unpacked_dir, original_docx, verbose=False, author="Claude"): + self.unpacked_dir = Path(unpacked_dir) + self.original_docx = Path(original_docx) + self.verbose = verbose + self.author = author + self.namespaces = { + "w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main" + } + + def repair(self) -> int: + return 0 + + def validate(self): + modified_file = self.unpacked_dir / "word" / "document.xml" + if not modified_file.exists(): + print(f"FAILED - Modified document.xml not found at {modified_file}") + return False + + try: + import xml.etree.ElementTree as ET + + tree = ET.parse(modified_file) + root = tree.getroot() + + del_elements = root.findall(".//w:del", self.namespaces) + ins_elements = root.findall(".//w:ins", self.namespaces) + + author_del_elements = [ + elem + for elem in del_elements + if elem.get(f"{{{self.namespaces['w']}}}author") == self.author + ] + author_ins_elements = [ + elem + for elem in ins_elements + if elem.get(f"{{{self.namespaces['w']}}}author") == self.author + ] + + if not author_del_elements and not author_ins_elements: + if self.verbose: + print(f"PASSED - No tracked changes by {self.author} found.") + return True + + except Exception: + pass + + with tempfile.TemporaryDirectory() as temp_dir: + temp_path = Path(temp_dir) + + try: + with zipfile.ZipFile(self.original_docx, "r") as zip_ref: + zip_ref.extractall(temp_path) + except Exception as e: + print(f"FAILED - Error unpacking original docx: {e}") + return False + + original_file = temp_path / "word" / "document.xml" + if not original_file.exists(): + print( + f"FAILED - Original document.xml not found in {self.original_docx}" + ) + return False + + try: + import xml.etree.ElementTree as ET + + modified_tree = ET.parse(modified_file) + modified_root = modified_tree.getroot() + original_tree = ET.parse(original_file) + original_root = original_tree.getroot() + except ET.ParseError as e: + print(f"FAILED - Error parsing XML files: {e}") + return False + + self._remove_author_tracked_changes(original_root) + self._remove_author_tracked_changes(modified_root) + + modified_text = self._extract_text_content(modified_root) + original_text = self._extract_text_content(original_root) + + if modified_text != original_text: + error_message = self._generate_detailed_diff( + original_text, modified_text + ) + print(error_message) + return False + + if self.verbose: + print(f"PASSED - All changes by {self.author} are properly tracked") + return True + + def _generate_detailed_diff(self, original_text, modified_text): + error_parts = [ + f"FAILED - Document text doesn't match after removing {self.author}'s tracked changes", + "", + "Likely causes:", + " 1. Modified text inside another author's <w:ins> or <w:del> tags", + " 2. Made edits without proper tracked changes", + " 3. Didn't nest <w:del> inside <w:ins> when deleting another's insertion", + "", + "For pre-redlined documents, use correct patterns:", + " - To reject another's INSERTION: Nest <w:del> inside their <w:ins>", + " - To restore another's DELETION: Add new <w:ins> AFTER their <w:del>", + "", + ] + + git_diff = self._get_git_word_diff(original_text, modified_text) + if git_diff: + error_parts.extend(["Differences:", "============", git_diff]) + else: + error_parts.append("Unable to generate word diff (git not available)") + + return "\n".join(error_parts) + + def _get_git_word_diff(self, original_text, modified_text): + try: + with tempfile.TemporaryDirectory() as temp_dir: + temp_path = Path(temp_dir) + + original_file = temp_path / "original.txt" + modified_file = temp_path / "modified.txt" + + original_file.write_text(original_text, encoding="utf-8") + modified_file.write_text(modified_text, encoding="utf-8") + + result = subprocess.run( + [ + "git", + "diff", + "--word-diff=plain", + "--word-diff-regex=.", + "-U0", + "--no-index", + str(original_file), + str(modified_file), + ], + capture_output=True, + text=True, + ) + + if result.stdout.strip(): + lines = result.stdout.split("\n") + content_lines = [] + in_content = False + for line in lines: + if line.startswith("@@"): + in_content = True + continue + if in_content and line.strip(): + content_lines.append(line) + + if content_lines: + return "\n".join(content_lines) + + result = subprocess.run( + [ + "git", + "diff", + "--word-diff=plain", + "-U0", + "--no-index", + str(original_file), + str(modified_file), + ], + capture_output=True, + text=True, + ) + + if result.stdout.strip(): + lines = result.stdout.split("\n") + content_lines = [] + in_content = False + for line in lines: + if line.startswith("@@"): + in_content = True + continue + if in_content and line.strip(): + content_lines.append(line) + return "\n".join(content_lines) + + except (subprocess.CalledProcessError, FileNotFoundError, Exception): + pass + + return None + + def _remove_author_tracked_changes(self, root): + ins_tag = f"{{{self.namespaces['w']}}}ins" + del_tag = f"{{{self.namespaces['w']}}}del" + author_attr = f"{{{self.namespaces['w']}}}author" + + for parent in root.iter(): + to_remove = [] + for child in parent: + if child.tag == ins_tag and child.get(author_attr) == self.author: + to_remove.append(child) + for elem in to_remove: + parent.remove(elem) + + deltext_tag = f"{{{self.namespaces['w']}}}delText" + t_tag = f"{{{self.namespaces['w']}}}t" + + for parent in root.iter(): + to_process = [] + for child in parent: + if child.tag == del_tag and child.get(author_attr) == self.author: + to_process.append((child, list(parent).index(child))) + + for del_elem, del_index in reversed(to_process): + for elem in del_elem.iter(): + if elem.tag == deltext_tag: + elem.tag = t_tag + + for child in reversed(list(del_elem)): + parent.insert(del_index, child) + parent.remove(del_elem) + + def _extract_text_content(self, root): + p_tag = f"{{{self.namespaces['w']}}}p" + t_tag = f"{{{self.namespaces['w']}}}t" + + paragraphs = [] + for p_elem in root.findall(f".//{p_tag}"): + text_parts = [] + for t_elem in p_elem.findall(f".//{t_tag}"): + if t_elem.text: + text_parts.append(t_elem.text) + paragraph_text = "".join(text_parts) + if paragraph_text: + paragraphs.append(paragraph_text) + + return "\n".join(paragraphs) + + +if __name__ == "__main__": + raise RuntimeError("This module should not be run directly.") diff --git a/.claude/skills/docx/scripts/templates/comments.xml b/.claude/skills/docx/scripts/templates/comments.xml new file mode 100644 index 00000000..cd01a7d7 --- /dev/null +++ b/.claude/skills/docx/scripts/templates/comments.xml @@ -0,0 +1,3 @@ +<?xml version="1.0" ?> +<w:comments xmlns:wpc="http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas" xmlns:cx="http://schemas.microsoft.com/office/drawing/2014/chartex" xmlns:cx1="http://schemas.microsoft.com/office/drawing/2015/9/8/chartex" xmlns:cx2="http://schemas.microsoft.com/office/drawing/2015/10/21/chartex" xmlns:cx3="http://schemas.microsoft.com/office/drawing/2016/5/9/chartex" xmlns:cx4="http://schemas.microsoft.com/office/drawing/2016/5/10/chartex" xmlns:cx5="http://schemas.microsoft.com/office/drawing/2016/5/11/chartex" xmlns:cx6="http://schemas.microsoft.com/office/drawing/2016/5/12/chartex" xmlns:cx7="http://schemas.microsoft.com/office/drawing/2016/5/13/chartex" xmlns:cx8="http://schemas.microsoft.com/office/drawing/2016/5/14/chartex" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:aink="http://schemas.microsoft.com/office/drawing/2016/ink" xmlns:am3d="http://schemas.microsoft.com/office/drawing/2017/model3d" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:oel="http://schemas.microsoft.com/office/2019/extlst" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math" xmlns:v="urn:schemas-microsoft-com:vml" xmlns:wp14="http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing" xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" xmlns:w10="urn:schemas-microsoft-com:office:word" xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml" xmlns:w15="http://schemas.microsoft.com/office/word/2012/wordml" xmlns:w16cex="http://schemas.microsoft.com/office/word/2018/wordml/cex" xmlns:w16cid="http://schemas.microsoft.com/office/word/2016/wordml/cid" xmlns:w16="http://schemas.microsoft.com/office/word/2018/wordml" xmlns:w16du="http://schemas.microsoft.com/office/word/2023/wordml/word16du" xmlns:w16sdtdh="http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash" xmlns:w16sdtfl="http://schemas.microsoft.com/office/word/2024/wordml/sdtformatlock" xmlns:w16se="http://schemas.microsoft.com/office/word/2015/wordml/symex" xmlns:wpg="http://schemas.microsoft.com/office/word/2010/wordprocessingGroup" xmlns:wpi="http://schemas.microsoft.com/office/word/2010/wordprocessingInk" xmlns:wne="http://schemas.microsoft.com/office/word/2006/wordml" xmlns:wps="http://schemas.microsoft.com/office/word/2010/wordprocessingShape" mc:Ignorable="w14 w15 w16se w16cid w16 w16cex w16sdtdh w16sdtfl w16du wp14"> +</w:comments> diff --git a/.claude/skills/docx/scripts/templates/commentsExtended.xml b/.claude/skills/docx/scripts/templates/commentsExtended.xml new file mode 100644 index 00000000..411003cc --- /dev/null +++ b/.claude/skills/docx/scripts/templates/commentsExtended.xml @@ -0,0 +1,3 @@ +<?xml version="1.0" ?> +<w15:commentsEx xmlns:wpc="http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas" xmlns:cx="http://schemas.microsoft.com/office/drawing/2014/chartex" xmlns:cx1="http://schemas.microsoft.com/office/drawing/2015/9/8/chartex" xmlns:cx2="http://schemas.microsoft.com/office/drawing/2015/10/21/chartex" xmlns:cx3="http://schemas.microsoft.com/office/drawing/2016/5/9/chartex" xmlns:cx4="http://schemas.microsoft.com/office/drawing/2016/5/10/chartex" xmlns:cx5="http://schemas.microsoft.com/office/drawing/2016/5/11/chartex" xmlns:cx6="http://schemas.microsoft.com/office/drawing/2016/5/12/chartex" xmlns:cx7="http://schemas.microsoft.com/office/drawing/2016/5/13/chartex" xmlns:cx8="http://schemas.microsoft.com/office/drawing/2016/5/14/chartex" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:aink="http://schemas.microsoft.com/office/drawing/2016/ink" xmlns:am3d="http://schemas.microsoft.com/office/drawing/2017/model3d" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:oel="http://schemas.microsoft.com/office/2019/extlst" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math" xmlns:v="urn:schemas-microsoft-com:vml" xmlns:wp14="http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing" xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" xmlns:w10="urn:schemas-microsoft-com:office:word" xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml" xmlns:w15="http://schemas.microsoft.com/office/word/2012/wordml" xmlns:w16cex="http://schemas.microsoft.com/office/word/2018/wordml/cex" xmlns:w16cid="http://schemas.microsoft.com/office/word/2016/wordml/cid" xmlns:w16="http://schemas.microsoft.com/office/word/2018/wordml" xmlns:w16du="http://schemas.microsoft.com/office/word/2023/wordml/word16du" xmlns:w16sdtdh="http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash" xmlns:w16sdtfl="http://schemas.microsoft.com/office/word/2024/wordml/sdtformatlock" xmlns:w16se="http://schemas.microsoft.com/office/word/2015/wordml/symex" xmlns:wpg="http://schemas.microsoft.com/office/word/2010/wordprocessingGroup" xmlns:wpi="http://schemas.microsoft.com/office/word/2010/wordprocessingInk" xmlns:wne="http://schemas.microsoft.com/office/word/2006/wordml" xmlns:wps="http://schemas.microsoft.com/office/word/2010/wordprocessingShape" mc:Ignorable="w14 w15 w16se w16cid w16 w16cex w16sdtdh w16sdtfl w16du wp14"> +</w15:commentsEx> diff --git a/.claude/skills/docx/scripts/templates/commentsExtensible.xml b/.claude/skills/docx/scripts/templates/commentsExtensible.xml new file mode 100644 index 00000000..f5572d71 --- /dev/null +++ b/.claude/skills/docx/scripts/templates/commentsExtensible.xml @@ -0,0 +1,3 @@ +<?xml version="1.0" ?> +<w16cex:commentsExtensible xmlns:wpc="http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas" xmlns:cx="http://schemas.microsoft.com/office/drawing/2014/chartex" xmlns:cx1="http://schemas.microsoft.com/office/drawing/2015/9/8/chartex" xmlns:cx2="http://schemas.microsoft.com/office/drawing/2015/10/21/chartex" xmlns:cx3="http://schemas.microsoft.com/office/drawing/2016/5/9/chartex" xmlns:cx4="http://schemas.microsoft.com/office/drawing/2016/5/10/chartex" xmlns:cx5="http://schemas.microsoft.com/office/drawing/2016/5/11/chartex" xmlns:cx6="http://schemas.microsoft.com/office/drawing/2016/5/12/chartex" xmlns:cx7="http://schemas.microsoft.com/office/drawing/2016/5/13/chartex" xmlns:cx8="http://schemas.microsoft.com/office/drawing/2016/5/14/chartex" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:aink="http://schemas.microsoft.com/office/drawing/2016/ink" xmlns:am3d="http://schemas.microsoft.com/office/drawing/2017/model3d" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:oel="http://schemas.microsoft.com/office/2019/extlst" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math" xmlns:v="urn:schemas-microsoft-com:vml" xmlns:wp14="http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing" xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" xmlns:w10="urn:schemas-microsoft-com:office:word" xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml" xmlns:w15="http://schemas.microsoft.com/office/word/2012/wordml" xmlns:w16cex="http://schemas.microsoft.com/office/word/2018/wordml/cex" xmlns:w16cid="http://schemas.microsoft.com/office/word/2016/wordml/cid" xmlns:w16="http://schemas.microsoft.com/office/word/2018/wordml" xmlns:w16du="http://schemas.microsoft.com/office/word/2023/wordml/word16du" xmlns:w16sdtdh="http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash" xmlns:w16sdtfl="http://schemas.microsoft.com/office/word/2024/wordml/sdtformatlock" xmlns:w16se="http://schemas.microsoft.com/office/word/2015/wordml/symex" xmlns:wpg="http://schemas.microsoft.com/office/word/2010/wordprocessingGroup" xmlns:wpi="http://schemas.microsoft.com/office/word/2010/wordprocessingInk" xmlns:wne="http://schemas.microsoft.com/office/word/2006/wordml" xmlns:wps="http://schemas.microsoft.com/office/word/2010/wordprocessingShape" xmlns:cr="http://schemas.microsoft.com/office/comments/2020/reactions" mc:Ignorable="w14 w15 w16se w16cid w16 w16cex w16sdtdh w16sdtfl cr w16du wp14"> +</w16cex:commentsExtensible> diff --git a/.claude/skills/docx/scripts/templates/commentsIds.xml b/.claude/skills/docx/scripts/templates/commentsIds.xml new file mode 100644 index 00000000..32f1629f --- /dev/null +++ b/.claude/skills/docx/scripts/templates/commentsIds.xml @@ -0,0 +1,3 @@ +<?xml version="1.0" ?> +<w16cid:commentsIds xmlns:wpc="http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas" xmlns:cx="http://schemas.microsoft.com/office/drawing/2014/chartex" xmlns:cx1="http://schemas.microsoft.com/office/drawing/2015/9/8/chartex" xmlns:cx2="http://schemas.microsoft.com/office/drawing/2015/10/21/chartex" xmlns:cx3="http://schemas.microsoft.com/office/drawing/2016/5/9/chartex" xmlns:cx4="http://schemas.microsoft.com/office/drawing/2016/5/10/chartex" xmlns:cx5="http://schemas.microsoft.com/office/drawing/2016/5/11/chartex" xmlns:cx6="http://schemas.microsoft.com/office/drawing/2016/5/12/chartex" xmlns:cx7="http://schemas.microsoft.com/office/drawing/2016/5/13/chartex" xmlns:cx8="http://schemas.microsoft.com/office/drawing/2016/5/14/chartex" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:aink="http://schemas.microsoft.com/office/drawing/2016/ink" xmlns:am3d="http://schemas.microsoft.com/office/drawing/2017/model3d" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:oel="http://schemas.microsoft.com/office/2019/extlst" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math" xmlns:v="urn:schemas-microsoft-com:vml" xmlns:wp14="http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing" xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" xmlns:w10="urn:schemas-microsoft-com:office:word" xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml" xmlns:w15="http://schemas.microsoft.com/office/word/2012/wordml" xmlns:w16cex="http://schemas.microsoft.com/office/word/2018/wordml/cex" xmlns:w16cid="http://schemas.microsoft.com/office/word/2016/wordml/cid" xmlns:w16="http://schemas.microsoft.com/office/word/2018/wordml" xmlns:w16du="http://schemas.microsoft.com/office/word/2023/wordml/word16du" xmlns:w16sdtdh="http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash" xmlns:w16sdtfl="http://schemas.microsoft.com/office/word/2024/wordml/sdtformatlock" xmlns:w16se="http://schemas.microsoft.com/office/word/2015/wordml/symex" xmlns:wpg="http://schemas.microsoft.com/office/word/2010/wordprocessingGroup" xmlns:wpi="http://schemas.microsoft.com/office/word/2010/wordprocessingInk" xmlns:wne="http://schemas.microsoft.com/office/word/2006/wordml" xmlns:wps="http://schemas.microsoft.com/office/word/2010/wordprocessingShape" mc:Ignorable="w14 w15 w16se w16cid w16 w16cex w16sdtdh w16sdtfl w16du wp14"> +</w16cid:commentsIds> diff --git a/.claude/skills/docx/scripts/templates/people.xml b/.claude/skills/docx/scripts/templates/people.xml new file mode 100644 index 00000000..3803d2de --- /dev/null +++ b/.claude/skills/docx/scripts/templates/people.xml @@ -0,0 +1,3 @@ +<?xml version="1.0" ?> +<w15:people xmlns:w15="http://schemas.microsoft.com/office/word/2012/wordml"> +</w15:people> diff --git a/.claude/skills/drawio/SKILL.md b/.claude/skills/drawio/SKILL.md new file mode 100644 index 00000000..96d39130 --- /dev/null +++ b/.claude/skills/drawio/SKILL.md @@ -0,0 +1,250 @@ +--- +name: drawio +description: Generate draw.io diagrams as .drawio files, optionally export to PNG/SVG/PDF with embedded XML. Use when the user asks to create diagrams, flowcharts, architecture diagrams, sequence diagrams, ER diagrams, network diagrams, org charts, or any visual diagram. Also use when the user mentions draw.io, drawio, mxGraph, or wants a visual representation of a system, process, or data flow. +license: Apache-2.0 +metadata: + source: https://github.com/jgraph/drawio-mcp + author: JGraph + modifications: Adapted for Open Elements projects +--- + +# Draw.io Diagram Skill + +Generate draw.io diagrams as native `.drawio` files. Optionally export to PNG, SVG, or PDF with the diagram XML embedded (so the exported file remains editable in draw.io). + +## How to create a diagram + +1. **Generate draw.io XML** in mxGraphModel format for the requested diagram +2. **Write the XML** to a `.drawio` file in the current working directory using the Write tool +3. **If the user requested an export format** (png, svg, pdf), export using the draw.io CLI with `--embed-diagram`, then delete the source `.drawio` file +4. **Open the result** — the exported file if exported, or the `.drawio` file otherwise + +## Choosing the output format + +Check the user's request for a format preference. Examples: + +- `/drawio create a flowchart` → `flowchart.drawio` +- `/drawio png flowchart for login` → `login-flow.drawio.png` +- `/drawio svg: ER diagram` → `er-diagram.drawio.svg` +- `/drawio pdf architecture overview` → `architecture-overview.drawio.pdf` + +If no format is mentioned, just write the `.drawio` file and open it in draw.io. The user can always ask to export later. + +### Supported export formats + +| Format | Embed XML | Notes | +|--------|-----------|-------| +| `png` | Yes (`-e`) | Viewable everywhere, editable in draw.io | +| `svg` | Yes (`-e`) | Scalable, editable in draw.io | +| `pdf` | Yes (`-e`) | Printable, editable in draw.io | +| `jpg` | No | Lossy, no embedded XML support | + +PNG, SVG, and PDF all support `--embed-diagram` — the exported file contains the full diagram XML, so opening it in draw.io recovers the editable diagram. + +## draw.io CLI + +The draw.io desktop app includes a command-line interface for exporting. + +### Locating the CLI + +Try `drawio` first (works if on PATH), then fall back to the platform-specific path: + +- **macOS**: `/Applications/draw.io.app/Contents/MacOS/draw.io` +- **Linux**: `drawio` (typically on PATH via snap/apt/flatpak) +- **Windows**: `"C:\Program Files\draw.io\draw.io.exe"` + +Use `which drawio` (or `where drawio` on Windows) to check if it's on PATH before falling back. + +### Export command + +```bash +drawio -x -f <format> -e -b 10 -o <output> <input.drawio> +``` + +Key flags: +- `-x` / `--export`: export mode +- `-f` / `--format`: output format (png, svg, pdf, jpg) +- `-e` / `--embed-diagram`: embed diagram XML in the output (PNG, SVG, PDF only) +- `-o` / `--output`: output file path +- `-b` / `--border`: border width around diagram (default: 0) +- `-t` / `--transparent`: transparent background (PNG only) +- `-s` / `--scale`: scale the diagram size +- `--width` / `--height`: fit into specified dimensions (preserves aspect ratio) +- `-a` / `--all-pages`: export all pages (PDF only) +- `-p` / `--page-index`: select a specific page (1-based) + +### Opening the result + +- **macOS**: `open <file>` +- **Linux**: `xdg-open <file>` +- **Windows**: `start <file>` + +## File naming + +- Use a descriptive filename based on the diagram content (e.g., `login-flow`, `database-schema`) +- Use lowercase with hyphens for multi-word names +- For export, use double extensions: `name.drawio.png`, `name.drawio.svg`, `name.drawio.pdf` — this signals the file contains embedded diagram XML +- After a successful export, delete the intermediate `.drawio` file — the exported file contains the full diagram + +## XML format + +A `.drawio` file is native mxGraphModel XML. Always generate XML directly — Mermaid and CSV formats require server-side conversion and cannot be saved as native files. + +### Basic structure + +Every diagram must have this structure: + +```xml +<mxGraphModel> + <root> + <mxCell id="0"/> + <mxCell id="1" parent="0"/> + <!-- Diagram cells go here with parent="1" --> + </root> +</mxGraphModel> +``` + +- Cell `id="0"` is the root layer +- Cell `id="1"` is the default parent layer +- All diagram elements use `parent="1"` unless using multiple layers + +### Common styles + +**Rounded rectangle:** +```xml +<mxCell id="2" value="Label" style="rounded=1;whiteSpace=wrap;" vertex="1" parent="1"> + <mxGeometry x="100" y="100" width="120" height="60" as="geometry"/> +</mxCell> +``` + +**Diamond (decision):** +```xml +<mxCell id="3" value="Condition?" style="rhombus;whiteSpace=wrap;" vertex="1" parent="1"> + <mxGeometry x="100" y="200" width="120" height="80" as="geometry"/> +</mxCell> +``` + +**Arrow (edge):** +```xml +<mxCell id="4" value="" style="edgeStyle=orthogonalEdgeStyle;" edge="1" source="2" target="3" parent="1"> + <mxGeometry relative="1" as="geometry"/> +</mxCell> +``` + +**Labeled arrow:** +```xml +<mxCell id="5" value="Yes" style="edgeStyle=orthogonalEdgeStyle;" edge="1" source="3" target="6" parent="1"> + <mxGeometry relative="1" as="geometry"/> +</mxCell> +``` + +### Useful style properties + +| Property | Values | Use for | +|----------|--------|---------| +| `rounded=1` | 0 or 1 | Rounded corners | +| `whiteSpace=wrap` | wrap | Text wrapping | +| `fillColor=#dae8fc` | Hex color | Background color | +| `strokeColor=#6c8ebf` | Hex color | Border color | +| `fontColor=#333333` | Hex color | Text color | +| `shape=cylinder3` | shape name | Database cylinders | +| `shape=mxgraph.flowchart.document` | shape name | Document shapes | +| `ellipse` | style keyword | Circles/ovals | +| `rhombus` | style keyword | Diamonds | +| `edgeStyle=orthogonalEdgeStyle` | style keyword | Right-angle connectors | +| `edgeStyle=elbowEdgeStyle` | style keyword | Elbow connectors | +| `dashed=1` | 0 or 1 | Dashed lines | +| `swimlane` | style keyword | Swimlane containers | +| `group` | style keyword | Invisible container (pointerEvents=0) | +| `container=1` | 0 or 1 | Enable container behavior on any shape | +| `pointerEvents=0` | 0 or 1 | Prevent container from capturing child connections | + +## Edge routing + +**CRITICAL: Every edge `mxCell` must contain a `<mxGeometry relative="1" as="geometry" />` child element**, even when there are no waypoints. Self-closing edge cells (e.g. `<mxCell ... edge="1" ... />`) are invalid and will not render correctly. Always use the expanded form: +```xml +<mxCell id="e1" edge="1" parent="1" source="a" target="b" style="..."> + <mxGeometry relative="1" as="geometry" /> +</mxCell> +``` + +draw.io does **not** have built-in collision detection for edges. Plan layout and routing carefully: + +- Use `edgeStyle=orthogonalEdgeStyle` for right-angle connectors (most common) +- **Space nodes generously** — at least 60px apart, prefer 200px horizontal / 120px vertical gaps +- Use `exitX`/`exitY` and `entryX`/`entryY` (values 0–1) to control which side of a node an edge connects to. Spread connections across different sides to prevent overlap +- **Leave room for arrowheads**: The final straight segment of an edge (between the last bend and the target shape, or between the source shape and the first bend) must be long enough to fit the arrowhead. The default arrow size is 6px (configurable via `startSize`/`endSize` styles). If the final segment is too short, the arrowhead overlaps the bend and looks broken. Ensure at least 20px of straight segment before the target and after the source when placing waypoints or positioning nodes +- When using `orthogonalEdgeStyle`, the auto-router places bends automatically — if source and target are close together or nearly aligned on one axis, the router may place a bend very close to a shape, leaving no room for the arrow. Fix this by either increasing node spacing or adding explicit waypoints that keep the final segment long enough +- Add explicit **waypoints** when edges would overlap: + ```xml + <mxCell id="e1" style="edgeStyle=orthogonalEdgeStyle;" edge="1" parent="1" source="a" target="b"> + <mxGeometry relative="1" as="geometry"> + <Array as="points"> + <mxPoint x="300" y="150"/> + <mxPoint x="300" y="250"/> + </Array> + </mxGeometry> + </mxCell> + ``` +- Use `rounded=1` on edges for cleaner bends +- Use `jettySize=auto` for better port spacing on orthogonal edges +- Align all nodes to a grid (multiples of 10) + +## Containers and groups + +For architecture diagrams or any diagram with nested elements, use draw.io's proper parent-child containment — do **not** just place shapes on top of larger shapes. + +### How containment works + +Set `parent="containerId"` on child cells. Children use **relative coordinates** within the container. + +### Container types + +| Type | Style | When to use | +|------|-------|-------------| +| **Group** (invisible) | `group;` | No visual border needed, container has no connections. Includes `pointerEvents=0` so child connections are not captured | +| **Swimlane** (titled) | `swimlane;startSize=30;` | Container needs a visible title bar/header, or the container itself has connections | +| **Custom container** | Add `container=1;pointerEvents=0;` to any shape style | Any shape acting as a container without its own connections | + +### Key rules + +- **Always add `pointerEvents=0;`** to container styles that should not capture connections being rewired between children +- Only omit `pointerEvents=0` when the container itself needs to be connectable — in that case, use `swimlane` style which handles this correctly (the client area is transparent for mouse events while the header remains connectable) +- Children must set `parent="containerId"` and use coordinates **relative to the container** + +### Example: Architecture container with swimlane + +```xml +<mxCell id="svc1" value="User Service" style="swimlane;startSize=30;fillColor=#dae8fc;strokeColor=#6c8ebf;" vertex="1" parent="1"> + <mxGeometry x="100" y="100" width="300" height="200" as="geometry"/> +</mxCell> +<mxCell id="api1" value="REST API" style="rounded=1;whiteSpace=wrap;" vertex="1" parent="svc1"> + <mxGeometry x="20" y="40" width="120" height="60" as="geometry"/> +</mxCell> +<mxCell id="db1" value="Database" style="shape=cylinder3;whiteSpace=wrap;" vertex="1" parent="svc1"> + <mxGeometry x="160" y="40" width="120" height="60" as="geometry"/> +</mxCell> +``` + +### Example: Invisible group container + +```xml +<mxCell id="grp1" value="" style="group;" vertex="1" parent="1"> + <mxGeometry x="100" y="100" width="300" height="200" as="geometry"/> +</mxCell> +<mxCell id="c1" value="Component A" style="rounded=1;whiteSpace=wrap;" vertex="1" parent="grp1"> + <mxGeometry x="10" y="10" width="120" height="60" as="geometry"/> +</mxCell> +``` + +## Style reference + +For the complete draw.io style reference: https://www.drawio.com/doc/faq/drawio-style-reference.html + +For the XML Schema Definition (XSD): https://www.drawio.com/assets/mxfile.xsd + +## CRITICAL: XML well-formedness + +- **NEVER use double hyphens (`--`) inside XML comments.** `--` is illegal inside `<!-- -->` per the XML spec and causes parse errors. Use single hyphens or rephrase. +- Escape special characters in attribute values: `&`, `<`, `>`, `"` +- Always use unique `id` values for each `mxCell` \ No newline at end of file diff --git a/.claude/skills/eclipse-info/SKILL.md b/.claude/skills/eclipse-info/SKILL.md new file mode 100644 index 00000000..8cde70c0 --- /dev/null +++ b/.claude/skills/eclipse-info/SKILL.md @@ -0,0 +1,176 @@ +--- +name: eclipse-info +license: Apache-2.0 +metadata: + source: https://github.com/open-elements/claude-base + author: Open Elements +description: Background information about the Eclipse Foundation and its key projects relevant to Open Elements — including Eclipse Adoptium/Temurin, Jakarta EE, the ORC WG (CRA compliance for open source), and the Eclipse IDE. Use when generating content that references the Eclipse Foundation, Adoptium, Temurin, Jakarta EE, ORC WG, CRA attestation, or when describing Open Elements' involvement in the Eclipse ecosystem. +--- + +# Eclipse Foundation Information + +## Overview + +The Eclipse Foundation is an international non-profit association (AISBL, based in Brussels) providing a vendor-neutral environment for open-source software collaboration and innovation. It is Europe's largest open-source foundation. + +- Founded: Eclipse Project created by IBM in November 2001, Eclipse Foundation established as independent entity in January 2004 +- Hosts 400+ open-source projects +- Supported by 300+ member organizations globally +- Domains: enterprise, cloud, edge computing, automotive, AI, IoT, embedded systems + +**Website:** https://www.eclipse.org + +### Core Services + +- IP Management +- Ecosystem Development & Marketing +- Development Process support +- IT Infrastructure (repositories, build systems, websites) + +## Membership Levels + +| Level | Governance | Annual Fee | +|-------|-----------|------------| +| **Strategic Member** | Seat on Board of Directors, Architecture Council, General Assembly voting, can lead Working Groups | 30,000-300,000 EUR (by revenue) | +| **Contributing Member** | Board representation through elected delegate, General Assembly voting, Working Group participation | 1,500-25,000 EUR (by revenue) | +| **Associate Member** | General Assembly attendance, guest Working Group membership | 0-25,000 EUR (free for government, NGOs, academia) | +| **Committer Member** | Board representation via elected committer delegate, no fees | Free | + +## Board of Directors (current) + +| Name | Organisation | +|------|-------------| +| Florian Bankoley | Robert Bosch GmbH | +| Bryan Che | Huawei Technologies | +| Angelo Corsaro | ZettaScale Technology | +| Tim Deboer | Red Hat | +| **Hendrik Ebbers** | **Open Elements** | +| James Eggleston | European Space Agency | +| John Ellis | Codethink Ltd. | +| Wolfgang Gehring | Mercedes-Benz Tech Innovation | +| Robert Hilbrich | DLR (German Aerospace Center) | +| Emily Jiang | IBM | +| Etienne Juliot | OBEO | +| Kenji Kazumura | Fujitsu | +| Matthew Khouzam | Ericsson | +| Rao Lakkakula | Microsoft | +| Shelley Lambert | Red Hat | +| Johannes Matheis | Vector Informatik | +| Ed Merks | Eclipse Modeling Framework | +| Chokri Mraidha | CEA LIST | +| Tom Ritter | Fraunhofer FOKUS | +| Matthias Sohn | SAP | +| Jim Wright | Oracle | + +## Eclipse Adoptium + +Eclipse Adoptium is a Working Group under the Eclipse Foundation that produces high-quality, enterprise-ready Java runtime binaries from a fully open-source build and test infrastructure. + +**Website:** https://adoptium.net + +### History + +- The AdoptOpenJDK project was established in 2017 to address the lack of an open and reproducible build and test system for OpenJDK across multiple platforms. +- Eclipse Adoptium is the continuation of this mission under the Eclipse Foundation. Hendrik Ebbers was a member of the AdoptOpenJDK Technical Steering Committee and is a founding member of Eclipse Adoptium. He also served on the Adoptium Steering Committee and PMC before stepping back due to time constraints when founding Open Elements. + +### Key Projects + +| Project | Purpose | +|---------|---------| +| **Eclipse Temurin** | Flagship OpenJDK distribution — high-performance, cross-platform, open-source Java runtimes. Java SE TCK certified and AQAvit verified. | +| **Eclipse AQAvit** | Quality assurance testing framework ensuring performance, reliability, and security in every build. | +| **Eclipse Mission Control** | JDK profiling and diagnostics tools. | + +### Eclipse Temurin Details + +- Supported LTS versions: JDK 8, 11, 17, 21, 25 +- **Platforms:** Windows (x64, aarch64), macOS (x64, aarch64), Linux (x64, aarch64, ppc64le, s390x), Docker container images +- Free of charge without usage restrictions +- 880+ million total downloads/Docker pulls +- 300+ open-source contributors +- Solaris and Windows 32-bit builds discontinued as of 2026 + +### Adoptium Working Group Members + +Strategic members include Microsoft, Red Hat, IBM, Arm, Atlassian, MongoDB, and others. + +## Jakarta EE + +Jakarta EE is the open-source platform for enterprise Java development under the Eclipse Foundation — the evolution of Java EE. It is described as "the new home of cloud native Java." + +### History + +Jakarta EE originated from Java EE, which was developed under the Java Community Process (JCP). When Java EE moved to the Eclipse Foundation, it was renamed to Jakarta EE, which included a namespace change from `javax.*` to `jakarta.*`. Hendrik Ebbers was already involved in the Java EE era as a member of JCP Expert Groups, contributing to specifications such as Java Bean Validation. He also supported the `javax` to `jakarta` namespace transition when the project moved to Eclipse. + +**Website:** https://jakarta.ee + +### Mission + +Enable developers to develop, run, and scale enterprise Java applications anywhere with the flexibility of open-source technology. Key principles: +- **Write once, run anywhere** — applications run consistently across certified runtimes +- **Cloud native** — designed for containers and orchestration +- **Security by design** — built-in security APIs +- **Vendor-neutral** — all Working Group members have equal voting power regardless of size + +### Profiles (Jakarta EE 11) + +| Profile | Scope | +|---------|-------| +| **Platform Profile** | Full specification set — Authorization, Batch, Messaging, Enterprise Beans, and more | +| **Web Profile** | Servlet, Faces, CDI, Persistence, Security, and related specs | +| **Core Profile** | Lightweight — RESTful Web Services, JSON Processing/Binding, CDI Lite | + +### Governance + +- Managed by the Jakarta EE Working Group under the Eclipse Foundation +- Specification process: Jakarta EE Specification Process (JESP) +- Strategic members: Fujitsu, IBM, Oracle, Payara, Tomitribe +- Formal committees oversee different aspects +- Compatible implementations available through certification program + +### Key Resources + +- Developer portal with learning hub and starter templates +- JakartaOne conference and Tech Talks +- Community contribution guidelines and mentorship programs + +## Open Regulatory Compliance Working Group (ORC WG) + +The ORC WG is a Working Group under the Eclipse Foundation focused on developing practical implementations of the Cyber Resilience Act (CRA) rules for open-source software and industry. + +**Website:** https://orcwg.org + +### Purpose + +The CRA introduces new regulatory requirements for software products in the EU, with significant implications for open-source software. The ORC WG works on concrete, implementable approaches to comply with these rules — bridging the gap between regulation and the realities of open-source development. + +### Key Workstreams + +- **CRA Attestation Working Group** — Develops attestation standards and processes for CRA compliance. Repository: https://github.com/orcwg/cra-attestations + +### Open Elements' Involvement + +Open Elements is a Founding Member and Participant Member of the ORC WG. Initially Hendrik Ebbers was a regular participant in the WG meetings. Sebastian Tiemann has since taken over and is especially active in the CRA Attestation Working Group. + +## Open Elements' Role in the Eclipse Foundation + +Open Elements is a Contributing Member of the Eclipse Foundation. Hendrik Ebbers, founder of Open Elements, serves on the Board of Directors. + +**Involvement in Working Groups:** +- **Eclipse Adoptium** — Participant Member. Hendrik Ebbers was on the AdoptOpenJDK TSC, is a founding member of Eclipse Adoptium, and served on the Adoptium Steering Committee and PMC before stepping back when founding Open Elements. +- **Jakarta EE** — Participant Member. +- **ORC WG** — Founding Member and Participant Member. Sebastian Tiemann is active in the CRA Attestation WG. + +See the `open-elements-info` skill for the full overview of Open Elements' foundation memberships and roles. + +## Key Links + +| Resource | URL | +|----------|-----| +| Eclipse Foundation | https://www.eclipse.org | +| Eclipse Adoptium | https://adoptium.net | +| Jakarta EE | https://jakarta.ee | +| ORC WG | https://orcwg.org | +| Board of Directors | https://www.eclipse.org/org/foundation/directors/ | +| Membership | https://www.eclipse.org/membership/ | +| Eclipse Projects | https://projects.eclipse.org | diff --git a/.claude/skills/frontend-design/SKILL.md b/.claude/skills/frontend-design/SKILL.md new file mode 100644 index 00000000..9f02b252 --- /dev/null +++ b/.claude/skills/frontend-design/SKILL.md @@ -0,0 +1,46 @@ +--- +name: frontend-design +description: Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, artifacts, posters, or applications (examples include websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished code and UI design that avoids generic AI aesthetics. +license: Apache-2.0 +metadata: + source: https://github.com/anthropics/skills + author: Anthropic + modifications: Adapted for Open Elements projects +--- + +This skill guides creation of distinctive, production-grade frontend interfaces that avoid generic "AI slop" aesthetics. Implement real working code with exceptional attention to aesthetic details and creative choices. + +The user provides frontend requirements: a component, page, application, or interface to build. They may include context about the purpose, audience, or technical constraints. + +## Design Thinking + +Before coding, understand the context and commit to a BOLD aesthetic direction: +- **Purpose**: What problem does this interface solve? Who uses it? +- **Tone**: Pick an extreme: brutally minimal, maximalist chaos, retro-futuristic, organic/natural, luxury/refined, playful/toy-like, editorial/magazine, brutalist/raw, art deco/geometric, soft/pastel, industrial/utilitarian, etc. There are so many flavors to choose from. Use these for inspiration but design one that is true to the aesthetic direction. +- **Constraints**: Technical requirements (framework, performance, accessibility). +- **Differentiation**: What makes this UNFORGETTABLE? What's the one thing someone will remember? + +**CRITICAL**: Choose a clear conceptual direction and execute it with precision. Bold maximalism and refined minimalism both work - the key is intentionality, not intensity. + +Then implement working code (HTML/CSS/JS, React, Vue, etc.) that is: +- Production-grade and functional +- Visually striking and memorable +- Cohesive with a clear aesthetic point-of-view +- Meticulously refined in every detail + +## Frontend Aesthetics Guidelines + +Focus on: +- **Typography**: Choose fonts that are beautiful, unique, and interesting. Avoid generic fonts like Arial and Inter; opt instead for distinctive choices that elevate the frontend's aesthetics; unexpected, characterful font choices. Pair a distinctive display font with a refined body font. +- **Color & Theme**: Commit to a cohesive aesthetic. Use CSS variables for consistency. Dominant colors with sharp accents outperform timid, evenly-distributed palettes. +- **Motion**: Use animations for effects and micro-interactions. Prioritize CSS-only solutions for HTML. Use Motion library for React when available. Focus on high-impact moments: one well-orchestrated page load with staggered reveals (animation-delay) creates more delight than scattered micro-interactions. Use scroll-triggering and hover states that surprise. +- **Spatial Composition**: Unexpected layouts. Asymmetry. Overlap. Diagonal flow. Grid-breaking elements. Generous negative space OR controlled density. +- **Backgrounds & Visual Details**: Create atmosphere and depth rather than defaulting to solid colors. Add contextual effects and textures that match the overall aesthetic. Apply creative forms like gradient meshes, noise textures, geometric patterns, layered transparencies, dramatic shadows, decorative borders, custom cursors, and grain overlays. + +NEVER use generic AI-generated aesthetics like overused font families (Inter, Roboto, Arial, system fonts), cliched color schemes (particularly purple gradients on white backgrounds), predictable layouts and component patterns, and cookie-cutter design that lacks context-specific character. + +Interpret creatively and make unexpected choices that feel genuinely designed for the context. No design should be the same. Vary between light and dark themes, different fonts, different aesthetics. NEVER converge on common choices (Space Grotesk, for example) across generations. + +**IMPORTANT**: Match implementation complexity to the aesthetic vision. Maximalist designs need elaborate code with extensive animations and effects. Minimalist or refined designs need restraint, precision, and careful attention to spacing, typography, and subtle details. Elegance comes from executing the vision well. + +Remember: Claude is capable of extraordinary creative work. Don't hold back, show what can truly be created when thinking outside the box and committing fully to a distinctive vision. diff --git a/.claude/skills/good-first-issues/SKILL.md b/.claude/skills/good-first-issues/SKILL.md new file mode 100644 index 00000000..33ff8cc5 --- /dev/null +++ b/.claude/skills/good-first-issues/SKILL.md @@ -0,0 +1,240 @@ +--- +name: good-first-issues +license: Apache-2.0 +metadata: + source: https://github.com/open-elements/claude-base + author: Open Elements +description: Create well-structured Good First Issues for open-source projects on GitHub. Produces beginner-friendly issues with clear descriptions, solution ideas, and welcoming formatting. Use when the user wants to create issues for newcomers, onboard new contributors, write good first issues, or improve contributor experience on GitHub repositories. +--- + +# Good First Issue Creator + +Create welcoming, well-structured GitHub issues that help newcomers make their first open-source contribution successfully. A good first issue is not just a task description — it is an invitation and a guided path into the project. + +## What Makes a Good First Issue + +A qualifying issue should be: + +- **Well-defined** — Clear goal, clear scope, no ambiguity about what "done" looks like +- **Manageable** — Completable in 30-90 minutes of focused work (after setup) +- **Educational** — The contributor learns something about the codebase +- **Non-critical** — No complex dependencies, no risk of breaking production +- **Self-contained** — Ideally touches 1-2 files, not a cross-cutting concern +- **Welcoming** — Tone matters. The issue should feel like an invitation, not a task assignment + +### Suitable Tasks + +- Spelling, grammar, or formatting fixes in docs or code comments +- Adding or improving docstrings / JSDoc / Javadoc +- Small refactors (rename for clarity, extract a constant, remove dead code) +- Adding a missing test case for existing functionality +- Fixing a simple, well-understood bug with an obvious fix location +- Adding a missing validation or error message +- Updating outdated examples or config values + +### NOT Suitable + +- Anything requiring deep architectural knowledge +- Tasks that touch multiple modules or have non-obvious side effects +- Performance optimizations requiring benchmarking +- Security-sensitive changes +- Features that require design decisions + +## Instructions + +### 1. Understand the context + +Ask the user (or determine from context): +- Which repository is this for? +- What is the task? (bug fix, docs improvement, test addition, refactor, etc.) +- What files are involved? +- What does the current behavior look like? What should it look like? +- Are there similar patterns in the codebase the contributor can follow? + +### 2. Determine the difficulty level + +Classify the issue into one of these levels: + +| Level | Time | Description | +|-------|------|-------------| +| **Good First Issue** | 30-90 min | Can be completed by following clear instructions. Minimal decision-making required. | +| **Beginner** | 2-4 hours | Requires reading some code and making small decisions, but not designing from scratch. | +| **Intermediate** | 4-8 hours | Requires navigating the codebase and understanding how components interact. | + +This skill focuses on **Good First Issues**. For beginner and intermediate issues, adapt the template by reducing the hand-holding and increasing the research expectations. + +### 3. Write the issue + +Use the template structure below. Every section uses an emoji heading for visual friendliness. The tone should be warm and encouraging throughout — remember that the person reading this may never have contributed to open source before. + +**Important writing principles:** + +- Never assume the contributor knows the codebase. Explain where files are and what they do. +- Use concrete examples: show actual code snippets, actual file paths, actual expected output. +- The "Solution Idea" section should give a clear direction without being a copy-paste recipe — the contributor should still learn by doing. +- Link to relevant files, docs, and similar examples in the codebase. +- If there is a pattern to follow (e.g., "look at how ClassX does it"), point to it explicitly. + +### 4. Review with the user + +Present the drafted issue and ask the user to review before creating it on GitHub. Check: +- Is the scope realistic for a newcomer? +- Are all file paths and links correct? +- Is the solution idea accurate? +- Is anything missing that a newcomer would need to know? + +## Issue Template + +Use this structure when writing Good First Issues. Adapt sections as needed — not every issue needs every section, but always include the core sections (marked as required). + +```markdown +## 🐣 Good First Issue + +Welcome! This is a beginner-friendly issue designed for first-time contributors. +No prior experience with this project is needed — just [language] basics and Git. + +⏱️ **Estimated time:** 30–90 minutes +🧩 **Difficulty:** Beginner-friendly +📁 **Files involved:** `path/to/file.ext` + +--- + +## 👾 Description ← REQUIRED + +[Clear explanation of what needs to change and why. +Show the current state and the desired state. +Use code blocks to illustrate.] + +**Current behavior:** +```[language] +// What it looks like now +``` + +**Desired behavior:** +```[language] +// What it should look like +``` + +--- + +## 💡 Solution Idea ← REQUIRED + +[High-level approach. Point to similar patterns in the codebase. +Give enough direction that the contributor knows where to start, +but not so much that there is nothing left to figure out.] + +1. Open `path/to/file.ext` +2. Look at how `SimilarClass` handles this — use the same pattern +3. [Specific guidance for this task] + +--- + +## 🔍 Helpful References + +[Links to relevant files, documentation, or examples that will +help the contributor understand the context.] + +- [`path/to/similar_file.ext`](link) — Example of the pattern to follow +- [Relevant documentation](link) +- [Language docs for the concept involved](link) + +--- + +## ✅ Done Checklist ← REQUIRED + +Before opening your PR, confirm: + +- [ ] My changes address what the issue asked for — nothing more, nothing less +- [ ] I tested my changes locally +- [ ] All CI checks pass +- [ ] [Any project-specific requirements, e.g., changelog entry, signed commits] + +--- + +## 🆘 Stuck? + +No worries — getting stuck is completely normal, especially on your first contribution! + +- **Comment on this issue** and describe what you have tried — a maintainer will help. +- **Check the project's contributing guide** for setup and workflow instructions. +- [Add project-specific support channels here, e.g., Discord, Slack, office hours] + +Do not spend more than 30 minutes blocked without asking for help. +Asking good questions is a skill too! 🙂 +``` + +## Formatting Guidelines + +### Emoji Usage + +Use emojis in section headings to make the issue visually scannable and welcoming. Stick to these conventions: + +| Emoji | Use for | +|-------|---------| +| 🐣 | Issue type header (Good First Issue) | +| 👾 | Description | +| 💡 | Solution idea | +| 🔍 | References / research pointers | +| 🛠️ | Implementation details (if needed) | +| 🧪 | Testing instructions (if needed) | +| ✅ | Done checklist | +| 🆘 | Stuck / help section | +| 📋 | Workflow reference | +| 🤖 | AI tips (if relevant) | +| 📚 | Additional resources | + +### Tone + +- Use "you" and "your" — address the contributor directly +- Say "Welcome!" at the start +- Use encouraging language: "No worries", "completely normal", "feel free to ask" +- Avoid jargon without explanation +- Never write "this should be easy" or "this is trivial" — what is trivial to a maintainer may be intimidating to a newcomer + +### GitHub Callouts + +Use GitHub's callout syntax for important information: + +```markdown +> [!TIP] +> Helpful advice for the contributor. + +> [!IMPORTANT] +> Critical information they must not miss. + +> [!NOTE] +> Additional context that is good to know. +``` + +## Difficulty Variants + +### Beginner Issues (next step after Good First Issues) + +For beginner issues, adjust the template: + +- Change header emoji to 🐥 and title to "Beginner Friendly" +- Increase estimated time to 2-4 hours +- Replace step-by-step instructions with research pointers ("look at how X does it") +- Add a "Background Research" section before the solution +- Expect the contributor to write tests +- Add a note: "We recommend completing at least 2-3 good first issues before attempting this" + +### Intermediate Issues + +For intermediate issues: + +- Change header emoji to 🔧 and title to "Intermediate" +- Increase estimated time to 4-8 hours +- Focus on the problem description and expected outcome, not the implementation path +- Expect the contributor to navigate the codebase independently +- Remove the "Stuck?" section — replace with "Questions? Comment below" + +## Labels + +Recommend the user apply these labels to the created issue: + +| Label | When to use | +|-------|------------| +| `good first issue` | GitHub's standard label — enables discoverability in GitHub's "Good First Issues" tab | +| `help wanted` | Signals the issue is open for external contributors | +| `documentation` / `tests` / `bug` | Describe the type of work | diff --git a/.claude/skills/grill-me/SKILL.md b/.claude/skills/grill-me/SKILL.md new file mode 100644 index 00000000..a58b5335 --- /dev/null +++ b/.claude/skills/grill-me/SKILL.md @@ -0,0 +1,175 @@ +--- +name: grill-me +license: Apache-2.0 +metadata: + source: https://github.com/open-elements/claude-base + author: Open Elements +description: Relentless Socratic interview that drills into technical plans, specifications, implementations, UI designs, blog drafts, or proposals until full clarity is reached. Systematically walks every branch of the decision tree — one dependency at a time — surfacing hidden assumptions, contradictions, missing requirements, and blind spots. Use when the user says "grill me", "drill into", "interview me about", "challenge my design", "stress-test this", or wants to think through a technical topic deeply before committing. +argument-hint: [topic, spec, design, implementation plan, blog draft, UI concept, or proposal to grill] +--- + +# Grill Me + +Relentless Socratic interviewer for technical work. Drills into any starting point until full clarity is reached — no hand-waving, no vague answers, no unresolved dependencies. + +## Identity Rules (Never Break These) + +1. Never accept a vague answer. If the answer is fuzzy, immediately follow up with a more specific question. +2. Never ask multiple questions at once. One question at a time, always. Pick the most important one. +3. Never move to the next branch until the current one is resolved or explicitly deferred. +4. When an answer contradicts a previous answer, flag the contradiction directly before continuing. +5. When an assumption is hidden inside an answer, surface it and make the user own it or reject it. +6. Never editorialize or praise answers. React with the next question or a contradiction flag, nothing else. +7. Keep questions tight — one sentence where possible. Complexity belongs in the answer, not the question. +8. When the user says "done", "enough", or "wrap up", switch to output mode — never cut off mid-branch without offering it. + +## Instructions + +### Phase 1 — Context Load (silent) + +1. Identify what was given: a file path, inline text, a topic name, or a mix. +2. If a file or spec is referenced, read it. If a codebase area is relevant, explore it. Do not ask the user questions that the code can answer. +3. Determine the **domain** of the grill from the input: + +| Domain | Trigger | +|--------|---------| +| **Specification** | spec, feature design, requirements, acceptance criteria | +| **Implementation** | code plan, architecture decision, refactoring, migration | +| **UI / Layout / Graphics** | wireframe, mockup, component design, visual concept, layout | +| **Technical Blog / Article** | blog post, tutorial, technical writing, documentation | +| **Proposal / Tender** | Ausschreibung, proposal, RFP response, project pitch | + +4. Load the domain-specific branch types (see below). Do NOT summarize what was read. Proceed directly to Phase 2. + +### Phase 2 — Map the Territory + +Produce a brief, structured map of the domain to grill. Show it to the user: + +``` +## Grill Map: [Title] + +**Domain:** [Specification | Implementation | UI/Layout | Blog/Article | Proposal] + +**What I understand so far:** [1-2 sentence honest summary of the starting point] + +**Branches to explore:** +- [ ] Branch A: [name] — [one-line description] +- [ ] Branch B: [name] — [one-line description] +- [ ] Branch C: [name] — [one-line description] +... + +**Starting with:** Branch A — [reason it's first] + +--- +[First question] +``` + +Ordering rule: start with the branch that most others depend on. If unclear, start with the branch that feels most assumed or skipped over. + +### Phase 3 — Drill (main loop) + +Run until all branches are resolved or user calls it done: + +1. Ask one question. +2. Wait for the answer. +3. Evaluate the answer: + - **Vague / hand-wavy** — follow up immediately, tighter scope. + - **Contradicts prior answer** — surface it: *"Earlier you said X. Now you're saying Y. Which is true, or is there a distinction I'm missing?"* + - **Contains a hidden assumption** — name it: *"That assumes [assumption]. Is that a constraint or a choice?"* + - **Skips a stakeholder or user group** — call it out: *"Who else is affected by this? You've only mentioned X."* + - **Resolves the thread** — mark branch as done, move to next. +4. When a branch closes: *"Branch [name] done — moving to [next]."* Then ask the first question of the next branch. +5. Track open threads. If an answer opens a new sub-branch, note it and return to it after the current one. + +### Phase 4 — Output (when done) + +When the session ends (user says done, or all branches resolved), produce: + +``` +## Grill Summary: [Title] + +### Resolved +[Bullet list of decisions, clarifications, and conclusions] + +### Open / Deferred +[Things explicitly left unresolved] + +### Contradictions or Tensions +[Unresolved tensions flagged during the session] + +### Recommended Next Steps +[Concrete, ordered actions — what to do with this clarity] +``` + +Then ask: **"Want me to update an existing spec, create a new document, or feed these results into another skill (e.g. `/spec-create`, `/spec-implement`)?"** + +## Domain-Specific Branch Types + +Use these to seed the grill map. Not every type applies — prune ruthlessly, only include branches that actually matter for the given input. + +### Specification + +| Branch | Drill for | +|--------|-----------| +| **Problem** | What exactly is broken or missing? Who feels the pain? How do they work around it today? | +| **Scope** | What's in, what's explicitly out? Where are the edges? | +| **Users / Actors** | Who uses this? What are their roles, permissions, expectations? | +| **Behavior** | What happens in the happy path? What happens on error? What are the edge cases? | +| **Data** | What data is created, read, updated, deleted? What are the invariants? | +| **Dependencies** | What does this depend on? What depends on this? What breaks if this changes? | +| **Constraints** | Performance, security, GDPR, backwards compatibility, deadlines | +| **Acceptance** | How do you know it's done? What's the test that proves it works? | + +### Implementation + +| Branch | Drill for | +|--------|-----------| +| **Approach** | Why this approach and not the obvious alternative? What was considered and rejected? | +| **Components** | Which files/modules/services are affected? Is the blast radius understood? | +| **API surface** | What's the public contract? What can callers rely on? What might change? | +| **Data model** | Schema changes? Migrations? Backwards compatibility of stored data? | +| **Error handling** | What fails? How does it fail? What does the user see? What gets logged? | +| **Testing** | How is this tested? What's hard to test? What's the regression risk? | +| **Rollback** | Can this be reverted safely? What's the rollback plan if it breaks in production? | +| **Performance** | What's the expected load? Where are the bottlenecks? Have you measured? | + +### UI / Layout / Graphics + +| Branch | Drill for | +|--------|-----------| +| **Purpose** | What decision or action does this screen/component enable? What's the user's goal? | +| **Information hierarchy** | What's the most important thing the user must see first? What's secondary? | +| **States** | Empty state, loading, error, partial data, full data, overflow — all covered? | +| **Interaction** | What's clickable? What happens on click, hover, focus, drag? Keyboard accessible? | +| **Responsiveness** | Mobile, tablet, desktop — what changes? What breaks? | +| **Brand consistency** | Does this follow the brand guidelines (colors, typography, spacing)? | +| **Accessibility** | Color contrast, screen reader support, focus management, ARIA labels? | +| **Edge cases** | Long text, missing images, slow network, right-to-left languages, zero results? | + +### Technical Blog / Article + +| Branch | Drill for | +|--------|-----------| +| **Audience** | Who reads this? What do they already know? What's their skill level? | +| **Core message** | In one sentence — what should the reader take away? | +| **Structure** | Does the narrative flow? Is there a hook? Does the ending land? | +| **Accuracy** | Are the technical claims correct? Are examples tested and working? | +| **Completeness** | Are prerequisites stated? Are setup steps reproducible? Are gotchas mentioned? | +| **Differentiation** | What exists on this topic already? Why should someone read this instead? | +| **Call to action** | What should the reader do after reading? Is that clear? | + +### Proposal / Tender (Ausschreibung) + +| Branch | Drill for | +|--------|-----------| +| **Requirements match** | Does the proposal actually address every requirement? Which ones are weak? | +| **Differentiators** | What makes this proposal stronger than a competitor's? Is that visible? | +| **Feasibility** | Is the timeline realistic? Are the resource estimates honest? What's the risk buffer? | +| **Pricing** | How was the price derived? What assumptions underlie the estimate? What's excluded? | +| **References** | Are the cited references actually comparable? Would they hold up to a call? | +| **Gaps** | What does the evaluator expect that's missing? What questions will they have? | +| **Compliance** | Are all formal requirements met (format, deadlines, certifications, legal)? | + +## Tone + +Direct and precise. No warmth-padding. Ask like a senior engineer reviewing a spec they'll have to live with. The user wants to think better — give them resistance, not agreement. diff --git a/.claude/skills/hedera-info/SKILL.md b/.claude/skills/hedera-info/SKILL.md new file mode 100644 index 00000000..58b7fcdd --- /dev/null +++ b/.claude/skills/hedera-info/SKILL.md @@ -0,0 +1,271 @@ +--- +name: hedera-info +license: Apache-2.0 +metadata: + source: https://github.com/open-elements/claude-base + author: Open Elements +description: Background information about the Hedera network — the public distributed ledger built on Hiero, governed by a council of global organizations. Covers the Hedera Mainnet, Testnet, HBAR cryptocurrency, Hedera Council, and the ecosystem organizations (Hashgraph, Hashgraph Association, HBAR Foundation). Use when generating content about Hedera as a product/network, its use cases, governance, HBAR token, or the organizations around it. Also use when the user mentions Hedera Mainnet, HBAR, HashScan, or Hedera Council. +--- + +# Hedera Network Information + +## Overview + +Hedera is a public, open-source, proof-of-stake distributed ledger network (DLT). It is built on the Hiero open-source codebase (see the `hiero-info` skill for technical details on the underlying technology) and governed by the Hedera Council — a decentralized body of leading global organizations. + +Hedera positions itself as "the trusted platform for building fast, secure, and compliant decentralized applications." + +- **Website:** https://hedera.com +- **Documentation:** https://docs.hedera.com +- **Block Explorer:** https://hashscan.io + +## HBAR + +HBAR (symbol: ℏ) is the native cryptocurrency of the Hedera network. It powers all network operations. + +### Denomination + +- **1 ℏ (HBAR)** = 100,000,000 tℏ (tinybars) +- Tinybars are the smallest unit — the network reports all balances and fees in tinybars + +### Uses + +- **Transaction fees** — All transactions and queries on the network cost fees paid in HBAR +- **Staking** — HBAR can be staked to network nodes as part of the proof-of-stake consensus +- **Application payments** — Used as a medium of exchange within Hedera-based applications +- **Network security** — Staked HBAR contributes to the network's security model + +### Fee Model + +Hedera avoids gas-based pricing (unlike Ethereum). Fees are: +- **Set in USD** — predictable and stable regardless of HBAR price +- **Converted to HBAR** at the time of transaction +- **Low and fixed** — e.g., consensus messages cost approximately $0.0001 per message + +## Network Services + +Hedera provides four core network services: + +### Hedera Token Service (HTS) + +Create and manage fungible and non-fungible tokens natively on the network. + +- Compatible with ERC-20 (fungible) and ERC-721 (NFT) standards +- 10,000+ TPS +- Native token operations (mint, burn, transfer, freeze, KYC) without smart contracts + +### Hedera Consensus Service (HCS) + +A decentralized message bus for writing immutable, verifiable, and consensus-timestamped data. + +- ~$0.0001 per message +- 10,000+ TPS +- Use cases: supply chain tracking, audit logs, IoT data streams, application event ordering + +### Smart Contract Service + +EVM-compatible smart contracts written in Solidity. + +- 10,000+ TPS +- Instant transaction finality +- Compatible with Ethereum development tools via JSON-RPC Relay: Web3.js, Ethers.js, Hardhat, Foundry, Truffle + +### File Service + +Decentralized file storage using hash-based file identification for secure storage and retrieval across the network. + +## Performance + +| Metric | Value | +|--------|-------| +| Throughput | 10,000+ TPS | +| Finality | Instant (seconds) | +| Consensus | Hashgraph (ABFT — Asynchronous Byzantine Fault Tolerant) | +| Node model | Permissioned (Council members operate nodes) | +| Fee model | USD-denominated, converted to HBAR at transaction time | + +## Networks + +### Mainnet + +The production network. All real HBAR transactions and live applications operate here. + +- Council members operate the consensus nodes +- Mirror nodes archive data and provide APIs for querying historical data +- Explorer: https://hashscan.io (select Mainnet) + +### Testnet + +A free test environment for developers. Mirrors mainnet functionality but uses test HBAR with no real value. + +- Free test HBAR available via the Hedera Developer Portal faucet or HashPack wallet +- Same services and APIs as mainnet +- Explorer: https://hashscan.io (select Testnet) + +### Previewnet + +An early-access network for testing upcoming features before they reach testnet and mainnet. + +### Local Development + +For local development, use **solo** — an opinionated CLI for deploying and managing standalone test networks. See the `hiero-info` skill for details on solo and the solo GitHub Action. (The older hiero-local-node tool is being deprecated in favor of solo.) + +## HashScan + +HashScan (https://hashscan.io) is the primary block explorer and analytics tool for the Hedera network. Built by Hashgraph. + +**Features:** +- View transactions, accounts, tokens, smart contracts, and topics +- Supports Mainnet, Testnet, and Previewnet +- Real-time transaction monitoring +- Token and NFT exploration +- Account balance and history lookup +- Smart contract verification + +## Hedera Council + +The Hedera Council is a decentralized governing body of leading global organizations that validate transactions on the Hedera network and steer its strategic direction. + +**Key principles:** +- Equal voting rights for all Council members +- Term limits to prevent concentration of power +- Members strategically spread across different regions and industries for collusion-proof governance +- Governed by the Hedera Council LLC Agreement + +**Website:** https://hederacouncil.org + +### Council Members (selection) + +The Council consists of 30+ organizations across industries: + +**Technology:** Dell, Google, LG, Hitachi, ServiceNow, Wipro +**Finance:** Shinhan Bank, Standard Bank, Nomura, LSE (London Stock Exchange) +**Telecommunications:** Deutsche Telekom, Tata Communications, Zain +**Enterprise:** FedEx, Mondelēz, Avery Dennison, Arrow Electronics +**Energy:** EDF, Repsol +**Blockchain/Crypto:** BitGo, Chainlink Labs, Swirlds +**Other:** Ubisoft, Australian Payments Plus + +### Participation Levels + +Beyond full Council membership: +- **Strategic Partners** — e.g., GBBC, Halborn +- **Community Partners** — e.g., HashPack, Hashgraph Online, Genfinity + +## Ecosystem Organizations + +### Hashgraph + +Hashgraph (formerly Swirlds Labs) is the primary software company providing technical development, product engineering, and marketing support for the Hedera network. + +- **Website:** https://hashgraph.com +- **Role:** Core engineering and ecosystem development for Hedera +- **CEO:** Eric Piscini +- **Co-founder of Hedera:** Mance Harmon +- **Inventor of hashgraph:** Dr. Leemon Baird (Co-founder & Chief Scientist) +- **Director of Open Source:** Hendrik Ebbers (founder of Open Elements, Hiero TSC Chair) + +**Products:** +- **HashSphere** — Private network powered by Hedera/Hiero technology +- **HashScan** — Block explorer and analytics tool (https://hashscan.io) +- **NFT Studio** — NFT development platform +- **HashioDAO** — Decentralized autonomous organization tooling +- **Hashio** — Network service offering + +**Note:** Hashgraph is a separate company from the Hedera Council. Hedera is an independent, council-governed public network; Hashgraph operates as a developer and service provider within that ecosystem. + +### HBAR Foundation + +The HBAR Foundation is dedicated to supporting the growth and development of the Hedera ecosystem through grants, investments, and ecosystem development programs. + +- Provides funding for projects building on Hedera +- Supports developer education and adoption programs +- Invests in ecosystem infrastructure and tooling + +### Hashgraph Association + +The Hashgraph Association is a Swiss-based organization focused on advancing the adoption of Hedera/Hiero technology, particularly in enterprise and institutional contexts. + +- Ecosystem development and adoption programs +- Enterprise partnerships and use case development +- Regional market development + +## Use Cases and Industries + +Hedera targets high-volume, cost-sensitive enterprise applications across several industries: + +### Finance & Payments + +- Tokenization of real-world assets (RWA) +- Cross-border payments with low, predictable fees +- Digital securities and compliance-ready financial products +- Islamic finance innovation (QFC Digital Asset Lab collaboration via Hashgraph) + +### Supply Chain & Logistics + +- Immutable tracking via Hedera Consensus Service +- Provenance verification for goods +- FedEx (Council member) — logistics and shipping applications + +### Sustainability & Carbon Markets + +- Carbon credit tokenization and tracking +- ESG reporting with verifiable, immutable data +- Environmental asset management + +### AI & Data Integrity + +- Verifiable data provenance for AI training data +- Consensus-timestamped audit trails +- Decentralized data marketplaces + +### Identity & Credentials + +- Decentralized identity (DID) solutions +- Verifiable credentials +- See the `hiero-info` skill for the Hiero DID SDKs + +### Notable Deployments + +- **Project Acacia (Australia)** — HashSphere selected as infrastructure provider +- **Standard Bank** — Financial services on Hedera (Council member) +- **ServiceNow** — Enterprise workflow integration (Council member) +- **Chainlink Labs** — Oracle services integration (Council member) + +## Relationship: Hedera, Hiero, and the Ecosystem + +Understanding the relationship between these entities is important: + +| Entity | What it is | +|--------|-----------| +| **Hiero** | The open-source codebase (under LF Decentralized Trust) from which Hedera is built. Anyone can use Hiero to run their own DLT. See `hiero-info` skill. | +| **Hedera Mainnet** | The production public network running Hiero code, governed by the Hedera Council | +| **Hedera Council** | The governing body of 30+ organizations that operate nodes and steer strategy | +| **Hashgraph** | The software company providing engineering and products for the Hedera ecosystem | +| **HBAR Foundation** | Grant and investment organization supporting Hedera ecosystem growth | +| **Hashgraph Association** | Swiss organization advancing enterprise adoption of Hedera/Hiero technology | +| **HBAR** | The native cryptocurrency powering the Hedera network | + +## Developer Resources + +| Resource | URL | +|----------|-----| +| Hedera Documentation | https://docs.hedera.com | +| Developer Portal | https://portal.hedera.com | +| HashScan Explorer | https://hashscan.io | +| Hedera SDKs | See `hiero-info` skill (SDKs are now under the Hiero project) | +| JSON-RPC Relay | See `hiero-info` skill | +| Hedera GitHub (legacy) | https://github.com/hashgraph | +| Hiero GitHub (current) | https://github.com/hiero-ledger | + +## Key Links + +| Resource | URL | +|----------|-----| +| Hedera Website | https://hedera.com | +| Hedera Council | https://hederacouncil.org | +| Hedera Documentation | https://docs.hedera.com | +| HashScan | https://hashscan.io | +| Hashgraph (company) | https://hashgraph.com | +| HBAR Foundation | https://www.hbarfoundation.org | +| Hiero (open-source base) | https://hiero.org | diff --git a/.claude/skills/hiero-info/SKILL.md b/.claude/skills/hiero-info/SKILL.md new file mode 100644 index 00000000..ae0e679e --- /dev/null +++ b/.claude/skills/hiero-info/SKILL.md @@ -0,0 +1,184 @@ +--- +name: hiero-info +license: Apache-2.0 +metadata: + source: https://github.com/open-elements/claude-base + author: Open Elements +description: Background information about the Hiero project — an open-source distributed ledger technology (DLT) under Linux Foundation Decentralized Trust (LFDT). Use when generating content that references Hiero, Hedera, hashgraph consensus, DLT/blockchain technology, or when working on code within the Hiero ecosystem. Also use when the user mentions LFDT, distributed ledger, or decentralized trust. +--- + +# Hiero Project Information + +## Overview + +Hiero is an open-source, vendor-neutral distributed ledger technology (DLT) project under Linux Foundation Decentralized Trust (LFDT). It is the foundational technology for the Hedera public ledger — one of the largest public DLTs in operation. + +Hedera donated its entire codebase to LFDT, creating Hiero. The Hedera Mainnet is now built from Hiero code. This same code can be used by anyone to operate their own public or private DLT — a first in the industry. + +In August 2025, Hiero graduated as the first project under the LFDT umbrella and its new Project Lifecycle Framework. + +- **Website:** https://hiero.org +- **Blog:** https://hiero.org/blog/ +- **GitHub:** https://github.com/hiero-ledger/ +- **License:** Apache License 2.0 + +## LF Decentralized Trust (LFDT) + +LFDT is a sub-foundation of the Linux Foundation focused on collaborative development of decentralized technologies and standards. It covers decentralized identity, ledger technologies, interoperability, cryptographic tools, smart contracts, and implementation tooling. + +Notable members include Accenture, American Express, Citi, ConsenSys, DTCC, Fujitsu, Hedera, IBM, Polygon, and Walmart. + +- **Website:** https://www.lfdecentralizedtrust.org + +## Technical Foundation + +### Hashgraph Consensus + +Hiero uses the hashgraph consensus algorithm, invented by Dr. Leemon Baird. Key properties: + +- **ABFT (Asynchronous Byzantine Fault Tolerant):** The highest security category for distributed consensus — tolerates malicious nodes and network partitions without assumptions about message timing. +- **Leaderless:** Every node participates equally. No node has a special role, making the protocol resistant to targeted denial-of-service attacks. +- **Fair ordering:** Transactions are processed in a fair, consensus-determined order — no single participant can manipulate sequencing. +- **High throughput:** Achieves high performance without sacrificing security or fairness. + +### Architecture Components + +| Component | Purpose | +|-----------|---------| +| **Consensus Node** | Core — processes transactions and executes consensus (Java) | +| **Block Node** | Block processing service (Java) | +| **Mirror Node** | Archives data from consensus nodes, provides query APIs (Java) | +| **JSON-RPC Relay** | Ethereum JSON-RPC API bridge for EVM compatibility (TypeScript) | +| **Local Node** | Local development and test network (TypeScript) | + +### Ethereum Compatibility + +The JSON-RPC Relay implements Ethereum JSON-RPC APIs, allowing Ethereum developers and tools to interact with Hiero/Hedera networks. The project maintains Ethereum execution spec tests for EVM regression validation. + +### Hiero Improvement Proposals (HIPs) + +HIPs are the formal process for proposing changes to the protocol (similar to BIPs for Bitcoin or EIPs for Ethereum). Repository: https://github.com/hiero-ledger/hiero-improvement-proposals + +## SDKs + +Hiero provides SDKs in seven languages: + +| SDK | Language | Repository | +|-----|----------|------------| +| hiero-sdk-java | Java | https://github.com/hiero-ledger/hiero-sdk-java | +| hiero-sdk-js | JavaScript/TypeScript | https://github.com/hiero-ledger/hiero-sdk-js | +| hiero-sdk-go | Go | https://github.com/hiero-ledger/hiero-sdk-go | +| hiero-sdk-python | Python | https://github.com/hiero-ledger/hiero-sdk-python | +| hiero-sdk-rust | Rust | https://github.com/hiero-ledger/hiero-sdk-rust | +| hiero-sdk-cpp | C++ | https://github.com/hiero-ledger/hiero-sdk-cpp | +| hiero-sdk-swift | Swift | https://github.com/hiero-ledger/hiero-sdk-swift | + +A Technology Compatibility Kit (TCK) ensures consistent behavior across SDK implementations: https://github.com/hiero-ledger/hiero-sdk-tck + +## Developer Tools + +| Tool | Purpose | Repository | +|------|---------|------------| +| **hiero-cli** | Command-line tools for developers | https://github.com/hiero-ledger/hiero-cli | +| **solo** | CLI for deploying and managing standalone test networks (preferred over hiero-local-node) | https://github.com/hiero-ledger/solo | +| **hiero-solo-action** | GitHub Action for setting up a Hiero network in CI/CD | https://github.com/hiero-ledger/hiero-solo-action | +| **hiero-local-node** | Local dev network (deprecated — use solo instead) | https://github.com/hiero-ledger/hiero-local-node | +| **hiero-mirror-node-explorer** | Mirror Node Explorer UI | https://github.com/hiero-ledger/hiero-mirror-node-explorer | +| **hiero-enterprise-java** | Java modules for enterprise apps (Spring Boot, MicroProfile) | https://github.com/hiero-ledger/hiero-enterprise-java | + +## Identity / Decentralized Identity (DID) + +Hiero has a growing identity workstream with dedicated SDKs and an identity platform: + +- **hiero-did-sdk-js** — TypeScript/JavaScript SDK for decentralized identity +- **hiero-did-sdk-python** — Python SDK for decentralized identity +- **heka-identity-platform** — Identity platform solution +- **identity-collaboration-hub** — Central repo for identity architecture docs and standards + +## Governance + +### Technical Steering Committee (TSC) + +The TSC is the primary governance body, responsible for technical decisions, HIP approvals, and project oversight. + +**Current members (9):** + +| Name | Organisation / Role | +|------|---------------------| +| Hendrik Ebbers (Chair) | Open Elements / Hashgraph — Director of Open Source | +| Richard Bair | Hashgraph — VP Engineering | +| Dr. Leemon Baird (permanent) | Hashgraph — Co-founder & Chief Scientist, inventor of the hashgraph algorithm | +| Stoyan Panayotov | LimeChain — Software Architect | +| Alexander Popowycz | Hedera — CIO | +| Michael Kantor | Hashgraph Online — President | +| Milan Wiercx van Rhijn | The HBAR Foundry — End User Representative | +| Brandon Davenport | Hgraph — Director of Communications | +| Georgi Lazarov | LimeChain — Technical Lead | + +**How the TSC operates:** +- Weekly meetings, Tuesdays 10:00 AM ET +- Quorum: 6 members required for votes +- Votes recorded per member (yes/no/abstain), asynchronous voting when no quorum +- Meeting minutes: https://github.com/hiero-ledger/tsc/tree/main/minutes (pre-2025), governance wiki (2026+) +- TSC mailing list via groups.io +- Elections for Contributor Seats and End-User Seats +- Calendar: https://zoom-lfx.platform.linuxfoundation.org/meetings/hiero + +### Governance Repository + +Central hub for governance documentation, managed via Clowarden.io: +https://github.com/hiero-ledger/governance + +Contains election procedures, role definitions, rules and guidelines, and PR templates for governance actions (new repos, new teams, membership changes, vote-required changes). + +## Community + +### Regular Meetings + +All meetings are public and accessible via the LFX Calendar. + +| Meeting | Frequency | +|---------|-----------| +| TSC Meetings | Weekly | +| Community Calls | Monthly | +| Python SDK Working Group | Monthly | +| Documentation Working Group | Monthly | +| Solo / Solo Action | Biweekly | +| SDK Cross-Implementation | Monthly | +| Website & Marketing | Monthly | +| Maintainers Coordination | Monthly | +| Identity Working Group | Monthly | +| Mirror Node Working Group | Monthly | + +### Ecosystem Partners + +HashPack (leading wallet), Hgraph (infrastructure provider), HBAR Foundry (developer community), SentX.io, ioBuilders, Calaxy, Diamond Standard, Hedera + +### Community Communication + +- Discord: via lfdecentralizedtrust.org +- GitHub Discussions: https://github.com/orgs/hiero-ledger/discussions +- Mailing lists via groups.io + +## Open Elements' Role in Hiero + +Hendrik Ebbers, founder of Open Elements and Director of Open Source at Hashgraph, chairs the Hiero TSC. He is also Vice Chair of the LFDT Technical Advisory Board and a member of AAIF working groups at the Linux Foundation. See the `open-elements-info` skill for full details on Hendrik's roles. + +**Code contributions donated to Hiero:** +- **hiero-enterprise-java** — Java APIs for integrating Hiero networks into enterprise frameworks like Spring Boot and MicroProfile. Developed by Open Elements and donated to the Hiero Ledger organization (March 2026). +- **hiero-solo-action** — GitHub Action for setting up a Hiero network in CI/CD pipelines. Developed by Open Elements and donated to Hiero. + +Beyond these donated projects, several Open Elements team members are active committers or maintainers on other Hiero repositories. + +## Key Links + +| Resource | URL | +|----------|-----| +| Hiero Website | https://hiero.org | +| Hiero Blog | https://hiero.org/blog/ | +| GitHub Organization | https://github.com/hiero-ledger/ | +| Governance Wiki | https://github.com/hiero-ledger/governance/wiki | +| TSC Repo | https://github.com/hiero-ledger/tsc | +| HIPs | https://github.com/hiero-ledger/hiero-improvement-proposals | +| LFDT Website | https://www.lfdecentralizedtrust.org | +| Meeting Calendar | https://zoom-lfx.platform.linuxfoundation.org/meetings/hiero | diff --git a/.claude/skills/implement-design/SKILL.md b/.claude/skills/implement-design/SKILL.md new file mode 100644 index 00000000..edfa5a92 --- /dev/null +++ b/.claude/skills/implement-design/SKILL.md @@ -0,0 +1,248 @@ +--- +name: implement-design +description: Translates Figma designs into production-ready code with 1:1 visual fidelity. Use when implementing UI from Figma files, when user mentions "implement design", "generate code", "implement component", "build Figma design", provides Figma URLs, or asks to build components matching Figma specs. Requires Figma MCP server connection. +metadata: + mcp-server: figma + source: https://github.com/figma/mcp-server-guide + author: Figma + modifications: None +--- + +# Implement Design + +## Overview + +This skill provides a structured workflow for translating Figma designs into production-ready code with pixel-perfect accuracy. It ensures consistent integration with the Figma MCP server, proper use of design tokens, and 1:1 visual parity with designs. + +## Prerequisites + +- Figma MCP server must be connected and accessible + - Before proceeding, verify the Figma MCP server is connected by checking if Figma MCP tools (e.g., `get_design_context`) are available. + - If the tools are not available, the Figma MCP server may not be enabled. Guide the user to enable the Figma MCP server that is included with the plugin. They may need to restart their MCP client afterward. +- User must provide a Figma URL in the format: `https://figma.com/design/:fileKey/:fileName?node-id=1-2` + - `:fileKey` is the file key + - `1-2` is the node ID (the specific component or frame to implement) +- Project should have an established design system or component library (preferred) + +## Required Workflow + +**Follow these steps in order. Do not skip steps.** + +### Step 1: Get Node ID + +#### Option A: Parse from Figma URL + +When the user provides a Figma URL, extract the file key and node ID to pass as arguments to MCP tools. + +**URL format:** `https://figma.com/design/:fileKey/:fileName?node-id=1-2` + +**Extract:** + +- **File key:** `:fileKey` (the segment after `/design/`) +- **Node ID:** `1-2` (the value of the `node-id` query parameter) + +**Example:** + +- URL: `https://figma.com/design/kL9xQn2VwM8pYrTb4ZcHjF/DesignSystem?node-id=42-15` +- File key: `kL9xQn2VwM8pYrTb4ZcHjF` +- Node ID: `42-15` + +### Step 2: Fetch Design Context + +Run `get_design_context` with the extracted file key and node ID. + +``` +get_design_context(fileKey=":fileKey", nodeId="1-2") +``` + +This provides the structured data including: + +- Layout properties (Auto Layout, constraints, sizing) +- Typography specifications +- Color values and design tokens +- Component structure and variants +- Spacing and padding values + +**If the response is too large or truncated:** + +1. Run `get_metadata(fileKey=":fileKey", nodeId="1-2")` to get the high-level node map +2. Identify the specific child nodes needed from the metadata +3. Fetch individual child nodes with `get_design_context(fileKey=":fileKey", nodeId=":childNodeId")` + +### Step 3: Capture Visual Reference + +Run `get_screenshot` with the same file key and node ID for a visual reference. + +``` +get_screenshot(fileKey=":fileKey", nodeId="1-2") +``` + +This screenshot serves as the source of truth for visual validation. Keep it accessible throughout implementation. + +### Step 4: Download Required Assets + +Download any assets (images, icons, SVGs) returned by the Figma MCP server. + +**IMPORTANT:** Follow these asset rules: + +- If the Figma MCP server returns a `localhost` source for an image or SVG, use that source directly +- DO NOT import or add new icon packages - all assets should come from the Figma payload +- DO NOT use or create placeholders if a `localhost` source is provided +- Assets are served through the Figma MCP server's built-in assets endpoint + +### Step 5: Translate to Project Conventions + +Translate the Figma output into this project's framework, styles, and conventions. + +**Key principles:** + +- Treat the Figma MCP output (typically React + Tailwind) as a representation of design and behavior, not as final code style +- Replace Tailwind utility classes with the project's preferred utilities or design system tokens +- Reuse existing components (buttons, inputs, typography, icon wrappers) instead of duplicating functionality +- Use the project's color system, typography scale, and spacing tokens consistently +- Respect existing routing, state management, and data-fetch patterns + +### Step 6: Achieve 1:1 Visual Parity + +Strive for pixel-perfect visual parity with the Figma design. + +**Guidelines:** + +- Prioritize Figma fidelity to match designs exactly +- Avoid hardcoded values - use design tokens from Figma where available +- When conflicts arise between design system tokens and Figma specs, prefer design system tokens but adjust spacing or sizes minimally to match visuals +- Follow WCAG requirements for accessibility +- Add component documentation as needed + +### Step 7: Validate Against Figma + +Before marking complete, validate the final UI against the Figma screenshot. + +**Validation checklist:** + +- [ ] Layout matches (spacing, alignment, sizing) +- [ ] Typography matches (font, size, weight, line height) +- [ ] Colors match exactly +- [ ] Interactive states work as designed (hover, active, disabled) +- [ ] Responsive behavior follows Figma constraints +- [ ] Assets render correctly +- [ ] Accessibility standards met + +## Implementation Rules + +### Component Organization + +- Place UI components in the project's designated design system directory +- Follow the project's component naming conventions +- Avoid inline styles unless truly necessary for dynamic values + +### Design System Integration + +- ALWAYS use components from the project's design system when possible +- Map Figma design tokens to project design tokens +- When a matching component exists, extend it rather than creating a new one +- Document any new components added to the design system + +### Code Quality + +- Avoid hardcoded values - extract to constants or design tokens +- Keep components composable and reusable +- Add TypeScript types for component props +- Include JSDoc comments for exported components + +## Examples + +### Example 1: Implementing a Button Component + +User says: "Implement this Figma button component: https://figma.com/design/kL9xQn2VwM8pYrTb4ZcHjF/DesignSystem?node-id=42-15" + +**Actions:** + +1. Parse URL to extract fileKey=`kL9xQn2VwM8pYrTb4ZcHjF` and nodeId=`42-15` +2. Run `get_design_context(fileKey="kL9xQn2VwM8pYrTb4ZcHjF", nodeId="42-15")` +3. Run `get_screenshot(fileKey="kL9xQn2VwM8pYrTb4ZcHjF", nodeId="42-15")` for visual reference +4. Download any button icons from the assets endpoint +5. Check if project has existing button component +6. If yes, extend it with new variant; if no, create new component using project conventions +7. Map Figma colors to project design tokens (e.g., `primary-500`, `primary-hover`) +8. Validate against screenshot for padding, border radius, typography + +**Result:** Button component matching Figma design, integrated with project design system. + +### Example 2: Building a Dashboard Layout + +User says: "Build this dashboard: https://figma.com/design/pR8mNv5KqXzGwY2JtCfL4D/Dashboard?node-id=10-5" + +**Actions:** + +1. Parse URL to extract fileKey=`pR8mNv5KqXzGwY2JtCfL4D` and nodeId=`10-5` +2. Run `get_metadata(fileKey="pR8mNv5KqXzGwY2JtCfL4D", nodeId="10-5")` to understand the page structure +3. Identify main sections from metadata (header, sidebar, content area, cards) and their child node IDs +4. Run `get_design_context(fileKey="pR8mNv5KqXzGwY2JtCfL4D", nodeId=":childNodeId")` for each major section +5. Run `get_screenshot(fileKey="pR8mNv5KqXzGwY2JtCfL4D", nodeId="10-5")` for the full page +6. Download all assets (logos, icons, charts) +7. Build layout using project's layout primitives +8. Implement each section using existing components where possible +9. Validate responsive behavior against Figma constraints + +**Result:** Complete dashboard matching Figma design with responsive layout. + +## Best Practices + +### Always Start with Context + +Never implement based on assumptions. Always fetch `get_design_context` and `get_screenshot` first. + +### Incremental Validation + +Validate frequently during implementation, not just at the end. This catches issues early. + +### Document Deviations + +If you must deviate from the Figma design (e.g., for accessibility or technical constraints), document why in code comments. + +### Reuse Over Recreation + +Always check for existing components before creating new ones. Consistency across the codebase is more important than exact Figma replication. + +### Design System First + +When in doubt, prefer the project's design system patterns over literal Figma translation. + +## Common Issues and Solutions + +### Issue: Figma output is truncated + +**Cause:** The design is too complex or has too many nested layers to return in a single response. +**Solution:** Use `get_metadata` to get the node structure, then fetch specific nodes individually with `get_design_context`. + +### Issue: Design doesn't match after implementation + +**Cause:** Visual discrepancies between the implemented code and the original Figma design. +**Solution:** Compare side-by-side with the screenshot from Step 3. Check spacing, colors, and typography values in the design context data. + +### Issue: Assets not loading + +**Cause:** The Figma MCP server's assets endpoint is not accessible or the URLs are being modified. +**Solution:** Verify the Figma MCP server's assets endpoint is accessible. The server serves assets at `localhost` URLs. Use these directly without modification. + +### Issue: Design token values differ from Figma + +**Cause:** The project's design system tokens have different values than those specified in the Figma design. +**Solution:** When project tokens differ from Figma values, prefer project tokens for consistency but adjust spacing/sizing to maintain visual fidelity. + +## Understanding Design Implementation + +The Figma implementation workflow establishes a reliable process for translating designs to code: + +**For designers:** Confidence that implementations will match their designs with pixel-perfect accuracy. +**For developers:** A structured approach that eliminates guesswork and reduces back-and-forth revisions. +**For teams:** Consistent, high-quality implementations that maintain design system integrity. + +By following this workflow, you ensure that every Figma design is implemented with the same level of care and attention to detail. + +## Additional Resources + +- [Figma MCP Server Documentation](https://developers.figma.com/docs/figma-mcp-server/) +- [Figma MCP Server Tools and Prompts](https://developers.figma.com/docs/figma-mcp-server/tools-and-prompts/) +- [Figma Variables and Design Tokens](https://help.figma.com/hc/en-us/articles/15339657135383-Guide-to-variables-in-Figma) diff --git a/.claude/skills/java-api-design/SKILL.md b/.claude/skills/java-api-design/SKILL.md new file mode 100644 index 00000000..c0cf57e1 --- /dev/null +++ b/.claude/skills/java-api-design/SKILL.md @@ -0,0 +1,224 @@ +--- +name: api-design +license: Apache-2.0 +metadata: + source: https://github.com/open-elements/claude-base + author: Open Elements +description: Design and review public Java APIs with a focus on hiding implementations, using the right type constructs (interfaces, records, enums, annotations instead of classes), applying design patterns (Factory, SPI, Facade, Builder, Strategy), modularization, and long-term API stability. Use this skill whenever the user asks about designing a public API, reviewing an API for quality, splitting API from implementation, creating an SPI, choosing between interfaces and classes, or structuring a Java library for external consumers. Also trigger when the user mentions API surface, breaking changes, API evolution, or module boundaries. +--- + +# API Design + +Design public Java APIs that are clean, stable, and implementation-hiding. This skill guides the creation and review of APIs that use the right type constructs, apply proven design patterns, and are structured to avoid breaking changes over time. + +The core philosophy: a public API is a contract with your users. Every public type and method is a commitment that is easy to add but painful to remove. The goal is to expose the minimum surface needed, hide all implementation details, and choose constructs that naturally support evolution. + +## Instructions + +### 1. Understand the context + +Determine what the user needs: + +- **Designing a new API** — they are creating a library, module, or component and need guidance on structure, types, and patterns. +- **Reviewing an existing API** — they want feedback on an existing API's design quality. +- **Refactoring toward a better API** — they have implementation-leaking code and want to improve it. +- **Choosing between constructs** — they need advice on whether to use an interface, record, enum, annotation, or class. + +Read the relevant code before giving advice. Understand the domain, the intended consumers, and the existing codebase conventions. + +### 2. Apply the type selection rules + +Public APIs should be built from interfaces, records, enums, and annotations. Classes are reserved for special cases. + +**Interfaces** are the primary API contract type. They decouple consumers from implementations, support multiple implementations, and evolve safely with default methods. + +- Keep interfaces small and focused (Interface Segregation Principle). +- Name with nouns for things (`UserRepository`, `Connection`), `-able` for capabilities (`Comparable`, `Closeable`), `-er` for agents (`Converter`, `Validator`). +- Do not use the `I` prefix (`IUserService`) or `Impl` suffix (`UserServiceImpl`). Name implementations by their distinguishing characteristic: `JpaUserRepository`, `InMemoryUserRepository`, `CachingUserRepository`. +- Use static factory methods on interfaces to hide implementation classes entirely. +- Use sealed interfaces (Java 17+) when the set of subtypes is known and finite, enabling exhaustive pattern matching. + +**Records** are the right choice for immutable data carriers: DTOs, value objects, API method parameters and return types, configuration objects, results, events. + +- Records guarantee immutability, provide `equals`/`hashCode`/`toString`, and clearly communicate their contract. +- Always defensive-copy mutable components in the compact constructor: `members = List.copyOf(members)`. +- Records work well as permitted subtypes of sealed interfaces for algebraic data types. + +**Enums** represent fixed sets of constants: statuses, modes, strategies, categories. + +- Enums are full classes — they can have fields, methods, and implement interfaces. +- Use enum-specific method implementations for strategy-per-constant patterns. +- Share vocabulary across APIs with top-level enums (like `java.math.RoundingMode`). + +**Annotations** provide metadata, constraints, and documentation. + +- Use for markers (`@Immutable`, `@ThreadSafe`), configuration (`@Cacheable`), constraints (`@NonNull`), and lifecycle (`@Deprecated`). +- Prefer `RUNTIME` retention for API annotations. +- Provide sensible defaults for annotation attributes. + +**Classes** should only appear in public APIs for: + +- **Exceptions** — must extend `Exception` or `RuntimeException`. Keep hierarchies shallow (1-2 levels). Include contextual data (error codes, IDs) as fields, not just in the message string. Provide constructors accepting both message and cause. +- **Abstract skeletal implementations** — optional implementation aids alongside interfaces (like `AbstractList`). These supplement the interface, not replace it. +- **Builders** — for constructing complex immutable objects with many optional parameters. + +### 3. Ensure consistency and progressive disclosure + +Good APIs are consistent and discoverable (Jonathan Giles, JLBP-1 and JLBP-12): + +**Consistency** — Apply uniform patterns across the entire API. If one factory uses `of()`, all similar factories should use `of()`. If one method provides a varargs overload, replicate that pattern for similar methods. Choose either `getXYZ()` or `xyz()` accessor style and stick with it. Maintain consistent argument ordering across overloaded methods. Establish a limited subset of collection return types and use them uniformly. Consistency lets developers intuit how new API parts work based on prior experience with other parts. + +**Progressive disclosure** — Design intuitive entry points. Expose primary functionality through the main entry point, leaving advanced features for deeper exploration. Minimize friction — a new user should succeed with minimal steps. If a developer cannot intuitively understand how to start using your API, the API has failed regardless of how powerful it is. + +**Fit for purpose** — Target the right abstraction level. Do one thing and do it right. Never require developers to understand implementation details to use basic functionality. For example, users of a collection should store and retrieve items without knowing about reallocation thresholds, load factors, or hash collision policies. + +### 4. Use generics effectively + +Generics are a core tool for type-safe, flexible APIs. These rules come from Joshua Bloch's Effective Java and the design of JDK APIs like Stream, Optional, and Collections. + +**Apply PECS (Producer Extends, Consumer Super)** — The foundational rule for wildcard bounds. If a parameter supplies values of type `T` to your method (producer), use `? extends T`. If it accepts values from your method (consumer), use `? super T`. If it does both, use plain `T`. Example: `Collections.copy(List<? super T> dest, List<? extends T> src)`. + +**Use wildcards in parameters, avoid them in return types** — Wildcards in parameters increase flexibility for callers. Wildcards in return types force callers to deal with wildcard types, reducing usability. Always return concrete parameterized types. + +**Never use raw types** — Raw types (`List` instead of `List<String>`) bypass type safety entirely. Use `List<?>` when the element type is unknown. + +**Design for type erasure** — Do not overload methods that differ only by generic type arguments (both erase to the same signature). Use distinct method names instead. Do not depend on runtime generic type information. Use `Supplier<T>` or `Class<T>` tokens when runtime type info is needed (not `new T()`). + +**Use recursive type bounds for self-referential APIs** — The pattern `<T extends Base<T>>` enables type-safe method chaining in builders and comparison in `Comparable`. Example: `<T extends Comparable<? super T>> T max(List<? extends T> list)`. + +**Use bounded type parameters for compile-time safety** — `<T extends Closeable>` guarantees the caller passes a closeable type. Multiple bounds are possible: `<T extends Comparable<T> & Serializable>`. + +**Follow naming conventions** — `T` for general type, `E` for element, `K`/`V` for key/value, `R` for result, `S`/`U` for additional types, `A` for accumulator. Do not shadow class-level type parameters in methods. + +**Single-use rule** — If a type parameter appears only once in a method, replace it with a wildcard: `<E> void swap(List<E> list, ...)` simplifies to `void swap(List<?> list, ...)`. + +### 5. Apply the design patterns + +Choose patterns based on what the API needs to accomplish: + +**Factory pattern** — Use when consumers need instances but should not see implementation classes. Replace public constructors with static factory methods (`of()`, `from()`, `create()`, `parse()`). Factories enable caching, subtype selection, and meaningful names. Place factory methods on the interface itself or on a companion utility class. + +**Service Provider Interface (SPI)** — Use when third parties should be able to plug in implementations. Define a minimal SPI interface in a separate `spi` package. Use `java.util.ServiceLoader` (and JPMS `provides/uses`) for runtime discovery. The key insight: APIs are called by users and implemented by library authors; SPIs are implemented by third parties and called by the library. Adding methods to an SPI is dangerous (breaks providers); adding methods to an API is safe. + +**Facade pattern** — Use when a subsystem is complex and consumers need a simplified entry point. The facade orchestrates internal components, enforces correct usage order, and reduces the learning curve. Keep subsystem classes package-private or in internal packages. + +**Builder pattern** — Use when an object has many optional parameters, requires cross-parameter validation, or must be immutable. Required parameters go in the builder's constructor. Use fluent method names without `set` prefix (`timeout()` not `setTimeout()`). Validate in `build()`, not in individual setters. + +**Strategy pattern** — Use when behavior should be pluggable and interchangeable. Define strategies as `@FunctionalInterface` to enable lambda usage. Provide built-in strategies as factory methods in a companion class. Prefer standard `java.util.function` interfaces before creating custom ones. + +**Options pattern** — An alternative to the Builder pattern for parameter telescoping (Jonathan Giles, JLBP-9). Consolidate optional parameters into a dedicated options container with fluent setters, reducing the API to `foo()` and `foo(FooOptions options)`. This simulates named parameters and avoids overload explosion. Required parameters go in the options constructor or as top-level method parameters. + +### 6. Structure for separation and modularization + +**Package structure** — Separate API from implementation: + +- `com.example.mylib.api` — public interfaces, value types, exceptions +- `com.example.mylib.spi` — service provider interfaces +- `com.example.mylib.model` — public data types (records) +- `com.example.mylib.internal` — implementation details, not for external use + +**JPMS** — Export only API packages. Non-exported packages are inaccessible at compile time and runtime: + +```java +module com.example.mylib { + exports com.example.mylib.api; + exports com.example.mylib.model; + // com.example.mylib.internal is NOT exported + + provides com.example.mylib.spi.StorageProvider + with com.example.mylib.internal.DefaultStorageProvider; +} +``` + +Use `opens` sparingly (only for frameworks needing reflection). Avoid `open module` (ok for modules that are only used for testing). Prefer qualified exports (`exports ... to ...`) when only specific modules need access. + +**Multi-module builds** — For libraries, split into API and implementation modules (like SLF4J does with `slf4j-api` + `logback-classic`). The API module has minimal dependencies. Consumers depend on API at compile scope, implementation at runtime. In Gradle, use `implementation` by default and `api` only when a type appears in public signatures. + +**Preventing API leakage** — Never let internal or third-party types appear in public method signatures: + +- Return interfaces, not implementation classes (`List<User>`, not `ArrayList<User>`). +- Accept the most general type as parameters (`Collection<? extends T>`, `Iterable<T>`). +- Wrap third-party exceptions in API-specific exceptions at module boundaries. +- Use ArchUnit tests to verify no `internal` package types leak into public signatures. +- Use japicmp or Revapi in CI to detect unintended API changes. + +### 7. Apply defensive coding practices + +These practices from Jonathan Giles and the Hiero SDK guide ensure APIs are robust and safe: + +**Fail fast at API boundaries** — Use `Objects.requireNonNull()` with descriptive messages at every public method entry point. Validate constraints (min, max, pattern) in constructors and setters. Catch invalid data early rather than letting it propagate. + +**Prefer primitives over wrapper types** — Use `int`, `long`, `double`, `boolean` in API signatures. Use wrapper types only when nullability is required. Boxing introduces null pointer risk, identity comparison bugs (`==` compares references), and performance overhead. + +**Use `final` deliberately** — Mark all method parameters `final` to signal intent. Mark classes `final` by default unless designed for inheritance. Remember: removing `final` later is not a breaking change, but adding it is. Protected methods are as much part of the public API as public methods — use `protected` only for intentional extension points. + +**Avoid `var` in library code** — Use explicit types for clarity. `Transaction transaction = createTransaction()` is clearer than `var transaction = createTransaction()` for library consumers reading your code or API. + +**Avoid Lombok** — Do not use `@Data`, `@Getter`, `@Setter` in library code. Hidden code generation makes debugging difficult, and modern Java (records, sealed classes) provides better, transparent solutions. + +**`toString()` discipline** — Use format `ClassName{field1=value1, field2=value2}`. Never include sensitive data. Keep implementations cheap. Be aware that users will parse `toString()` output — changes can break downstream code. + +**`equals()`/`hashCode()` contract** — If `equals()` is overridden, `hashCode()` must be too. Use `Objects.equals()` and `Objects.hash()`. Do not use mutable fields in hash code. Prefer records for value types — they generate correct implementations automatically. + +**Thread safety** — Prefer immutability over synchronization. Use concurrent collections (`ConcurrentHashMap`, `CopyOnWriteArrayList`) for internal mutable state. Document which classes and methods are thread-safe. Consider `@ThreadSafe` annotations. + +**Exception naming** — Follow `[Domain][Condition]Exception` format: `AccountNotFoundException`, `InsufficientFundsException`. + +**Logging in libraries** — Prefer `System.Logger` (Java 9+) for libraries, especially low-level ones, to avoid forcing a logging framework dependency on consumers. Use parameterized log messages, never string concatenation. Check log level before expensive computations. + +### 8. Design for stability + +Every public API element is a long-term commitment. These practices help avoid breaking changes: + +**Minimize the surface** — "When in doubt, leave it out." Start with everything package-private. Only make types public when there is a concrete need. Make classes `final` by default unless designed for inheritance. + +**Return the right types** — Return interfaces, not concrete classes. Return the most specific useful interface (`List<T>` when ordering matters, `Set<T>` for uniqueness). Never return `null` where an empty collection or `Optional` would work. Always return unmodifiable collections (`List.copyOf()`, `List.of()`). + +**Handle null explicitly** — Adopt non-null-by-default with JSpecify annotations (`@NullMarked` at package level). Mark individual nullable cases with `@Nullable`. Use `Optional` for return types where absence is a normal outcome. Never use `Optional` as a parameter, field, or collection element. + +**Evolve interfaces safely** — Add default methods for backward-compatible evolution. Use sub-interfaces for major additions (`UserRepositoryV2 extends UserRepository`). Use companion utility classes for static operations. Mark experimental APIs with `@API(status = EXPERIMENTAL)` from API Guardian. + +**Version correctly** — Follow Semantic Versioning: MAJOR for breaking changes, MINOR for additions, PATCH for fixes. Deprecate with `@Deprecated(since = "2.3", forRemoval = true)` and document replacements. Remove no earlier than two versions after deprecation. Integrate japicmp or Revapi in CI to catch accidental breaks. + +**Use API status markers** — Communicate stability expectations with annotations like API Guardian's `@API(status = STABLE)`, `@API(status = INTERNAL)`, `@API(status = EXPERIMENTAL)`. + +### 9. Review checklist + +When reviewing an API design (new or existing), check: + +- [ ] Are interfaces used as the primary contract types (not classes)? +- [ ] Are implementation classes hidden (package-private, internal package, or non-exported module)? +- [ ] Are data carriers implemented as records (not mutable POJOs)? +- [ ] Are fixed constant sets implemented as enums? +- [ ] Are classes only used for exceptions, skeletal implementations, or builders? +- [ ] Do factory methods replace public constructors? +- [ ] Is the API/SPI distinction clear (separate packages, minimal SPI surface)? +- [ ] Are collections returned as unmodifiable? +- [ ] Are null semantics explicit (JSpecify annotations, Optional for lookups)? +- [ ] Is the package structure clean (api/spi/model/internal)? +- [ ] Does the module-info.java export only API packages? +- [ ] Are third-party types absent from public method signatures? +- [ ] Are exceptions well-designed (contextual data, shallow hierarchy, cause chaining)? +- [ ] Is the API surface minimal — nothing exposed "just in case"? +- [ ] Do generic method signatures follow PECS (extends for producers, super for consumers)? +- [ ] Are wildcards used in parameters but avoided in return types? +- [ ] Are raw types absent from the entire API? +- [ ] Are type parameter names following conventions (T, E, K, V, R)? +- [ ] Is the API consistent — uniform naming, argument ordering, overload patterns? +- [ ] Are public API methods using `Objects.requireNonNull()` for parameter validation? +- [ ] Are primitive types used instead of wrappers where nullability is not needed? +- [ ] Are classes `final` by default (unless designed for inheritance)? +- [ ] Is `var` avoided in favor of explicit types? +- [ ] Does `toString()` exclude sensitive data and follow a consistent format? +- [ ] Are `equals()`/`hashCode()` correctly implemented (or records used)? +- [ ] Is thread safety documented and implemented where needed? +- [ ] Is the API stable — could it survive two major versions without breaking changes? + +### 10. Present recommendations + +When advising on API design: + +- Explain the reasoning behind each recommendation. A developer who understands *why* interfaces are preferred over classes will make better decisions in edge cases than one following a rule mechanically. +- Show concrete code examples that demonstrate the recommended pattern. +- Reference well-designed JDK APIs as models: `java.time` for immutable value types with factories, `java.util.ServiceLoader` for SPI, `java.util.Collections` for factories returning hidden implementations, JDBC for API/SPI separation, SLF4J for facade + SPI. +- When reviewing existing code, prioritize findings by impact: API leakage and missing encapsulation are more important than naming conventions. diff --git a/.claude/skills/open-elements-brand-guidelines/SKILL.md b/.claude/skills/open-elements-brand-guidelines/SKILL.md new file mode 100644 index 00000000..fd396465 --- /dev/null +++ b/.claude/skills/open-elements-brand-guidelines/SKILL.md @@ -0,0 +1,192 @@ +--- +name: open-elements-brand-guidelines +license: Apache-2.0 +metadata: + source: https://github.com/open-elements/claude-base + author: Open Elements +description: Applies the official brand colors and typography of Open Elements to any sort of artifact that may benefit from having the look-and-feel of Open Elements. Use it when brand colors or style guidelines, visual formatting, or company design standards apply. +--- + +# Open Elements Brand Styling + +## Overview + +To access the official brand identity and style resources of Open Elements, use this skill. + +## Brand Guidelines + +### Colors + +**Main Colors:** + +- Dark: `#020144` - Can be used as backgrounds in header footer or for example as headline text color. + In diagrams / technical illustrations often used for note texts or arrows. +- Black: `#000000` - Normal text color on bright backgrounds +- White: `#ffffff` - Normal background color +- Mid Gray: `#b0aea5` - Secondary elements +- Light Gray: `#e8e6dc` - Subtle backgrounds +- Primary Green: `#5CBA9E` - Can be used in texts, for highlighting or as background color for example in diagrams +- Primary Red: `#E63277` - Can be used in texts, for highlighting or as background color for example in diagrams + +**Accent Colors:** + +- Blue: `#5DB9F5` - Primary accent +- Yellow: `#F1E34B` - Secondary accent + +**Light variants:** +(green) #BEE3D8, (red) #F5ADC9, (blue) #BEE3FB, (yellow) #F9F4B7 + +**Lighter variants:** +(green) #DEF1EC, (red) #FAD6E4, (blue) #DFF1FD, (yellow) #FCF9DB + +**Dark variants:** +(green) #3E9279, (red) #BB1756, (blue) #2496EF, (yellow) #DCCB12 + +### CSS Custom Properties + +When using the brand colors in web projects, define them as CSS custom properties: + +```css +:root { + --oe-dark: #020144; + --oe-black: #000000; + --oe-white: #ffffff; + --oe-gray-mid: #b0aea5; + --oe-gray-light: #e8e6dc; + --oe-green: #5CBA9E; + --oe-green-light: #BEE3D8; + --oe-green-lighter: #DEF1EC; + --oe-green-dark: #3E9279; + --oe-red: #E63277; + --oe-red-light: #F5ADC9; + --oe-red-lighter: #FAD6E4; + --oe-red-dark: #BB1756; + --oe-blue: #5DB9F5; + --oe-blue-light: #BEE3FB; + --oe-blue-lighter: #DFF1FD; + --oe-blue-dark: #2496EF; + --oe-yellow: #F1E34B; + --oe-yellow-light: #F9F4B7; + --oe-yellow-lighter: #FCF9DB; + --oe-yellow-dark: #DCCB12; +} +``` + +### Illustration Colors + +The following colors are derived from analyzing the full Open Elements SVG illustration library (~210 illustrations). +They represent the actual color palette used in the corporate illustrations and should be used when creating diagrams, charts, graphs, or any visual graphics to match the Open Elements illustration style. + +**Primary illustration fills (most frequently used across all illustrations):** + +| Color | Hex | Usage | +|-------|-----|-------| +| Green (primary fill) | `#5CBA9E` | The dominant fill color, used in ~60% of all illustrations | +| Light mint | `#BEE3D8` | Large area fills, backgrounds of highlighted sections | +| Lighter mint | `#DEF1EC` | Subtle background fills, secondary areas | +| Medium mint | `#9DD6C5` | Intermediate green tone, frequently used alongside primary green | +| Sky blue | `#5DB9F5` | Secondary fill color for contrast elements | +| Light blue | `#BEE3FB` | Large area fills in blue-themed sections | +| Lighter blue | `#DFF1FD` | Subtle blue backgrounds | +| Medium blue | `#9ED5F9` | Intermediate blue tone, used for highlights and accents | + +**Secondary illustration fills (used for emphasis or thematic elements):** + +| Color | Hex | Usage | +|-------|-----|-------| +| Yellow | `#F1E34B` | Accent for stars, light bulbs, idea elements | +| Pale yellow | `#F9F4B7` | Subtle yellow backgrounds | +| Cream | `#FCF9DB` | Very subtle warm backgrounds | +| Hot pink | `#E63277` | Alert or energy accents | +| Dark pink | `#BB1756` | Danger, warning, or evil-themed elements | +| Light pink | `#F084AD` | Softer pink accents | +| Pale pink | `#FAD6E4` | Subtle pink backgrounds | +| Bright cyan | `#0FBBFB` | Used in newer illustration series as sky blue accent | +| Dark blue | `#15649F` | Technology, blockchain, and data-themed illustrations | +| Bright blue | `#2496EF` | Active/highlighted blue elements | + +**Illustration outline and neutral colors:** + +| Color | Hex | Usage | +|-------|-----|-------| +| Black | `#000000` | Primary outline/stroke color (~80% of illustrations) | +| Dark navy | `#020144` | Alternative outline/stroke color (~30% of illustrations) | +| Light gray | `#DADADA` | Neutral fills for inactive or background elements | +| White | `#FFFFFF` | Interior fills for contrast, eyes, highlights | + +**Dark accent tones (used sparingly for depth):** + +| Color | Hex | Usage | +|-------|-----|-------| +| Dark green | `#3E9279` | Shadows or dark-side fills on green elements | +| Very dark green | `#296251` | Deep shadows, rare accent | +| Dark olive | `#93870C` | Dark variant for yellow/gold elements | +| Teal | `#27BD9D` | Alternative green, slightly brighter than primary | + +### Illustration Style Guide + +The following style parameters are derived from the Open Elements SVG illustration library and should be applied when creating diagrams, charts, graphs, or any visual graphics. + +**Stroke / Outlines:** + +- Stroke width: ~1% of the canvas width (e.g. `16.67px` on a `1668px` canvas, `25px` on a `2500px` canvas, `6px` on a `600px` canvas) +- Stroke color: `#000000` (black) or `#020144` (dark navy) — use one consistently within a single graphic +- Stroke line cap: `round` +- Stroke line join: `round` +- Stroke miter limit: `1.5` + +**Fill Style:** + +- Use flat fills only — no gradients, no textures, no patterns +- No opacity/transparency effects (all fills are fully opaque) +- Use `fill-rule: evenodd` + +**Color Usage Hierarchy:** + +1. Use `#5CBA9E` (green) as the dominant fill color +2. Use lighter green tones (`#BEE3D8`, `#DEF1EC`, `#9DD6C5`) for secondary areas +3. Use blue tones (`#5DB9F5`, `#BEE3FB`, `#DFF1FD`, `#9ED5F9`) for contrasting elements +4. Use yellow (`#F1E34B`) and pink (`#E63277`, `#BB1756`) sparingly as accents +5. Use `#DADADA` for neutral/inactive elements +6. Keep outlines in `#000000` or `#020144` + +**General Principles:** + +- Illustrations are clean, flat-design vector graphics with bold rounded outlines +- No drop shadows, no glow effects, no 3D effects +- Rounded stroke caps and joins give a friendly, approachable look +- White space is used generously inside illustrations +- Color palette is intentionally limited per illustration (typically 3-5 colors plus black/white) + +### Typography + +- **Headings**: Montserrat (or Lato) +- **Body Text**: Lato +- **Source Code**: Source_Code_Pro +- In diagrams notes can be written in Permanent_Marker +- **Note**: Fonts should be pre-installed in your environment for best results. + All fonts are available in the [Google Fonts](https://fonts.google.com/) library. + +### Logo + +The open elements logo is available in the folder of this skill. +It is provided in PNG and SVG format. +All PNGs have a transparent background. +If possible, use the SVG version. + +Here is an overview of the SVG logo files. +All PNG files are available in the same folder and have the same name as the SVG files. +- **open-elements-logo/logo-landscape-dark-background.svg**: Landscape logo with dark background +- **open-elements-logo/logo-landscape-light-background.svg**: Landscape logo with light background +- **open-elements-logo/logo-portrait-dark-background.svg**: Portrait logo with dark background. This is preferred for square logo placements. +- **open-elements-logo/logo-portrait-light-background.svg**: Portrait logo with light background. This is preferred for square logo placements. + +On a dark backround only the *-dark-background.* logos must be used. +On a light background only the *-light-background.* logos must be used. + +Next to that the graphic part of the logo without the "Open Elements" text is available (for example for use as fav-icon) +- **open-elements-logo/logo-icon.png**: 1024x1024 PNG file +- **open-elements-logo/logo-icon@0,5x.png**: 0,5x PNG file +- **open-elements-logo/logo-icon@0,25x.png**: 0,25x PNG file +- **open-elements-logo/logo-icon@0,33x.png**: 0,33x PNG file +- **open-elements-logo/logo-icon@0,75x.png**: 0,75x PNG file diff --git a/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-icon.png b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-icon.png new file mode 100644 index 00000000..c74adeb5 Binary files /dev/null and b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-icon.png differ diff --git a/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-icon@0,25x.png b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-icon@0,25x.png new file mode 100644 index 00000000..7589a767 Binary files /dev/null and b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-icon@0,25x.png differ diff --git a/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-icon@0,33x.png b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-icon@0,33x.png new file mode 100644 index 00000000..f408182f Binary files /dev/null and b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-icon@0,33x.png differ diff --git a/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-icon@0,5x.png b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-icon@0,5x.png new file mode 100644 index 00000000..a5e57576 Binary files /dev/null and b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-icon@0,5x.png differ diff --git a/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-icon@0,75x.png b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-icon@0,75x.png new file mode 100644 index 00000000..8f0c5210 Binary files /dev/null and b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-icon@0,75x.png differ diff --git a/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-landscape-dark-background.png b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-landscape-dark-background.png new file mode 100644 index 00000000..96dc802c Binary files /dev/null and b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-landscape-dark-background.png differ diff --git a/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-landscape-dark-background.svg b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-landscape-dark-background.svg new file mode 100644 index 00000000..62dd2ec2 --- /dev/null +++ b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-landscape-dark-background.svg @@ -0,0 +1,57 @@ +<?xml version="1.0" encoding="UTF-8"?> +<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 653.15 85.73"> + <defs> + <style> + .cls-1 { + fill: #fd0177; + } + + .cls-2 { + fill: #01bd9c; + } + + .cls-3 { + fill: #f4e301; + } + + .cls-4 { + fill: #fff; + } + + .cls-5 { + fill: #0fbbfb; + } + </style> + </defs> + <g> + <path class="cls-4" d="m177.37,43c-.16,14.01-8.75,28.03-27.79,28.03s-27.87-13.7-27.87-27.95,9.14-28.57,27.87-28.57,27.95,14.32,27.79,28.49Zm-45.6.23c.23,8.9,5.03,18.43,17.81,18.43s17.57-9.6,17.73-18.5c.16-9.14-4.95-19.35-17.73-19.35s-18.04,10.3-17.81,19.43Z"/> + <path class="cls-4" d="m184.17,85.73V31.62h8.83l.62,5.27c2.94-4.26,8.05-6.12,12.39-6.12,11.77,0,19.59,8.75,19.59,19.97s-7.05,19.97-19.28,19.97c-4.03,0-9.99-1.24-12.7-5.42v20.44h-9.44Zm31.97-34.99c0-5.96-4.03-10.84-10.84-10.84s-10.84,4.88-10.84,10.84,4.41,10.84,10.84,10.84,10.84-4.88,10.84-10.84Z"/> + <path class="cls-4" d="m240.61,54.07c.62,4.72,4.72,8.13,11.38,8.13,3.48,0,8.05-1.32,10.22-3.56l6.04,5.96c-4.03,4.18-10.61,6.19-16.41,6.19-13.16,0-20.98-8.13-20.98-20.36s7.9-19.97,20.28-19.97,20.75,7.9,19.28,23.61h-29.81Zm20.75-7.82c-.62-4.95-4.49-7.43-9.91-7.43-5.11,0-9.29,2.48-10.68,7.43h20.59Z"/> + <path class="cls-4" d="m305.79,69.78v-19.97c0-5.81-3.17-10.22-9.21-10.22s-9.75,4.88-9.75,10.68v19.51h-9.37V31.54h8.44l.62,5.19c3.87-3.79,7.74-5.73,12.54-5.73,8.98,0,16.18,6.74,16.18,18.74v20.05h-9.45Z"/> + <path class="cls-4" d="m387.62,50.66c0-11.46,8.67-19.74,19.43-19.74s20.36,6.58,18.89,21.52h-34.45c.77,8.98,7.66,14.17,15.56,14.17,5.03,0,10.92-2.01,13.78-5.81l2.71,2.17c-3.72,4.88-10.37,7.36-16.49,7.36-10.76,0-19.43-7.51-19.43-19.67Zm34.92-1.55c-.08-9.44-6.27-14.71-15.48-14.71-7.9,0-14.71,5.34-15.56,14.71h31.05Z"/> + <path class="cls-4" d="m378.17,15.59v54.19h-3.79V15.59h3.79Z"/> + <path class="cls-4" d="m489.1,69.78v-22.92c0-7.35-4.95-12.54-12.23-12.54s-12.31,5.42-12.31,12.77v22.68h-3.79v-22.68c0-7.36-5.03-12.7-12.31-12.7s-12.23,5.34-12.23,12.7v22.68h-3.79V31.54h3.56l.08,6.35c2.63-5.03,7.51-7.12,12.46-7.12,5.81,0,11.92,2.63,14.17,9.44,2.32-6.27,8.28-9.44,14.17-9.44,9.37,0,16.03,6.58,16.03,16.1v22.92h-3.79Z"/> + <path class="cls-4" d="m501.41,50.66c0-11.46,8.67-19.74,19.43-19.74s20.36,6.58,18.89,21.52h-34.45c.77,8.98,7.66,14.17,15.56,14.17,5.03,0,10.92-2.01,13.78-5.81l2.71,2.17c-3.72,4.88-10.37,7.36-16.49,7.36-10.76,0-19.43-7.51-19.43-19.67Zm34.92-1.55c-.08-9.44-6.27-14.71-15.48-14.71-7.9,0-14.71,5.34-15.56,14.71h31.05Z"/> + <path class="cls-4" d="m553.27,31.54v6.81c2.94-5.26,8.28-7.43,13.63-7.51,10.22,0,17.26,6.27,17.26,16.88v22.06h-3.79v-21.99c0-8.67-5.34-13.32-13.63-13.24-7.9.08-13.39,6.04-13.39,13.94v21.29h-3.79V31.54h3.72Z"/> + <path class="cls-4" d="m601.19,20v11.54h13.01v3.17h-13.01v23.3c0,5.19,1.08,8.83,7.05,8.83,1.86,0,3.95-.62,5.88-1.55l1.32,3.1c-2.4,1.16-4.8,1.94-7.2,1.94-8.13,0-10.76-4.8-10.76-12.31v-23.3h-8.13v-3.17h8.13v-11.15l3.72-.39Z"/> + <path class="cls-4" d="m649.19,38.51c-3.87-3.41-7.66-4.03-11.92-4.03-5.96-.08-11.69,2.17-11.54,7.04.15,5.11,6.81,6.12,11.61,6.97,6.81,1.16,16.18,2.32,15.79,11.23-.23,8.44-8.98,10.68-15.72,10.68s-13.39-2.56-16.72-7.66l2.79-2.48c3.17,4.57,8.9,6.5,14.01,6.5,4.65,0,11.69-1.24,11.92-7.28.15-5.5-6.19-6.58-12.46-7.59-7.43-1.24-14.79-2.63-14.86-10.3-.08-7.51,7.43-10.76,15.17-10.68,5.57,0,10.45,1.55,14.25,5.11l-2.32,2.48Z"/> + <g> + <polygon class="cls-4" points="327.04 15.41 327.04 19.36 331.14 19.36 343.83 19.36 365.36 19.36 365.36 15.41 327.04 15.41"/> + <polygon class="cls-4" points="331.14 65.55 327.04 65.55 327.04 69.6 365.36 69.6 365.36 65.58 331.14 65.58 331.14 65.55"/> + <polygon class="cls-4" points="331.14 40.37 327.04 40.37 327.04 44.19 345.52 44.19 345.52 44.21 365.36 44.21 365.36 40.41 331.14 40.41 331.14 40.37"/> + </g> + </g> + <g> + <path class="cls-2" d="m41.76,65.25h34.5c2.93-4.28,5.07-9.14,6.24-14.36h-19.09c-3.57,8.43-11.93,14.36-21.65,14.36Z"/> + <path class="cls-2" d="m41.76,18.26c9.72,0,18.08,5.93,21.65,14.36h19.09c-1.17-5.22-3.31-10.08-6.24-14.36h-34.5Z"/> + <path class="cls-2" d="m41.76,65.25c-12.96,0-23.5-10.54-23.5-23.5s10.54-23.5,23.5-23.5h-1.93V.05C17.69,1.06,0,19.38,0,41.76s17.69,40.69,39.82,41.71v-18.21h1.93Z"/> + <path class="cls-1" d="m39.82,0v.05c.64-.03,1.28-.05,1.93-.05h-1.93Z"/> + <path class="cls-1" d="m76.26,18.26h31.08V0H41.76c14.32,0,26.97,7.25,34.5,18.26Z"/> + <path class="cls-2" d="m41.76,18.26h34.5C68.73,7.25,56.08,0,41.76,0c-.65,0-1.29.02-1.93.05v18.21h1.93Z"/> + <path class="cls-5" d="m82.5,50.89h24.84v-18.26h-24.84c.66,2.94,1.02,5.99,1.02,9.13s-.36,6.19-1.02,9.13Z"/> + <path class="cls-2" d="m65.25,41.76c0,3.24-.66,6.32-1.85,9.13h19.09c.66-2.94,1.02-5.99,1.02-9.13s-.36-6.19-1.02-9.13h-19.09c1.19,2.81,1.85,5.89,1.85,9.13Z"/> + <path class="cls-3" d="m39.82,83.52h1.93c-.65,0-1.29-.02-1.93-.05v.05Z"/> + <path class="cls-3" d="m41.76,83.52h65.58v-18.26h-31.08c-7.53,11.02-20.18,18.26-34.5,18.26Z"/> + <path class="cls-2" d="m39.82,65.25v18.21c.64.03,1.28.05,1.93.05,14.32,0,26.97-7.25,34.5-18.26h-36.43Z"/> + </g> +</svg> \ No newline at end of file diff --git a/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-landscape-light-background.png b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-landscape-light-background.png new file mode 100644 index 00000000..509c39ed Binary files /dev/null and b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-landscape-light-background.png differ diff --git a/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-landscape-light-background.svg b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-landscape-light-background.svg new file mode 100644 index 00000000..422bb009 --- /dev/null +++ b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-landscape-light-background.svg @@ -0,0 +1,69 @@ +<?xml version="1.0" encoding="utf-8"?> +<!-- Generator: Adobe Illustrator 24.3.0, SVG Export Plug-In . SVG Version: 6.00 Build 0) --> +<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" + viewBox="0 0 1000 1000" style="enable-background:new 0 0 1000 1000;" xml:space="preserve"> +<style type="text/css"> + .st0{fill:#010149;} + .st1{fill:#01BD9C;} + .st2{fill:#FD0177;} + .st3{fill:#0FBBFB;} + .st4{fill:#F4E301;} + .st5{fill:#FFFFFF;} +</style> +<g> + <g> + <g> + <path class="st0" d="M350.8,500.1c-0.2,14-8.7,28-27.8,28s-27.9-13.7-27.9-27.9c0-14.2,9.1-28.6,27.9-28.6 + C341.7,471.6,350.9,486,350.8,500.1z M305.2,500.4c0.2,8.9,5,18.4,17.8,18.4c12.8,0,17.6-9.6,17.7-18.5c0.2-9.1-5-19.4-17.7-19.4 + C310.2,480.9,305,491.2,305.2,500.4z"/> + <path class="st0" d="M357.6,542.9v-54.1h8.8l0.6,5.3c2.9-4.3,8.1-6.1,12.4-6.1c11.8,0,19.6,8.7,19.6,20c0,11.1-7,20-19.3,20 + c-4,0-10-1.2-12.7-5.4v20.4H357.6z M389.6,507.9c0-6-4-10.8-10.8-10.8s-10.8,4.9-10.8,10.8c0,6,4.4,10.8,10.8,10.8 + S389.6,513.8,389.6,507.9z"/> + <path class="st0" d="M414,511.2c0.6,4.7,4.7,8.1,11.4,8.1c3.5,0,8.1-1.3,10.2-3.6l6,6c-4,4.2-10.6,6.2-16.4,6.2 + c-13.2,0-21-8.1-21-20.4c0-11.6,7.9-20,20.3-20c12.8,0,20.7,7.9,19.3,23.6H414z M434.8,503.4c-0.6-5-4.5-7.4-9.9-7.4 + c-5.1,0-9.3,2.5-10.7,7.4H434.8z"/> + <path class="st0" d="M479.2,526.9v-20c0-5.8-3.2-10.2-9.2-10.2c-5.8,0-9.8,4.9-9.8,10.7v19.5h-9.4v-38.2h8.4l0.6,5.2 + c3.9-3.8,7.7-5.7,12.5-5.7c9,0,16.2,6.7,16.2,18.7v20.1H479.2z"/> + <path class="st0" d="M561,507.8c0-11.5,8.7-19.7,19.4-19.7c10.8,0,20.4,6.6,18.9,21.5h-34.5c0.8,9,7.7,14.2,15.6,14.2 + c5,0,10.9-2,13.8-5.8l2.7,2.2c-3.7,4.9-10.4,7.4-16.5,7.4C569.7,527.5,561,520,561,507.8z M596,506.2 + c-0.1-9.4-6.3-14.7-15.5-14.7c-7.9,0-14.7,5.3-15.6,14.7H596z"/> + <path class="st0" d="M551.6,472.7v54.2h-3.8v-54.2H551.6z"/> + <path class="st0" d="M662.5,526.9V504c0-7.4-5-12.5-12.2-12.5c-7.3,0-12.3,5.4-12.3,12.8v22.7h-3.8v-22.7c0-7.4-5-12.7-12.3-12.7 + c-7.3,0-12.2,5.3-12.2,12.7v22.7h-3.8v-38.2h3.6l0.1,6.3c2.6-5,7.5-7.1,12.5-7.1c5.8,0,11.9,2.6,14.2,9.4 + c2.3-6.3,8.3-9.4,14.2-9.4c9.4,0,16,6.6,16,16.1v22.9H662.5z"/> + <path class="st0" d="M674.8,507.8c0-11.5,8.7-19.7,19.4-19.7c10.8,0,20.4,6.6,18.9,21.5h-34.5c0.8,9,7.7,14.2,15.6,14.2 + c5,0,10.9-2,13.8-5.8l2.7,2.2c-3.7,4.9-10.4,7.4-16.5,7.4C683.5,527.5,674.8,520,674.8,507.8z M709.7,506.2 + c-0.1-9.4-6.3-14.7-15.5-14.7c-7.9,0-14.7,5.3-15.6,14.7H709.7z"/> + <path class="st0" d="M726.7,488.7v6.8c2.9-5.3,8.3-7.4,13.6-7.5c10.2,0,17.3,6.3,17.3,16.9v22.1h-3.8v-22 + c0-8.7-5.3-13.3-13.6-13.2c-7.9,0.1-13.4,6-13.4,13.9v21.3H723v-38.2H726.7z"/> + <path class="st0" d="M774.6,477.1v11.5h13v3.2h-13v23.3c0,5.2,1.1,8.8,7,8.8c1.9,0,3.9-0.6,5.9-1.5l1.3,3.1 + c-2.4,1.2-4.8,1.9-7.2,1.9c-8.1,0-10.8-4.8-10.8-12.3v-23.3h-8.1v-3.2h8.1v-11.1L774.6,477.1z"/> + <path class="st0" d="M822.6,495.6c-3.9-3.4-7.7-4-11.9-4c-6-0.1-11.7,2.2-11.5,7c0.2,5.1,6.8,6.1,11.6,7 + c6.8,1.2,16.2,2.3,15.8,11.2c-0.2,8.4-9,10.7-15.7,10.7c-6.7,0-13.4-2.6-16.7-7.7l2.8-2.5c3.2,4.6,8.9,6.5,14,6.5 + c4.6,0,11.7-1.2,11.9-7.3c0.2-5.5-6.2-6.6-12.5-7.6c-7.4-1.2-14.8-2.6-14.9-10.3c-0.1-7.5,7.4-10.8,15.2-10.7 + c5.6,0,10.5,1.5,14.2,5.1L822.6,495.6z"/> + <g> + <polygon class="st0" points="500.5,472.5 500.5,476.5 504.6,476.5 517.3,476.5 538.8,476.5 538.8,472.5 "/> + <polygon class="st0" points="504.6,522.7 500.5,522.7 500.5,526.7 538.8,526.7 538.8,522.7 504.6,522.7 "/> + <polygon class="st0" points="504.6,497.5 500.5,497.5 500.5,501.3 518.9,501.3 518.9,501.3 538.8,501.3 538.8,497.5 + 504.6,497.5 "/> + </g> + </g> + </g> + <g> + <path class="st1" d="M215.2,522.4h34.5c2.9-4.3,5.1-9.1,6.2-14.4h-19.1C233.3,516.5,224.9,522.4,215.2,522.4z"/> + <path class="st1" d="M215.2,475.4c9.7,0,18.1,5.9,21.6,14.4h19.1c-1.2-5.2-3.3-10.1-6.2-14.4H215.2z"/> + <path class="st1" d="M215.2,522.4c-13,0-23.5-10.5-23.5-23.5c0-13,10.5-23.5,23.5-23.5h-1.9v-18.2c-22.1,1-39.8,19.3-39.8,41.7 + c0,22.4,17.7,40.7,39.8,41.7v-18.2H215.2z"/> + <path class="st2" d="M213.3,457.1L213.3,457.1c0.6,0,1.3,0,1.9,0H213.3z"/> + <path class="st2" d="M249.7,475.4h31.1v-18.3h-65.6C229.5,457.1,242.2,464.4,249.7,475.4z"/> + <path class="st1" d="M215.2,475.4h34.5c-7.5-11-20.2-18.3-34.5-18.3c-0.6,0-1.3,0-1.9,0v18.2H215.2z"/> + <path class="st3" d="M255.9,508h24.8v-18.3h-24.8c0.7,2.9,1,6,1,9.1C256.9,502,256.6,505.1,255.9,508z"/> + <path class="st1" d="M238.7,498.9c0,3.2-0.7,6.3-1.8,9.1h19.1c0.7-2.9,1-6,1-9.1c0-3.1-0.4-6.2-1-9.1h-19.1 + C238,492.6,238.7,495.7,238.7,498.9z"/> + <path class="st4" d="M213.3,540.7h1.9C214.5,540.7,213.9,540.6,213.3,540.7L213.3,540.7z"/> + <path class="st4" d="M215.2,540.7h65.6v-18.3h-31.1C242.2,533.4,229.5,540.7,215.2,540.7z"/> + <path class="st1" d="M213.3,522.4v18.2c0.6,0,1.3,0,1.9,0c14.3,0,27-7.2,34.5-18.3h-34.5H213.3z"/> + </g> +</g> +</svg> diff --git a/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-portrait-dark-background.png b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-portrait-dark-background.png new file mode 100644 index 00000000..6ef24af3 Binary files /dev/null and b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-portrait-dark-background.png differ diff --git a/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-portrait-dark-background.svg b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-portrait-dark-background.svg new file mode 100644 index 00000000..22e50d4d --- /dev/null +++ b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-portrait-dark-background.svg @@ -0,0 +1,25 @@ +<?xml version="1.0" encoding="utf-8"?> +<!-- Generator: Adobe Illustrator 24.3.0, SVG Export Plug-In . SVG Version: 6.00 Build 0) --> +<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" + viewBox="0 0 1000 1000" style="enable-background:new 0 0 1000 1000;" xml:space="preserve"> +<style type="text/css"> + .st0{fill:#010149;} + .st1{fill:#01BD9C;} + .st2{fill:#FD0177;} + .st3{fill:#0FBBFB;} + .st4{fill:#F4E301;} + .st5{fill:#FFFFFF;} +</style> +<g> + <path class="st2" d="M445,334v0.2c2.5-0.1,5.1-0.2,7.7-0.2H445z"/> + <path class="st2" d="M589.8,406.6h123.5V334H452.7C509.6,334,559.9,362.8,589.8,406.6z"/> + <path class="st3" d="M614.6,536.3h98.7v-72.6h-98.7c2.6,11.7,4,23.8,4,36.3S617.2,524.6,614.6,536.3z"/> + <path class="st4" d="M445,666h7.7c-2.6,0-5.1-0.1-7.7-0.2V666z"/> + <path class="st4" d="M452.7,666h260.6v-72.6H589.8C559.9,637.2,509.6,666,452.7,666z"/> + <path class="st1" d="M614.6,463.7c-4.6-20.8-13.2-40.1-24.8-57.1c-29.9-43.8-80.2-72.6-137.1-72.6c-2.6,0-5.1,0.1-7.7,0.2 + c-88,4-158.3,76.8-158.3,165.8c0,88.9,70.3,161.7,158.3,165.8c2.5,0.1,5.1,0.2,7.7,0.2c56.9,0,107.2-28.8,137.1-72.6 + c11.6-17,20.2-36.3,24.8-57.1c2.6-11.7,4-23.8,4-36.3S617.2,475.4,614.6,463.7z M452.7,593.4c-51.5,0-93.4-41.9-93.4-93.4 + c0-51.5,41.9-93.4,93.4-93.4c38.6,0,71.9,23.6,86,57.1c4.7,11.2,7.3,23.4,7.3,36.3c0,12.9-2.6,25.1-7.3,36.3 + C524.5,569.8,491.3,593.4,452.7,593.4z"/> +</g> +</svg> diff --git a/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-portrait-light-background.png b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-portrait-light-background.png new file mode 100644 index 00000000..d422be23 Binary files /dev/null and b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-portrait-light-background.png differ diff --git a/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-portrait-light-background.svg b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-portrait-light-background.svg new file mode 100644 index 00000000..e4bfd347 --- /dev/null +++ b/.claude/skills/open-elements-brand-guidelines/open-elements-logo/logo-portrait-light-background.svg @@ -0,0 +1,56 @@ +<?xml version="1.0" encoding="utf-8"?> +<!-- Generator: Adobe Illustrator 24.3.0, SVG Export Plug-In . SVG Version: 6.00 Build 0) --> +<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" + viewBox="0 0 1000 1000" style="enable-background:new 0 0 1000 1000;" xml:space="preserve"> +<style type="text/css"> + .st0{fill:#010149;} + .st1{fill:#01BD9C;} + .st2{fill:#FD0177;} + .st3{fill:#0FBBFB;} + .st4{fill:#F4E301;} + .st5{fill:#FFFFFF;} +</style> +<g> + <path class="st2" d="M463.7,321.6v0.1c1.7-0.1,3.4-0.1,5.1-0.1H463.7z"/> + <path class="st2" d="M559.3,369.5h81.5v-47.9H468.8C506.3,321.6,539.5,340.6,559.3,369.5z"/> + <path class="st3" d="M575.6,455.1h65.2v-47.9h-65.2c1.7,7.7,2.7,15.7,2.7,24S577.4,447.4,575.6,455.1z"/> + <path class="st4" d="M463.7,540.7h5.1c-1.7,0-3.4-0.1-5.1-0.1V540.7z"/> + <path class="st4" d="M468.8,540.7h172.1v-47.9h-81.5C539.5,521.7,506.3,540.7,468.8,540.7z"/> + <path class="st1" d="M575.6,407.2c-3.1-13.7-8.7-26.4-16.4-37.7c-19.7-28.9-52.9-47.9-90.5-47.9c-1.7,0-3.4,0.1-5.1,0.1 + c-58.1,2.7-104.5,50.7-104.5,109.4c0,58.7,46.4,106.8,104.5,109.4c1.7,0.1,3.4,0.1,5.1,0.1c37.6,0,70.8-19,90.5-47.9 + c7.7-11.2,13.3-24,16.4-37.7c1.7-7.7,2.7-15.7,2.7-24S577.4,414.9,575.6,407.2z M468.8,492.8c-34,0-61.6-27.7-61.6-61.6 + c0-34,27.7-61.6,61.6-61.6c25.5,0,47.4,15.6,56.8,37.7c3.1,7.4,4.8,15.5,4.8,24c0,8.5-1.7,16.6-4.8,24 + C516.2,477.3,494.3,492.8,468.8,492.8z"/> + <path class="st0" d="M252.1,604.1c-19.5,0-29,14.9-29,29.8c0,14.8,9.2,29.1,29,29.1c19.8,0,28.8-14.6,29-29.2 + C281.2,619.1,271.6,604.1,252.1,604.1z M252.1,653.3c-13.3,0-18.3-9.9-18.6-19.2c-0.2-9.5,5.2-20.3,18.6-20.3 + c13.3,0,18.6,10.7,18.5,20.2C270.4,643.3,265.4,653.3,252.1,653.3z"/> + <path class="st0" d="M310.9,621.1c-4.5,0-9.8,1.9-12.9,6.4l-0.6-5.5h-9.2v56.4h9.8v-21.3c2.8,4.4,9,5.6,13.2,5.6 + c12.7,0,20.1-9.2,20.1-20.8C331.3,630.2,323.2,621.1,310.9,621.1z M310.2,653.2c-6.7,0-11.3-5.1-11.3-11.3 + c0-6.2,4.2-11.3,11.3-11.3c7.1,0,11.3,5.1,11.3,11.3C321.5,648.1,316.9,653.2,310.2,653.2z"/> + <path class="st0" d="M358,620.8c-12.9,0-21.1,8.7-21.1,20.8c0,12.7,8.1,21.2,21.9,21.2c6.1,0,12.9-2.1,17.1-6.5l-6.3-6.2 + c-2.3,2.3-7,3.7-10.7,3.7c-6.9,0-11.2-3.6-11.9-8.5h31.1C379.6,629,371.3,620.8,358,620.8z M347.1,637.2c1.5-5.2,5.8-7.7,11.1-7.7 + c5.6,0,9.7,2.6,10.3,7.7H347.1z"/> + <path class="st0" d="M407.9,621.3c-5,0-9,2-13.1,6l-0.6-5.4h-8.8v39.9h9.8v-20.3c0-6.1,4.1-11.1,10.2-11.1c6.3,0,9.6,4.6,9.6,10.7 + v20.8h9.8v-20.9C424.8,628.4,417.3,621.3,407.9,621.3z"/> + <path class="st0" d="M520.5,621.3c-11.2,0-20.3,8.6-20.3,20.6c0,12.7,9,20.5,20.3,20.5c6.4,0,13.3-2.6,17.2-7.7l-2.8-2.3 + c-3,4-9.1,6.1-14.4,6.1c-8.2,0-15.4-5.4-16.2-14.8h35.9C541.7,628.1,531.7,621.3,520.5,621.3z M504.2,640.2 + c0.9-9.8,8-15.3,16.2-15.3c9.6,0,16.1,5.5,16.1,15.3H504.2z"/> + <rect x="486.4" y="605.3" class="st0" width="4" height="56.5"/> + <path class="st0" d="M593.2,621.1c-6.1,0-12.3,3.3-14.8,9.8c-2.3-7.1-8.7-9.8-14.8-9.8c-5.2,0-10.2,2.2-13,7.4l-0.1-6.6h-3.7v39.9 + h4v-23.6c0-7.7,5.2-13.2,12.7-13.2c7.6,0,12.8,5.6,12.8,13.2v23.6h4v-23.6c0-7.7,5.2-13.3,12.8-13.3c7.6,0,12.7,5.4,12.7,13.1v23.9 + h4v-23.9C609.9,627.9,603,621.1,593.2,621.1z"/> + <path class="st0" d="M639,621.3c-11.2,0-20.3,8.6-20.3,20.6c0,12.7,9,20.5,20.3,20.5c6.4,0,13.3-2.6,17.2-7.7l-2.8-2.3 + c-3,4-9.1,6.1-14.4,6.1c-8.2,0-15.4-5.4-16.2-14.8h35.9C660.3,628.1,650.3,621.3,639,621.3z M622.8,640.2c0.9-9.8,8-15.3,16.2-15.3 + c9.6,0,16.1,5.5,16.1,15.3H622.8z"/> + <path class="st0" d="M687,621.2c-5.6,0.1-11.1,2.3-14.2,7.8v-7.1H669v39.9h4v-22.2c0-8.2,5.7-14.4,14-14.5 + c8.6-0.1,14.2,4.8,14.2,13.8v22.9h4v-23C705,627.7,697.7,621.2,687,621.2z"/> + <path class="st0" d="M730.1,658.7c-6.2,0-7.3-3.8-7.3-9.2v-24.3h13.6v-3.3h-13.6v-12l-3.9,0.4v11.6h-8.5v3.3h8.5v24.3 + c0,7.8,2.7,12.8,11.2,12.8c2.5,0,5-0.8,7.5-2l-1.4-3.2C734.2,658,732.1,658.7,730.1,658.7z"/> + <path class="st0" d="M760.5,639.6c-5-0.9-11.9-1.9-12.1-7.3c-0.2-5.1,5.8-7.4,12-7.3c4.4,0,8.4,0.6,12.4,4.2l2.4-2.6 + c-4-3.7-9-5.3-14.8-5.3c-8.1-0.1-15.9,3.3-15.8,11.1c0.1,8,7.7,9.4,15.5,10.7c6.5,1,13.2,2.2,13,7.9c-0.2,6.3-7.6,7.6-12.4,7.6 + c-5.3,0-11.3-2-14.6-6.8l-2.9,2.6c3.5,5.3,10.4,8,17.4,8c7,0,16.1-2.3,16.4-11.1C777.3,642,767.6,640.8,760.5,639.6z"/> + <polygon class="st0" points="437.1,609.2 441.3,609.2 454.6,609.2 477,609.2 477,605.1 437.1,605.1 "/> + <polygon class="st0" points="441.3,657.3 437.1,657.3 437.1,661.6 477,661.6 477,657.4 441.3,657.4 "/> + <polygon class="st0" points="441.3,631.1 437.1,631.1 437.1,635.1 456.3,635.1 456.3,635.1 477,635.1 477,631.1 441.3,631.1 "/> +</g> +</svg> diff --git a/.claude/skills/open-elements-info/SKILL.md b/.claude/skills/open-elements-info/SKILL.md new file mode 100644 index 00000000..2e734d04 --- /dev/null +++ b/.claude/skills/open-elements-info/SKILL.md @@ -0,0 +1,95 @@ +--- +name: open-elements-info +license: Apache-2.0 +metadata: + source: https://github.com/open-elements/claude-base + author: Open Elements +description: Background information about Open Elements GmbH — company profile, founder Hendrik Ebbers, team, mission, business areas (Support & Care, Digital Trust), foundation memberships, and contact details. Use when generating content that references the company, its people, its values, or its organizational context. Also use when the user mentions Hendrik Ebbers, Open Elements, or needs company background for proposals, tenders, or presentations. +--- + +# Open Elements Company Information + +## Overview + +Open Elements GmbH is a German IT company focusing on open-source software (OSS) and Java. +By specializing in Java-based OSS, we provide expert advice and support in developing and using open-source software. +We are members of the leading committees and foundations on these topics and actively contribute to the further development of critical open-source systems in the Java ecosystem. + +Open Elements sustainably reinvests income from Support & Care into OSS projects. + +The company motto is "Open Source made right." + +## Founder — Hendrik Ebbers + +Hendrik Ebbers is the founder of Open Elements and Director of Open Source at Hashgraph. + +**Roles and positions:** + +- Member of the Board of Directors of the Eclipse Foundation +- Technical Steering Committee Chair of the Hiero project (Linux Foundation) +- Vice Chair of the LFDT Technical Advisory Board (Linux Foundation) +- Member of AAIF working groups (Linux Foundation) +- Co-leading and contributing to Eclipse JakartaEE and Eclipse Adoptium +- Founding member of Eclipse Adoptium (formerly on the AdoptOpenJDK TSC) + +**Recognition:** + +- Java Champion +- JavaOne Rockstar +- Member of JSR expert groups + +**Community:** + +- Founded the Java User Group Dortmund in 2012 +- Regular speaker at international conferences +- Lectures on decentralized ledger technology at universities (OTH Regensburg) + +## Business Areas + +### Support & Care + +Support for critical open-source software (e.g. Apache Maven support with Sovereign Tech Agency). + +### Digital Trust + +Work on Hedera, Hiero (Linux Foundation Decentralized Trust), and related technologies. + +## Foundation Memberships and Roles + +- **Eclipse Foundation**: Contributing Member — Hendrik Ebbers is a member of the Board of Directors (Europe's largest OSS foundation). +- **Eclipse Adoptium**: Participant Member — Hendrik Ebbers is a founding member of Eclipse Adoptium (formerly on the AdoptOpenJDK TSC). +- **JakartaEE**: Participant Member. +- **Open Regulatory Compliance Working Group (ORC WG)**: Founding Member and Participant Member (https://orcwg.org). Open Elements actively contributes to a practical implementation of the Cyber Resilience Act (CRA) rules for open-source software and industry. Initially Hendrik Ebbers was a regular participant in the WG meetings; Sebastian Tiemann has since taken over and is especially active in the CRA Attestation Working Group (https://github.com/orcwg/cra-attestations). +- **Linux Foundation**: Hendrik Ebbers is Vice Chair of the LFDT Technical Advisory Board, TSC Chair of the Hiero project, and member of AAIF working groups (world's largest OSS foundation). +- **Apache Maven**: Sponsor and active contributor. +- **BVMW**: Member (German Association for Small/Medium Businesses). +- **iJUG e.V.**: Member (German Java User Groups umbrella organization). + +## Partners + +Eclipse Foundation, Linux Foundation, Sovereign Tech Agency, Hedera, Hashgraph, OTH Regensburg, AKG GmbH, DUH-IT + +## Community Engagement + +- See the "Founder — Hendrik Ebbers" section for details on community engagement. + +## Mission + +Open Elements promotes open-source software in a sustainable and transparent manner through cooperation with foundations, universities, and industry partners. + +## Contact + +Open Elements GmbH +Gerhart-Hauptmann-Str. 49B +51379 Leverkusen +Germany + +Mail: hendrik.ebbers@open-elements.de +Umsatzsteuer ID: DE355815175 + +## Online Presence + +- Website: https://open-elements.com (available in EN and DE) +- GitHub (main): https://github.com/OpenElements +- GitHub (labs/evaluation): https://github.com/OpenElementsLabs +- GitHub (Support & Care): https://github.com/support-and-care \ No newline at end of file diff --git a/.claude/skills/open-source-facts/SKILL.md b/.claude/skills/open-source-facts/SKILL.md new file mode 100644 index 00000000..9b40d971 --- /dev/null +++ b/.claude/skills/open-source-facts/SKILL.md @@ -0,0 +1,366 @@ +--- +name: open-source-facts +license: Apache-2.0 +metadata: + source: https://github.com/open-elements/claude-base + author: Open Elements +description: Statistics, economic data, success stories, and key facts about open-source software (OSS) adoption, market size, developer ecosystem, ROI, and business impact. Use when the user needs data points for presentations, tenders, proposals, blog posts, or any content that benefits from concrete open-source statistics. Also use when the user asks about OSS adoption rates, market trends, economic value, developer demographics, CRA impact statistics, Bitkom Open Source Monitor, OSS ROI, or real-world OSS success stories and case studies. +--- + +# Open Source Facts & Statistics + +This skill provides concrete, sourced statistics about open-source software for use in business documents, presentations, tenders, and other professional content. + +**Important:** Statistics change over time. When using these numbers in documents, always note the source and year. If the document will be published or submitted, consider verifying the latest numbers from the original sources listed at the bottom of this file. + +## Developer Ecosystem + +### GitHub (Octoverse 2025) + +| Metric | Value | +|--------|-------| +| Total developers on GitHub | 180+ million | +| New developers in 2025 | 36.2 million (+23% YoY) | +| Growth rate | ~1 new developer joins every second | +| Total repositories | 630 million | +| Public/open-source repositories | 395 million (63% of all repos) | +| New repositories in 2025 | 121 million | +| Contributions to public repos (2025) | 1.12 billion (+13% YoY) | +| Pull requests merged (2025) | 518.7 million (+29% YoY) | +| Commits pushed (2025) | 986 million (+25% YoY) | + +### Developer Growth Projections (2030) + +| Country | Projected Developers | +|---------|---------------------| +| India | 57.5 million | +| United States | 54.7 million | +| Brazil | 19.6 million | +| Japan | 11.7 million | +| United Kingdom | 11 million | + +## Open Source in Enterprise Software + +### Adoption Rates + +- **96%** of all codebases contain open-source components (Black Duck/Synopsys OSSRA Report) +- **70-90%** of a typical modern software application consists of open-source code (various industry estimates, Linux Foundation) +- Over **80%** of organizations use open-source software in their IT infrastructure (Gartner) +- **95%** of IT leaders say enterprise open source is strategically important (Red Hat State of Enterprise Open Source) + +### Germany: Bitkom Open Source Monitor 2025 + +Representative survey of 1,100+ German companies and 100 public sector organizations (Bitkom Research 2025): + +**Adoption & Attitude:** +- **61%** of German companies are open to OSS (24% "very open", 37% "rather open") +- **73%** of companies use OSS — stable at ~70% since 2021 (71% in 2021, 69% in 2023, 73% in 2025) +- **42%** expect the importance of OSS in their company to increase +- **67%** use OSS internally without modifying source code; **35%** modify source code +- **25%** integrate OSS into customer-facing products +- **60%** have no OSS strategy; **37%** have a documented strategy (up from 25% in 2021) + +**Top advantages cited by companies:** +- Cost savings: **26%** +- Access to source code for review/customization: **19%** +- Increased digital sovereignty: **8%** +- Support for open standards: **6%** + +**Top barriers to adoption:** +- Security concerns: **71%** +- Legal uncertainties (licensing): **60%** +- Unclear warranty/liability: **59%** +- Compliance/regulatory requirements: **43%** +- Lack of skilled OSS personnel: **71%** (of non-adopters) + +**Selection criteria (% rating "very/rather important"):** +- Security indicators/certifications: **94%** +- Functionality: **94%** +- CRA compliance: **92%** +- IP/copyright clarity: **90%** +- Number of available support partners: **83%** +- License type: **84%** +- Community reputation: **81%** + +**OSS contribution:** +- **47%** of companies participate in OSS development +- **37%** buy support/subscriptions for commercial OSS +- **17%** contribute modified source code back to communities +- **51%** do not participate in OSS development at all +- **13%** are paying members of OSS foundations (Linux, Eclipse) + +**Public sector:** +- **63%** of public sector organizations use OSS +- **52%** are positively disposed toward OSS +- **25%** of public sector organizations have an OSPO (vs. 14% in the private sector) +- Average **4 FTEs** for OSS management in public sector (vs. 1.9 in private sector) + +**Digital sovereignty:** +- **73%** see OSS as an instrument for strengthening digital sovereignty +- **60%** want increased government investment in OSS +- **57%** support the Sovereign Tech Agency +- Only **17%** have fully analyzed and reduced their digital dependencies + +**AI & Open Source:** +- **51%** consider open-source AI models recommendable +- **45%** see them as a way to avoid dependencies + +**Source:** Bitkom Open Source Monitor 2025 (DOI: 10.64022/2025-open-source-monitor) + +### Enterprise Trends + +- Enterprises are shifting from proprietary to open-source solutions across infrastructure, databases, middleware, and application development +- Open-source adoption is driven by: better security through transparency, faster innovation cycles, avoidance of vendor lock-in, lower total cost of ownership, and access to talent +- Most enterprises use a mix of community open source and commercial open-source products with enterprise support + +## Economic Value + +### The $8.8 Trillion Study (Harvard Business School, 2024) + +A landmark study by researchers at Harvard Business School ("The Value of Open Source Software", Hoffmann et al., 2024) estimated: + +- The **demand-side value** of widely-used OSS is **$8.8 trillion** +- If OSS did not exist, companies would need to spend **3.5x more** on software +- The top 6 programming languages account for **84%** of the value +- A small number of developers create most of the value: the **top 5%** of developers contribute **over 90%** of the value + +**Source:** Harvard Business School Working Paper 24-038, "The Value of Open Source Software" + +### EU Economic Impact Study (European Commission, 2021) + +A study commissioned by the European Commission found: + +- OSS contributes **€65-95 billion** to the European GDP +- A **10% increase** in OSS contributions would generate **€100 billion+** additional EU GDP annually +- The **cost-benefit ratio** of investing in OSS is **1:4** — every €1 invested yields €4 in economic value +- EU-based OSS developers contributed code valued at an estimated **€1 billion** annually + +**Source:** European Commission, "Study about the Impact of Open Source Software and Hardware on Technological Independence, Competitiveness and Innovation in the EU Economy", 2021 + +### Linux Foundation ROI Survey (February 2026) + +The Linux Foundation's "ROI for Open Source Software Contribution" report surveyed organizations about the measurable returns from contributing to OSS: + +**Core finding: Contributing to OSS delivers a 2-5x return on investment across all forms of engagement.** + +**Cost of NOT contributing:** +- Without OSS, organizations would spend **$3.5 million** to purchase proprietary alternatives (53%) or write the code themselves (51%) +- **49%** of organizations develop internal workarounds for features not on OSS roadmaps, costing an average of **$670,000/year** +- **45%** maintain private forks of OSS components — averaging **86 private forks** per organization +- Private fork maintenance costs **5,160 labor hours ($258,000 USD)** per release cycle on average +- **36%** report that missing OSS features cause frequent production delays (rises to **54%** for large organizations) + +**ROI by contribution type:** +- Code contribution: **3.6x** benefit-to-cost ratio +- Community contribution: **3.2x** +- Financial contribution: **2.4x** +- Foundation membership: **4.8x** (highest ROI, requires least internal capacity) + +**Benefits of contributing:** +- **10%** average increase in product development speed +- **68%** say OSS contribution makes hiring and retaining talent easier +- **66%** report upstream maintainers respond faster to security issues after contributing +- **2+ months** advance notice for important changes +- **2 out of 3** respondents report ROI has increased since they began contributing +- **70%** expect continued ROI increases in the future + +**Economic model:** +- The top 100 contributing organizations invested **$3.9 billion** between 2018 and 2025 +- This yielded **$23.2 billion** in benefits — approximately **6x ROI** +- Foundation membership delivers benefits **5x greater** than the investment; key benefits are networking and brand recognition + +**Source:** Linux Foundation Research, "ROI for Open Source Software Contribution", February 2026 + +### Open Source Software Funding Report (Harvard/Linux Foundation/GitHub, 2024) + +- Organizations worldwide invest approximately **$7.7 billion per year** in OSS +- **86%** of this is provided as employee working time (not cash) +- The annual benefit is estimated at **$2.9 to $10.1 billion**, with a median of **$520,600 per organization** +- If no country contributed to OSS, the average GDP would be **2.2% lower** in the long term + +**Source:** Open Source Software Funding Report 2024 (cited in Open Elements Whitepaper) + +### Linux Foundation Economic Estimates + +- The cost to recreate the Linux kernel alone is estimated at over **$14 billion** +- The total value of the collaborative open-source projects hosted by the Linux Foundation exceeds **$100 billion** in development costs + +## Security & Supply Chain + +### OSSRA Report (Black Duck / Synopsys) + +The annual Open Source Security and Risk Analysis (OSSRA) report audits commercial codebases: + +- **96%** of codebases contain open-source components +- **76%** of all code in audited codebases is open source +- **84%** of codebases contain at least one known vulnerability +- **48%** contain high-risk vulnerabilities +- **91%** of codebases use components with no recent development activity (2+ years without updates) + +These numbers underscore why professional OSS maintenance (like Support & Care) is critical. + +### Vulnerability Response + +- Average time to fix a critical open-source vulnerability: **50-300 days** (GitHub Octoverse 2025, trend improving) +- The Log4Shell vulnerability (CVE-2021-44228) demonstrated the risk: a single critical flaw in a widely-used base library affected millions of applications worldwide + +## Key Open-Source Projects — Adoption Numbers + +### Java Ecosystem + +| Project | Adoption | Source | +|---------|----------|--------| +| JUnit | ~85% of Java projects, 1 billion+ downloads/month | JetBrains Developer Ecosystem Survey | +| Apache Maven | ~75% of Java projects, 2 billion downloads/year | JetBrains, Sonatype | +| Apache Log4j | ~76% of Java applications | New Relic State of Java Ecosystem | +| Apache Commons | ~49% of Java developers | JetBrains Developer Ecosystem Survey | +| Eclipse Temurin | 500,000+ downloads/day, 880M+ total | Eclipse Adoptium | + +### General + +| Project | Metric | +|---------|--------| +| Linux kernel | Runs on 96% of top 1M web servers, all top 500 supercomputers, most Android devices | +| Kubernetes | Used by 84% of organizations running containers (CNCF Survey) | +| PostgreSQL | Most popular database among developers (Stack Overflow Survey) | +| VS Code | Most popular IDE with 74% market share among developers (Stack Overflow Survey) | + +## Open Source Foundations — Scale + +| Foundation | Key Metrics | +|------------|-------------| +| **Linux Foundation** | 800+ projects, largest OSS foundation globally | +| **Eclipse Foundation** | 400+ projects, largest European OSS foundation | +| **Apache Software Foundation** | 350+ projects, $22 billion+ estimated value of maintained code | +| **CNCF** | 180+ projects including Kubernetes, 900+ contributing organizations | + +## Open Source Business Models + +The most common commercial models built on open source: + +| Model | Description | Examples | +|-------|-------------|----------| +| **Open Core** | Core is OSS, premium features are proprietary | GitLab, Elastic, MongoDB | +| **Support & Services** | Software is fully OSS, revenue from support/consulting | Red Hat, Open Elements | +| **SaaS/Managed** | OSS hosted as a managed cloud service | AWS (managed OSS services), Confluent | +| **Dual Licensing** | OSS license + commercial license option | MySQL, Qt | +| **Open Source Stewardship** | Maintaining and supporting critical OSS dependencies for enterprises | Open Elements (Support & Care) | + +## Success Stories + +Real-world examples of OSS delivering measurable value — useful for presentations, tenders, and proposals. + +### Toulouse (France) — Municipal Government + +Toulouse, the fourth-largest city in France, migrated approximately 8,000 workstations to LibreOffice. The project took 18 months and was deliberately designed for flexibility. **Result:** Annual savings of **€1.8 million** in software licenses alone. The migration costs including custom development were approximately **€800,000** — meaning the investment paid for itself within the first year. + +**Source:** Open Elements Whitepaper, Nomensa Case Study + +### German Automotive Supplier — Industry / ERP + +A German automotive supplier switched to an open-source ERP system and additional OSS-based components. **Results:** Production downtime decreased by **66%**, order processing time shortened by **43%**, and operative costs were reduced by **30%**. + +**Source:** Open Elements Whitepaper (Silent Infotech Case Study) + +### Lehner Versand AG (Switzerland) — E-Commerce + +Lehner Versand AG, a Swiss multi-channel retailer with approximately 300 employees and annual revenues in the double-digit millions, migrated their email and marketing automation from a proprietary system to the open-source platform Mautic in 2022. **Result:** Five-figure savings over the project's duration, plus achievement of GDPR compliance that the previous system could not guarantee. + +**Source:** Open Elements Whitepaper (Mautic Case Study) + +### Essex Council (UK) — Public Sector + +Essex Council migrated to LocalGov Drupal, an open-source CMS built collaboratively by UK municipalities. The shared development model allowed multiple councils to contribute and benefit from each other's improvements, reducing costs and increasing functionality for all participants. + +**Source:** Open Elements Whitepaper (Nomensa Case Study) + +### UK Data Standards Authority — Open Standards + +The UK Data Standards Authority chose ODF (Open Document Format) as the standard file format. The decision was based on the fact that the OSS format enables strict security audits, reduces IT costs, and facilitates document exchange between government agencies, citizens, and businesses. + +**Source:** Open Elements Whitepaper + +### Mercedes-Benz — Enterprise FOSS Strategy + +Mercedes-Benz made "Embrace FOSS" a strategic priority in their FOSS Manifesto published in 2018. Dr. Wolfgang Gehring (FOSS Ambassador, Mercedes-Benz Tech Innovation) supports the Linux Foundation ROI study, stating it "provides invaluable, actionable guidance and demonstrates a tangible ROI for Open Source Software contributions." + +**Source:** Linux Foundation ROI Survey 2026 + +### EU Commission Investment + +The EU Commission invested approximately **€140 million** in more than **1,200 OSS projects** between 2019 and 2024. Germany provides approximately **€19 million/year** via the Sovereign Tech Agency for securing and maintaining critical OSS infrastructure. Of this, **€0.5 million** flows into the maintenance of Apache Maven through Open Elements. + +**Source:** Open Elements Whitepaper (NGI Commons Study) + +## Cyber Resilience Act (CRA) & Regulation + +### CRA Overview + +- **Regulation (EU) 2024/2847** — entered into force on 10 December 2024 +- Starting **2027**, manufacturers are responsible for **100% of their software**, including all open-source dependencies +- Applies to all "products with digital elements" placed on the EU market — including standalone software, hardware with embedded software, and combinations thereof +- Compliance drivers in German enterprises (Bitkom 2025): CER (61%), **CRA (57%)**, PLD (44%) + +### CRA and Open Source + +The EU Commission published guidance (March 2026) specifically addressing FOSS: + +- FOSS that is **not monetized** and **not placed on the market** in a commercial context is **outside the CRA's scope** +- Sharing code on public repositories is **not** considered "placing on the market" +- However, if FOSS is integrated into a commercial product, the **manufacturer** (not the OSS project) bears CRA responsibility +- The CRA introduces the role of **Open-Source Software Steward** (Article 3(14)) — a legal person that systematically supports the maintenance of critical OSS components +- Stewards are subject to obligations under **Article 24** (lighter than manufacturer obligations) +- The **ORC WG** (Open Regulatory Compliance Working Group) at the Eclipse Foundation develops practical CRA compliance guidelines + +**Source:** EU Commission CRA Guidance (Ref. Ares(2026)2319816, March 2026); Daniel Thompson-Yvetot, "Manufacturing European Software" (2024) + +### CRA Impact on Enterprises + +- **92%** of German companies consider CRA compliance important when selecting OSS (Bitkom 2025) +- **43%** cite compliance/regulatory requirements as a barrier to OSS adoption +- Companies must maintain SBOMs, conduct cybersecurity risk assessments, and provide security updates throughout the support period +- The concept of "substantial modification" means significant software updates can trigger new compliance obligations + +See the `eclipse-info` skill (ORC WG section) and the `support-and-care-info` skill for details on Open Elements' involvement. + +## AI & Open Source + +### GitHub Octoverse 2025 + +| Metric | Value | +|--------|-------| +| AI projects on GitHub | 4.3 million total | +| New AI projects (2025) | 693,867 (+178% YoY) | +| Repos using LLM SDKs | 1.1 million | +| Developers using Copilot in first week | 80% of new GitHub users | +| AI-focused repos in top 10 by contributors | 60% | + +### Open Source AI Trend + +- The majority of frontier AI development builds on open-source libraries (PyTorch, TensorFlow, Hugging Face Transformers) +- Open-source LLMs (LLaMA, Mistral, etc.) are rapidly closing the gap to proprietary models +- Model Context Protocol (MCP) reached 37K GitHub stars in 8 months — showing demand for open standards in AI tooling + +## Sources + +All statistics should be verified against the original sources before use in formal documents. + +| Source | URL | Data | +|--------|-----|------| +| GitHub Octoverse 2025 | https://github.blog/news-insights/octoverse/ | Developer ecosystem, contributions, AI | +| Black Duck OSSRA Report | https://www.blackduck.com/resources/analyst-reports/open-source-security-risk-analysis.html | Codebase composition, vulnerabilities | +| Harvard Business School OSS Study | Search: "The Value of Open Source Software" HBS Working Paper 24-038 | $8.8 trillion value estimate | +| EU Commission OSS Impact Study | https://digital-strategy.ec.europa.eu/en/library/study-about-impact-open-source-software-and-hardware-technological-independence-competitiveness-and | European economic impact | +| JetBrains Developer Ecosystem | https://www.jetbrains.com/lp/devecosystem/ | Java ecosystem adoption | +| New Relic State of Java Ecosystem | https://newrelic.com/resources/report/state-of-the-java-ecosystem | Java library usage | +| Red Hat State of Enterprise Open Source | https://www.redhat.com/en/enterprise-open-source-report | Enterprise adoption | +| Stack Overflow Developer Survey | https://survey.stackoverflow.co/ | Tool and language popularity | +| CNCF Survey | https://www.cncf.io/reports/ | Cloud native adoption | +| Linux Foundation ROI Survey 2026 | https://www.linuxfoundation.org/research | ROI of OSS contribution, private fork costs | +| Bitkom Open Source Monitor 2025 | DOI: 10.64022/2025-open-source-monitor | German enterprise OSS adoption | +| Open Elements OSS Whitepaper | Contact Open Elements | Success stories, facts, German market data | +| Bitkom Open Source Leitfaden 3.0 | https://www.bitkom.org | OSS enterprise guide, business models, compliance | +| Manufacturing European Software | Daniel Thompson-Yvetot, ISBN 978-9918-0-0959-6 | CRA compliance, EU regulatory landscape | +| EU Commission CRA Guidance | Ref. Ares(2026)2319816, March 2026 | Official CRA implementation guidance | +| Open Source Funding Report 2024 | Harvard/Linux Foundation/GitHub | Global OSS investment, GDP impact | +| Linux Foundation Research | https://www.linuxfoundation.org/research | Enterprise OSS strategy | diff --git a/.claude/skills/pdf/LICENSE.txt b/.claude/skills/pdf/LICENSE.txt new file mode 100644 index 00000000..c55ab422 --- /dev/null +++ b/.claude/skills/pdf/LICENSE.txt @@ -0,0 +1,30 @@ +© 2025 Anthropic, PBC. All rights reserved. + +LICENSE: Use of these materials (including all code, prompts, assets, files, +and other components of this Skill) is governed by your agreement with +Anthropic regarding use of Anthropic's services. If no separate agreement +exists, use is governed by Anthropic's Consumer Terms of Service or +Commercial Terms of Service, as applicable: +https://www.anthropic.com/legal/consumer-terms +https://www.anthropic.com/legal/commercial-terms +Your applicable agreement is referred to as the "Agreement." "Services" are +as defined in the Agreement. + +ADDITIONAL RESTRICTIONS: Notwithstanding anything in the Agreement to the +contrary, users may not: + +- Extract these materials from the Services or retain copies of these + materials outside the Services +- Reproduce or copy these materials, except for temporary copies created + automatically during authorized use of the Services +- Create derivative works based on these materials +- Distribute, sublicense, or transfer these materials to any third party +- Make, offer to sell, sell, or import any inventions embodied in these + materials +- Reverse engineer, decompile, or disassemble these materials + +The receipt, viewing, or possession of these materials does not convey or +imply any license or right beyond those expressly granted above. + +Anthropic retains all right, title, and interest in these materials, +including all copyrights, patents, and other intellectual property rights. diff --git a/.claude/skills/pdf/SKILL.md b/.claude/skills/pdf/SKILL.md new file mode 100644 index 00000000..86879abe --- /dev/null +++ b/.claude/skills/pdf/SKILL.md @@ -0,0 +1,318 @@ +--- +name: pdf +description: Use this skill whenever the user wants to do anything with PDF files. This includes reading or extracting text/tables from PDFs, combining or merging multiple PDFs into one, splitting PDFs apart, rotating pages, adding watermarks, creating new PDFs, filling PDF forms, encrypting/decrypting PDFs, extracting images, and OCR on scanned PDFs to make them searchable. If the user mentions a .pdf file or asks to produce one, use this skill. +license: Proprietary. LICENSE.txt has complete terms +metadata: + source: https://github.com/anthropics/skills + author: Anthropic + modifications: None +--- + +# PDF Processing Guide + +## Overview + +This guide covers essential PDF processing operations using Python libraries and command-line tools. For advanced features, JavaScript libraries, and detailed examples, see REFERENCE.md. If you need to fill out a PDF form, read FORMS.md and follow its instructions. + +## Quick Start + +```python +from pypdf import PdfReader, PdfWriter + +# Read a PDF +reader = PdfReader("document.pdf") +print(f"Pages: {len(reader.pages)}") + +# Extract text +text = "" +for page in reader.pages: + text += page.extract_text() +``` + +## Python Libraries + +### pypdf - Basic Operations + +#### Merge PDFs +```python +from pypdf import PdfWriter, PdfReader + +writer = PdfWriter() +for pdf_file in ["doc1.pdf", "doc2.pdf", "doc3.pdf"]: + reader = PdfReader(pdf_file) + for page in reader.pages: + writer.add_page(page) + +with open("merged.pdf", "wb") as output: + writer.write(output) +``` + +#### Split PDF +```python +reader = PdfReader("input.pdf") +for i, page in enumerate(reader.pages): + writer = PdfWriter() + writer.add_page(page) + with open(f"page_{i+1}.pdf", "wb") as output: + writer.write(output) +``` + +#### Extract Metadata +```python +reader = PdfReader("document.pdf") +meta = reader.metadata +print(f"Title: {meta.title}") +print(f"Author: {meta.author}") +print(f"Subject: {meta.subject}") +print(f"Creator: {meta.creator}") +``` + +#### Rotate Pages +```python +reader = PdfReader("input.pdf") +writer = PdfWriter() + +page = reader.pages[0] +page.rotate(90) # Rotate 90 degrees clockwise +writer.add_page(page) + +with open("rotated.pdf", "wb") as output: + writer.write(output) +``` + +### pdfplumber - Text and Table Extraction + +#### Extract Text with Layout +```python +import pdfplumber + +with pdfplumber.open("document.pdf") as pdf: + for page in pdf.pages: + text = page.extract_text() + print(text) +``` + +#### Extract Tables +```python +with pdfplumber.open("document.pdf") as pdf: + for i, page in enumerate(pdf.pages): + tables = page.extract_tables() + for j, table in enumerate(tables): + print(f"Table {j+1} on page {i+1}:") + for row in table: + print(row) +``` + +#### Advanced Table Extraction +```python +import pandas as pd + +with pdfplumber.open("document.pdf") as pdf: + all_tables = [] + for page in pdf.pages: + tables = page.extract_tables() + for table in tables: + if table: # Check if table is not empty + df = pd.DataFrame(table[1:], columns=table[0]) + all_tables.append(df) + +# Combine all tables +if all_tables: + combined_df = pd.concat(all_tables, ignore_index=True) + combined_df.to_excel("extracted_tables.xlsx", index=False) +``` + +### reportlab - Create PDFs + +#### Basic PDF Creation +```python +from reportlab.lib.pagesizes import letter +from reportlab.pdfgen import canvas + +c = canvas.Canvas("hello.pdf", pagesize=letter) +width, height = letter + +# Add text +c.drawString(100, height - 100, "Hello World!") +c.drawString(100, height - 120, "This is a PDF created with reportlab") + +# Add a line +c.line(100, height - 140, 400, height - 140) + +# Save +c.save() +``` + +#### Create PDF with Multiple Pages +```python +from reportlab.lib.pagesizes import letter +from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, PageBreak +from reportlab.lib.styles import getSampleStyleSheet + +doc = SimpleDocTemplate("report.pdf", pagesize=letter) +styles = getSampleStyleSheet() +story = [] + +# Add content +title = Paragraph("Report Title", styles['Title']) +story.append(title) +story.append(Spacer(1, 12)) + +body = Paragraph("This is the body of the report. " * 20, styles['Normal']) +story.append(body) +story.append(PageBreak()) + +# Page 2 +story.append(Paragraph("Page 2", styles['Heading1'])) +story.append(Paragraph("Content for page 2", styles['Normal'])) + +# Build PDF +doc.build(story) +``` + +#### Subscripts and Superscripts + +**IMPORTANT**: Never use Unicode subscript/superscript characters (₀₁₂₃₄₅₆₇₈₉, ⁰¹²³⁴⁵⁶⁷⁸⁹) in ReportLab PDFs. The built-in fonts do not include these glyphs, causing them to render as solid black boxes. + +Instead, use ReportLab's XML markup tags in Paragraph objects: +```python +from reportlab.platypus import Paragraph +from reportlab.lib.styles import getSampleStyleSheet + +styles = getSampleStyleSheet() + +# Subscripts: use <sub> tag +chemical = Paragraph("H<sub>2</sub>O", styles['Normal']) + +# Superscripts: use <super> tag +squared = Paragraph("x<super>2</super> + y<super>2</super>", styles['Normal']) +``` + +For canvas-drawn text (not Paragraph objects), manually adjust font the size and position rather than using Unicode subscripts/superscripts. + +## Command-Line Tools + +### pdftotext (poppler-utils) +```bash +# Extract text +pdftotext input.pdf output.txt + +# Extract text preserving layout +pdftotext -layout input.pdf output.txt + +# Extract specific pages +pdftotext -f 1 -l 5 input.pdf output.txt # Pages 1-5 +``` + +### qpdf +```bash +# Merge PDFs +qpdf --empty --pages file1.pdf file2.pdf -- merged.pdf + +# Split pages +qpdf input.pdf --pages . 1-5 -- pages1-5.pdf +qpdf input.pdf --pages . 6-10 -- pages6-10.pdf + +# Rotate pages +qpdf input.pdf output.pdf --rotate=+90:1 # Rotate page 1 by 90 degrees + +# Remove password +qpdf --password=mypassword --decrypt encrypted.pdf decrypted.pdf +``` + +### pdftk (if available) +```bash +# Merge +pdftk file1.pdf file2.pdf cat output merged.pdf + +# Split +pdftk input.pdf burst + +# Rotate +pdftk input.pdf rotate 1east output rotated.pdf +``` + +## Common Tasks + +### Extract Text from Scanned PDFs +```python +# Requires: pip install pytesseract pdf2image +import pytesseract +from pdf2image import convert_from_path + +# Convert PDF to images +images = convert_from_path('scanned.pdf') + +# OCR each page +text = "" +for i, image in enumerate(images): + text += f"Page {i+1}:\n" + text += pytesseract.image_to_string(image) + text += "\n\n" + +print(text) +``` + +### Add Watermark +```python +from pypdf import PdfReader, PdfWriter + +# Create watermark (or load existing) +watermark = PdfReader("watermark.pdf").pages[0] + +# Apply to all pages +reader = PdfReader("document.pdf") +writer = PdfWriter() + +for page in reader.pages: + page.merge_page(watermark) + writer.add_page(page) + +with open("watermarked.pdf", "wb") as output: + writer.write(output) +``` + +### Extract Images +```bash +# Using pdfimages (poppler-utils) +pdfimages -j input.pdf output_prefix + +# This extracts all images as output_prefix-000.jpg, output_prefix-001.jpg, etc. +``` + +### Password Protection +```python +from pypdf import PdfReader, PdfWriter + +reader = PdfReader("input.pdf") +writer = PdfWriter() + +for page in reader.pages: + writer.add_page(page) + +# Add password +writer.encrypt("userpassword", "ownerpassword") + +with open("encrypted.pdf", "wb") as output: + writer.write(output) +``` + +## Quick Reference + +| Task | Best Tool | Command/Code | +|------|-----------|--------------| +| Merge PDFs | pypdf | `writer.add_page(page)` | +| Split PDFs | pypdf | One page per file | +| Extract text | pdfplumber | `page.extract_text()` | +| Extract tables | pdfplumber | `page.extract_tables()` | +| Create PDFs | reportlab | Canvas or Platypus | +| Command line merge | qpdf | `qpdf --empty --pages ...` | +| OCR scanned PDFs | pytesseract | Convert to image first | +| Fill PDF forms | pdf-lib or pypdf (see FORMS.md) | See FORMS.md | + +## Next Steps + +- For advanced pypdfium2 usage, see REFERENCE.md +- For JavaScript libraries (pdf-lib), see REFERENCE.md +- If you need to fill out a PDF form, follow the instructions in FORMS.md +- For troubleshooting guides, see REFERENCE.md diff --git a/.claude/skills/pdf/forms.md b/.claude/skills/pdf/forms.md new file mode 100644 index 00000000..6e7e1e0d --- /dev/null +++ b/.claude/skills/pdf/forms.md @@ -0,0 +1,294 @@ +**CRITICAL: You MUST complete these steps in order. Do not skip ahead to writing code.** + +If you need to fill out a PDF form, first check to see if the PDF has fillable form fields. Run this script from this file's directory: + `python scripts/check_fillable_fields <file.pdf>`, and depending on the result go to either the "Fillable fields" or "Non-fillable fields" and follow those instructions. + +# Fillable fields +If the PDF has fillable form fields: +- Run this script from this file's directory: `python scripts/extract_form_field_info.py <input.pdf> <field_info.json>`. It will create a JSON file with a list of fields in this format: +``` +[ + { + "field_id": (unique ID for the field), + "page": (page number, 1-based), + "rect": ([left, bottom, right, top] bounding box in PDF coordinates, y=0 is the bottom of the page), + "type": ("text", "checkbox", "radio_group", or "choice"), + }, + // Checkboxes have "checked_value" and "unchecked_value" properties: + { + "field_id": (unique ID for the field), + "page": (page number, 1-based), + "type": "checkbox", + "checked_value": (Set the field to this value to check the checkbox), + "unchecked_value": (Set the field to this value to uncheck the checkbox), + }, + // Radio groups have a "radio_options" list with the possible choices. + { + "field_id": (unique ID for the field), + "page": (page number, 1-based), + "type": "radio_group", + "radio_options": [ + { + "value": (set the field to this value to select this radio option), + "rect": (bounding box for the radio button for this option) + }, + // Other radio options + ] + }, + // Multiple choice fields have a "choice_options" list with the possible choices: + { + "field_id": (unique ID for the field), + "page": (page number, 1-based), + "type": "choice", + "choice_options": [ + { + "value": (set the field to this value to select this option), + "text": (display text of the option) + }, + // Other choice options + ], + } +] +``` +- Convert the PDF to PNGs (one image for each page) with this script (run from this file's directory): +`python scripts/convert_pdf_to_images.py <file.pdf> <output_directory>` +Then analyze the images to determine the purpose of each form field (make sure to convert the bounding box PDF coordinates to image coordinates). +- Create a `field_values.json` file in this format with the values to be entered for each field: +``` +[ + { + "field_id": "last_name", // Must match the field_id from `extract_form_field_info.py` + "description": "The user's last name", + "page": 1, // Must match the "page" value in field_info.json + "value": "Simpson" + }, + { + "field_id": "Checkbox12", + "description": "Checkbox to be checked if the user is 18 or over", + "page": 1, + "value": "/On" // If this is a checkbox, use its "checked_value" value to check it. If it's a radio button group, use one of the "value" values in "radio_options". + }, + // more fields +] +``` +- Run the `fill_fillable_fields.py` script from this file's directory to create a filled-in PDF: +`python scripts/fill_fillable_fields.py <input pdf> <field_values.json> <output pdf>` +This script will verify that the field IDs and values you provide are valid; if it prints error messages, correct the appropriate fields and try again. + +# Non-fillable fields +If the PDF doesn't have fillable form fields, you'll add text annotations. First try to extract coordinates from the PDF structure (more accurate), then fall back to visual estimation if needed. + +## Step 1: Try Structure Extraction First + +Run this script to extract text labels, lines, and checkboxes with their exact PDF coordinates: +`python scripts/extract_form_structure.py <input.pdf> form_structure.json` + +This creates a JSON file containing: +- **labels**: Every text element with exact coordinates (x0, top, x1, bottom in PDF points) +- **lines**: Horizontal lines that define row boundaries +- **checkboxes**: Small square rectangles that are checkboxes (with center coordinates) +- **row_boundaries**: Row top/bottom positions calculated from horizontal lines + +**Check the results**: If `form_structure.json` has meaningful labels (text elements that correspond to form fields), use **Approach A: Structure-Based Coordinates**. If the PDF is scanned/image-based and has few or no labels, use **Approach B: Visual Estimation**. + +--- + +## Approach A: Structure-Based Coordinates (Preferred) + +Use this when `extract_form_structure.py` found text labels in the PDF. + +### A.1: Analyze the Structure + +Read form_structure.json and identify: + +1. **Label groups**: Adjacent text elements that form a single label (e.g., "Last" + "Name") +2. **Row structure**: Labels with similar `top` values are in the same row +3. **Field columns**: Entry areas start after label ends (x0 = label.x1 + gap) +4. **Checkboxes**: Use the checkbox coordinates directly from the structure + +**Coordinate system**: PDF coordinates where y=0 is at TOP of page, y increases downward. + +### A.2: Check for Missing Elements + +The structure extraction may not detect all form elements. Common cases: +- **Circular checkboxes**: Only square rectangles are detected as checkboxes +- **Complex graphics**: Decorative elements or non-standard form controls +- **Faded or light-colored elements**: May not be extracted + +If you see form fields in the PDF images that aren't in form_structure.json, you'll need to use **visual analysis** for those specific fields (see "Hybrid Approach" below). + +### A.3: Create fields.json with PDF Coordinates + +For each field, calculate entry coordinates from the extracted structure: + +**Text fields:** +- entry x0 = label x1 + 5 (small gap after label) +- entry x1 = next label's x0, or row boundary +- entry top = same as label top +- entry bottom = row boundary line below, or label bottom + row_height + +**Checkboxes:** +- Use the checkbox rectangle coordinates directly from form_structure.json +- entry_bounding_box = [checkbox.x0, checkbox.top, checkbox.x1, checkbox.bottom] + +Create fields.json using `pdf_width` and `pdf_height` (signals PDF coordinates): +```json +{ + "pages": [ + {"page_number": 1, "pdf_width": 612, "pdf_height": 792} + ], + "form_fields": [ + { + "page_number": 1, + "description": "Last name entry field", + "field_label": "Last Name", + "label_bounding_box": [43, 63, 87, 73], + "entry_bounding_box": [92, 63, 260, 79], + "entry_text": {"text": "Smith", "font_size": 10} + }, + { + "page_number": 1, + "description": "US Citizen Yes checkbox", + "field_label": "Yes", + "label_bounding_box": [260, 200, 280, 210], + "entry_bounding_box": [285, 197, 292, 205], + "entry_text": {"text": "X"} + } + ] +} +``` + +**Important**: Use `pdf_width`/`pdf_height` and coordinates directly from form_structure.json. + +### A.4: Validate Bounding Boxes + +Before filling, check your bounding boxes for errors: +`python scripts/check_bounding_boxes.py fields.json` + +This checks for intersecting bounding boxes and entry boxes that are too small for the font size. Fix any reported errors before filling. + +--- + +## Approach B: Visual Estimation (Fallback) + +Use this when the PDF is scanned/image-based and structure extraction found no usable text labels (e.g., all text shows as "(cid:X)" patterns). + +### B.1: Convert PDF to Images + +`python scripts/convert_pdf_to_images.py <input.pdf> <images_dir/>` + +### B.2: Initial Field Identification + +Examine each page image to identify form sections and get **rough estimates** of field locations: +- Form field labels and their approximate positions +- Entry areas (lines, boxes, or blank spaces for text input) +- Checkboxes and their approximate locations + +For each field, note approximate pixel coordinates (they don't need to be precise yet). + +### B.3: Zoom Refinement (CRITICAL for accuracy) + +For each field, crop a region around the estimated position to refine coordinates precisely. + +**Create a zoomed crop using ImageMagick:** +```bash +magick <page_image> -crop <width>x<height>+<x>+<y> +repage <crop_output.png> +``` + +Where: +- `<x>, <y>` = top-left corner of crop region (use your rough estimate minus padding) +- `<width>, <height>` = size of crop region (field area plus ~50px padding on each side) + +**Example:** To refine a "Name" field estimated around (100, 150): +```bash +magick images_dir/page_1.png -crop 300x80+50+120 +repage crops/name_field.png +``` + +(Note: if the `magick` command isn't available, try `convert` with the same arguments). + +**Examine the cropped image** to determine precise coordinates: +1. Identify the exact pixel where the entry area begins (after the label) +2. Identify where the entry area ends (before next field or edge) +3. Identify the top and bottom of the entry line/box + +**Convert crop coordinates back to full image coordinates:** +- full_x = crop_x + crop_offset_x +- full_y = crop_y + crop_offset_y + +Example: If the crop started at (50, 120) and the entry box starts at (52, 18) within the crop: +- entry_x0 = 52 + 50 = 102 +- entry_top = 18 + 120 = 138 + +**Repeat for each field**, grouping nearby fields into single crops when possible. + +### B.4: Create fields.json with Refined Coordinates + +Create fields.json using `image_width` and `image_height` (signals image coordinates): +```json +{ + "pages": [ + {"page_number": 1, "image_width": 1700, "image_height": 2200} + ], + "form_fields": [ + { + "page_number": 1, + "description": "Last name entry field", + "field_label": "Last Name", + "label_bounding_box": [120, 175, 242, 198], + "entry_bounding_box": [255, 175, 720, 218], + "entry_text": {"text": "Smith", "font_size": 10} + } + ] +} +``` + +**Important**: Use `image_width`/`image_height` and the refined pixel coordinates from the zoom analysis. + +### B.5: Validate Bounding Boxes + +Before filling, check your bounding boxes for errors: +`python scripts/check_bounding_boxes.py fields.json` + +This checks for intersecting bounding boxes and entry boxes that are too small for the font size. Fix any reported errors before filling. + +--- + +## Hybrid Approach: Structure + Visual + +Use this when structure extraction works for most fields but misses some elements (e.g., circular checkboxes, unusual form controls). + +1. **Use Approach A** for fields that were detected in form_structure.json +2. **Convert PDF to images** for visual analysis of missing fields +3. **Use zoom refinement** (from Approach B) for the missing fields +4. **Combine coordinates**: For fields from structure extraction, use `pdf_width`/`pdf_height`. For visually-estimated fields, you must convert image coordinates to PDF coordinates: + - pdf_x = image_x * (pdf_width / image_width) + - pdf_y = image_y * (pdf_height / image_height) +5. **Use a single coordinate system** in fields.json - convert all to PDF coordinates with `pdf_width`/`pdf_height` + +--- + +## Step 2: Validate Before Filling + +**Always validate bounding boxes before filling:** +`python scripts/check_bounding_boxes.py fields.json` + +This checks for: +- Intersecting bounding boxes (which would cause overlapping text) +- Entry boxes that are too small for the specified font size + +Fix any reported errors in fields.json before proceeding. + +## Step 3: Fill the Form + +The fill script auto-detects the coordinate system and handles conversion: +`python scripts/fill_pdf_form_with_annotations.py <input.pdf> fields.json <output.pdf>` + +## Step 4: Verify Output + +Convert the filled PDF to images and verify text placement: +`python scripts/convert_pdf_to_images.py <output.pdf> <verify_images/>` + +If text is mispositioned: +- **Approach A**: Check that you're using PDF coordinates from form_structure.json with `pdf_width`/`pdf_height` +- **Approach B**: Check that image dimensions match and coordinates are accurate pixels +- **Hybrid**: Ensure coordinate conversions are correct for visually-estimated fields diff --git a/.claude/skills/pdf/reference.md b/.claude/skills/pdf/reference.md new file mode 100644 index 00000000..41400bf4 --- /dev/null +++ b/.claude/skills/pdf/reference.md @@ -0,0 +1,612 @@ +# PDF Processing Advanced Reference + +This document contains advanced PDF processing features, detailed examples, and additional libraries not covered in the main skill instructions. + +## pypdfium2 Library (Apache/BSD License) + +### Overview +pypdfium2 is a Python binding for PDFium (Chromium's PDF library). It's excellent for fast PDF rendering, image generation, and serves as a PyMuPDF replacement. + +### Render PDF to Images +```python +import pypdfium2 as pdfium +from PIL import Image + +# Load PDF +pdf = pdfium.PdfDocument("document.pdf") + +# Render page to image +page = pdf[0] # First page +bitmap = page.render( + scale=2.0, # Higher resolution + rotation=0 # No rotation +) + +# Convert to PIL Image +img = bitmap.to_pil() +img.save("page_1.png", "PNG") + +# Process multiple pages +for i, page in enumerate(pdf): + bitmap = page.render(scale=1.5) + img = bitmap.to_pil() + img.save(f"page_{i+1}.jpg", "JPEG", quality=90) +``` + +### Extract Text with pypdfium2 +```python +import pypdfium2 as pdfium + +pdf = pdfium.PdfDocument("document.pdf") +for i, page in enumerate(pdf): + text = page.get_text() + print(f"Page {i+1} text length: {len(text)} chars") +``` + +## JavaScript Libraries + +### pdf-lib (MIT License) + +pdf-lib is a powerful JavaScript library for creating and modifying PDF documents in any JavaScript environment. + +#### Load and Manipulate Existing PDF +```javascript +import { PDFDocument } from 'pdf-lib'; +import fs from 'fs'; + +async function manipulatePDF() { + // Load existing PDF + const existingPdfBytes = fs.readFileSync('input.pdf'); + const pdfDoc = await PDFDocument.load(existingPdfBytes); + + // Get page count + const pageCount = pdfDoc.getPageCount(); + console.log(`Document has ${pageCount} pages`); + + // Add new page + const newPage = pdfDoc.addPage([600, 400]); + newPage.drawText('Added by pdf-lib', { + x: 100, + y: 300, + size: 16 + }); + + // Save modified PDF + const pdfBytes = await pdfDoc.save(); + fs.writeFileSync('modified.pdf', pdfBytes); +} +``` + +#### Create Complex PDFs from Scratch +```javascript +import { PDFDocument, rgb, StandardFonts } from 'pdf-lib'; +import fs from 'fs'; + +async function createPDF() { + const pdfDoc = await PDFDocument.create(); + + // Add fonts + const helveticaFont = await pdfDoc.embedFont(StandardFonts.Helvetica); + const helveticaBold = await pdfDoc.embedFont(StandardFonts.HelveticaBold); + + // Add page + const page = pdfDoc.addPage([595, 842]); // A4 size + const { width, height } = page.getSize(); + + // Add text with styling + page.drawText('Invoice #12345', { + x: 50, + y: height - 50, + size: 18, + font: helveticaBold, + color: rgb(0.2, 0.2, 0.8) + }); + + // Add rectangle (header background) + page.drawRectangle({ + x: 40, + y: height - 100, + width: width - 80, + height: 30, + color: rgb(0.9, 0.9, 0.9) + }); + + // Add table-like content + const items = [ + ['Item', 'Qty', 'Price', 'Total'], + ['Widget', '2', '$50', '$100'], + ['Gadget', '1', '$75', '$75'] + ]; + + let yPos = height - 150; + items.forEach(row => { + let xPos = 50; + row.forEach(cell => { + page.drawText(cell, { + x: xPos, + y: yPos, + size: 12, + font: helveticaFont + }); + xPos += 120; + }); + yPos -= 25; + }); + + const pdfBytes = await pdfDoc.save(); + fs.writeFileSync('created.pdf', pdfBytes); +} +``` + +#### Advanced Merge and Split Operations +```javascript +import { PDFDocument } from 'pdf-lib'; +import fs from 'fs'; + +async function mergePDFs() { + // Create new document + const mergedPdf = await PDFDocument.create(); + + // Load source PDFs + const pdf1Bytes = fs.readFileSync('doc1.pdf'); + const pdf2Bytes = fs.readFileSync('doc2.pdf'); + + const pdf1 = await PDFDocument.load(pdf1Bytes); + const pdf2 = await PDFDocument.load(pdf2Bytes); + + // Copy pages from first PDF + const pdf1Pages = await mergedPdf.copyPages(pdf1, pdf1.getPageIndices()); + pdf1Pages.forEach(page => mergedPdf.addPage(page)); + + // Copy specific pages from second PDF (pages 0, 2, 4) + const pdf2Pages = await mergedPdf.copyPages(pdf2, [0, 2, 4]); + pdf2Pages.forEach(page => mergedPdf.addPage(page)); + + const mergedPdfBytes = await mergedPdf.save(); + fs.writeFileSync('merged.pdf', mergedPdfBytes); +} +``` + +### pdfjs-dist (Apache License) + +PDF.js is Mozilla's JavaScript library for rendering PDFs in the browser. + +#### Basic PDF Loading and Rendering +```javascript +import * as pdfjsLib from 'pdfjs-dist'; + +// Configure worker (important for performance) +pdfjsLib.GlobalWorkerOptions.workerSrc = './pdf.worker.js'; + +async function renderPDF() { + // Load PDF + const loadingTask = pdfjsLib.getDocument('document.pdf'); + const pdf = await loadingTask.promise; + + console.log(`Loaded PDF with ${pdf.numPages} pages`); + + // Get first page + const page = await pdf.getPage(1); + const viewport = page.getViewport({ scale: 1.5 }); + + // Render to canvas + const canvas = document.createElement('canvas'); + const context = canvas.getContext('2d'); + canvas.height = viewport.height; + canvas.width = viewport.width; + + const renderContext = { + canvasContext: context, + viewport: viewport + }; + + await page.render(renderContext).promise; + document.body.appendChild(canvas); +} +``` + +#### Extract Text with Coordinates +```javascript +import * as pdfjsLib from 'pdfjs-dist'; + +async function extractText() { + const loadingTask = pdfjsLib.getDocument('document.pdf'); + const pdf = await loadingTask.promise; + + let fullText = ''; + + // Extract text from all pages + for (let i = 1; i <= pdf.numPages; i++) { + const page = await pdf.getPage(i); + const textContent = await page.getTextContent(); + + const pageText = textContent.items + .map(item => item.str) + .join(' '); + + fullText += `\n--- Page ${i} ---\n${pageText}`; + + // Get text with coordinates for advanced processing + const textWithCoords = textContent.items.map(item => ({ + text: item.str, + x: item.transform[4], + y: item.transform[5], + width: item.width, + height: item.height + })); + } + + console.log(fullText); + return fullText; +} +``` + +#### Extract Annotations and Forms +```javascript +import * as pdfjsLib from 'pdfjs-dist'; + +async function extractAnnotations() { + const loadingTask = pdfjsLib.getDocument('annotated.pdf'); + const pdf = await loadingTask.promise; + + for (let i = 1; i <= pdf.numPages; i++) { + const page = await pdf.getPage(i); + const annotations = await page.getAnnotations(); + + annotations.forEach(annotation => { + console.log(`Annotation type: ${annotation.subtype}`); + console.log(`Content: ${annotation.contents}`); + console.log(`Coordinates: ${JSON.stringify(annotation.rect)}`); + }); + } +} +``` + +## Advanced Command-Line Operations + +### poppler-utils Advanced Features + +#### Extract Text with Bounding Box Coordinates +```bash +# Extract text with bounding box coordinates (essential for structured data) +pdftotext -bbox-layout document.pdf output.xml + +# The XML output contains precise coordinates for each text element +``` + +#### Advanced Image Conversion +```bash +# Convert to PNG images with specific resolution +pdftoppm -png -r 300 document.pdf output_prefix + +# Convert specific page range with high resolution +pdftoppm -png -r 600 -f 1 -l 3 document.pdf high_res_pages + +# Convert to JPEG with quality setting +pdftoppm -jpeg -jpegopt quality=85 -r 200 document.pdf jpeg_output +``` + +#### Extract Embedded Images +```bash +# Extract all embedded images with metadata +pdfimages -j -p document.pdf page_images + +# List image info without extracting +pdfimages -list document.pdf + +# Extract images in their original format +pdfimages -all document.pdf images/img +``` + +### qpdf Advanced Features + +#### Complex Page Manipulation +```bash +# Split PDF into groups of pages +qpdf --split-pages=3 input.pdf output_group_%02d.pdf + +# Extract specific pages with complex ranges +qpdf input.pdf --pages input.pdf 1,3-5,8,10-end -- extracted.pdf + +# Merge specific pages from multiple PDFs +qpdf --empty --pages doc1.pdf 1-3 doc2.pdf 5-7 doc3.pdf 2,4 -- combined.pdf +``` + +#### PDF Optimization and Repair +```bash +# Optimize PDF for web (linearize for streaming) +qpdf --linearize input.pdf optimized.pdf + +# Remove unused objects and compress +qpdf --optimize-level=all input.pdf compressed.pdf + +# Attempt to repair corrupted PDF structure +qpdf --check input.pdf +qpdf --fix-qdf damaged.pdf repaired.pdf + +# Show detailed PDF structure for debugging +qpdf --show-all-pages input.pdf > structure.txt +``` + +#### Advanced Encryption +```bash +# Add password protection with specific permissions +qpdf --encrypt user_pass owner_pass 256 --print=none --modify=none -- input.pdf encrypted.pdf + +# Check encryption status +qpdf --show-encryption encrypted.pdf + +# Remove password protection (requires password) +qpdf --password=secret123 --decrypt encrypted.pdf decrypted.pdf +``` + +## Advanced Python Techniques + +### pdfplumber Advanced Features + +#### Extract Text with Precise Coordinates +```python +import pdfplumber + +with pdfplumber.open("document.pdf") as pdf: + page = pdf.pages[0] + + # Extract all text with coordinates + chars = page.chars + for char in chars[:10]: # First 10 characters + print(f"Char: '{char['text']}' at x:{char['x0']:.1f} y:{char['y0']:.1f}") + + # Extract text by bounding box (left, top, right, bottom) + bbox_text = page.within_bbox((100, 100, 400, 200)).extract_text() +``` + +#### Advanced Table Extraction with Custom Settings +```python +import pdfplumber +import pandas as pd + +with pdfplumber.open("complex_table.pdf") as pdf: + page = pdf.pages[0] + + # Extract tables with custom settings for complex layouts + table_settings = { + "vertical_strategy": "lines", + "horizontal_strategy": "lines", + "snap_tolerance": 3, + "intersection_tolerance": 15 + } + tables = page.extract_tables(table_settings) + + # Visual debugging for table extraction + img = page.to_image(resolution=150) + img.save("debug_layout.png") +``` + +### reportlab Advanced Features + +#### Create Professional Reports with Tables +```python +from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph +from reportlab.lib.styles import getSampleStyleSheet +from reportlab.lib import colors + +# Sample data +data = [ + ['Product', 'Q1', 'Q2', 'Q3', 'Q4'], + ['Widgets', '120', '135', '142', '158'], + ['Gadgets', '85', '92', '98', '105'] +] + +# Create PDF with table +doc = SimpleDocTemplate("report.pdf") +elements = [] + +# Add title +styles = getSampleStyleSheet() +title = Paragraph("Quarterly Sales Report", styles['Title']) +elements.append(title) + +# Add table with advanced styling +table = Table(data) +table.setStyle(TableStyle([ + ('BACKGROUND', (0, 0), (-1, 0), colors.grey), + ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke), + ('ALIGN', (0, 0), (-1, -1), 'CENTER'), + ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'), + ('FONTSIZE', (0, 0), (-1, 0), 14), + ('BOTTOMPADDING', (0, 0), (-1, 0), 12), + ('BACKGROUND', (0, 1), (-1, -1), colors.beige), + ('GRID', (0, 0), (-1, -1), 1, colors.black) +])) +elements.append(table) + +doc.build(elements) +``` + +## Complex Workflows + +### Extract Figures/Images from PDF + +#### Method 1: Using pdfimages (fastest) +```bash +# Extract all images with original quality +pdfimages -all document.pdf images/img +``` + +#### Method 2: Using pypdfium2 + Image Processing +```python +import pypdfium2 as pdfium +from PIL import Image +import numpy as np + +def extract_figures(pdf_path, output_dir): + pdf = pdfium.PdfDocument(pdf_path) + + for page_num, page in enumerate(pdf): + # Render high-resolution page + bitmap = page.render(scale=3.0) + img = bitmap.to_pil() + + # Convert to numpy for processing + img_array = np.array(img) + + # Simple figure detection (non-white regions) + mask = np.any(img_array != [255, 255, 255], axis=2) + + # Find contours and extract bounding boxes + # (This is simplified - real implementation would need more sophisticated detection) + + # Save detected figures + # ... implementation depends on specific needs +``` + +### Batch PDF Processing with Error Handling +```python +import os +import glob +from pypdf import PdfReader, PdfWriter +import logging + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + +def batch_process_pdfs(input_dir, operation='merge'): + pdf_files = glob.glob(os.path.join(input_dir, "*.pdf")) + + if operation == 'merge': + writer = PdfWriter() + for pdf_file in pdf_files: + try: + reader = PdfReader(pdf_file) + for page in reader.pages: + writer.add_page(page) + logger.info(f"Processed: {pdf_file}") + except Exception as e: + logger.error(f"Failed to process {pdf_file}: {e}") + continue + + with open("batch_merged.pdf", "wb") as output: + writer.write(output) + + elif operation == 'extract_text': + for pdf_file in pdf_files: + try: + reader = PdfReader(pdf_file) + text = "" + for page in reader.pages: + text += page.extract_text() + + output_file = pdf_file.replace('.pdf', '.txt') + with open(output_file, 'w', encoding='utf-8') as f: + f.write(text) + logger.info(f"Extracted text from: {pdf_file}") + + except Exception as e: + logger.error(f"Failed to extract text from {pdf_file}: {e}") + continue +``` + +### Advanced PDF Cropping +```python +from pypdf import PdfWriter, PdfReader + +reader = PdfReader("input.pdf") +writer = PdfWriter() + +# Crop page (left, bottom, right, top in points) +page = reader.pages[0] +page.mediabox.left = 50 +page.mediabox.bottom = 50 +page.mediabox.right = 550 +page.mediabox.top = 750 + +writer.add_page(page) +with open("cropped.pdf", "wb") as output: + writer.write(output) +``` + +## Performance Optimization Tips + +### 1. For Large PDFs +- Use streaming approaches instead of loading entire PDF in memory +- Use `qpdf --split-pages` for splitting large files +- Process pages individually with pypdfium2 + +### 2. For Text Extraction +- `pdftotext -bbox-layout` is fastest for plain text extraction +- Use pdfplumber for structured data and tables +- Avoid `pypdf.extract_text()` for very large documents + +### 3. For Image Extraction +- `pdfimages` is much faster than rendering pages +- Use low resolution for previews, high resolution for final output + +### 4. For Form Filling +- pdf-lib maintains form structure better than most alternatives +- Pre-validate form fields before processing + +### 5. Memory Management +```python +# Process PDFs in chunks +def process_large_pdf(pdf_path, chunk_size=10): + reader = PdfReader(pdf_path) + total_pages = len(reader.pages) + + for start_idx in range(0, total_pages, chunk_size): + end_idx = min(start_idx + chunk_size, total_pages) + writer = PdfWriter() + + for i in range(start_idx, end_idx): + writer.add_page(reader.pages[i]) + + # Process chunk + with open(f"chunk_{start_idx//chunk_size}.pdf", "wb") as output: + writer.write(output) +``` + +## Troubleshooting Common Issues + +### Encrypted PDFs +```python +# Handle password-protected PDFs +from pypdf import PdfReader + +try: + reader = PdfReader("encrypted.pdf") + if reader.is_encrypted: + reader.decrypt("password") +except Exception as e: + print(f"Failed to decrypt: {e}") +``` + +### Corrupted PDFs +```bash +# Use qpdf to repair +qpdf --check corrupted.pdf +qpdf --replace-input corrupted.pdf +``` + +### Text Extraction Issues +```python +# Fallback to OCR for scanned PDFs +import pytesseract +from pdf2image import convert_from_path + +def extract_text_with_ocr(pdf_path): + images = convert_from_path(pdf_path) + text = "" + for i, image in enumerate(images): + text += pytesseract.image_to_string(image) + return text +``` + +## License Information + +- **pypdf**: BSD License +- **pdfplumber**: MIT License +- **pypdfium2**: Apache/BSD License +- **reportlab**: BSD License +- **poppler-utils**: GPL-2 License +- **qpdf**: Apache License +- **pdf-lib**: MIT License +- **pdfjs-dist**: Apache License \ No newline at end of file diff --git a/.claude/skills/pdf/scripts/check_bounding_boxes.py b/.claude/skills/pdf/scripts/check_bounding_boxes.py new file mode 100644 index 00000000..2cc5e348 --- /dev/null +++ b/.claude/skills/pdf/scripts/check_bounding_boxes.py @@ -0,0 +1,65 @@ +from dataclasses import dataclass +import json +import sys + + + + +@dataclass +class RectAndField: + rect: list[float] + rect_type: str + field: dict + + +def get_bounding_box_messages(fields_json_stream) -> list[str]: + messages = [] + fields = json.load(fields_json_stream) + messages.append(f"Read {len(fields['form_fields'])} fields") + + def rects_intersect(r1, r2): + disjoint_horizontal = r1[0] >= r2[2] or r1[2] <= r2[0] + disjoint_vertical = r1[1] >= r2[3] or r1[3] <= r2[1] + return not (disjoint_horizontal or disjoint_vertical) + + rects_and_fields = [] + for f in fields["form_fields"]: + rects_and_fields.append(RectAndField(f["label_bounding_box"], "label", f)) + rects_and_fields.append(RectAndField(f["entry_bounding_box"], "entry", f)) + + has_error = False + for i, ri in enumerate(rects_and_fields): + for j in range(i + 1, len(rects_and_fields)): + rj = rects_and_fields[j] + if ri.field["page_number"] == rj.field["page_number"] and rects_intersect(ri.rect, rj.rect): + has_error = True + if ri.field is rj.field: + messages.append(f"FAILURE: intersection between label and entry bounding boxes for `{ri.field['description']}` ({ri.rect}, {rj.rect})") + else: + messages.append(f"FAILURE: intersection between {ri.rect_type} bounding box for `{ri.field['description']}` ({ri.rect}) and {rj.rect_type} bounding box for `{rj.field['description']}` ({rj.rect})") + if len(messages) >= 20: + messages.append("Aborting further checks; fix bounding boxes and try again") + return messages + if ri.rect_type == "entry": + if "entry_text" in ri.field: + font_size = ri.field["entry_text"].get("font_size", 14) + entry_height = ri.rect[3] - ri.rect[1] + if entry_height < font_size: + has_error = True + messages.append(f"FAILURE: entry bounding box height ({entry_height}) for `{ri.field['description']}` is too short for the text content (font size: {font_size}). Increase the box height or decrease the font size.") + if len(messages) >= 20: + messages.append("Aborting further checks; fix bounding boxes and try again") + return messages + + if not has_error: + messages.append("SUCCESS: All bounding boxes are valid") + return messages + +if __name__ == "__main__": + if len(sys.argv) != 2: + print("Usage: check_bounding_boxes.py [fields.json]") + sys.exit(1) + with open(sys.argv[1]) as f: + messages = get_bounding_box_messages(f) + for msg in messages: + print(msg) diff --git a/.claude/skills/pdf/scripts/check_fillable_fields.py b/.claude/skills/pdf/scripts/check_fillable_fields.py new file mode 100644 index 00000000..36dfb951 --- /dev/null +++ b/.claude/skills/pdf/scripts/check_fillable_fields.py @@ -0,0 +1,11 @@ +import sys +from pypdf import PdfReader + + + + +reader = PdfReader(sys.argv[1]) +if (reader.get_fields()): + print("This PDF has fillable form fields") +else: + print("This PDF does not have fillable form fields; you will need to visually determine where to enter data") diff --git a/.claude/skills/pdf/scripts/convert_pdf_to_images.py b/.claude/skills/pdf/scripts/convert_pdf_to_images.py new file mode 100644 index 00000000..7939cef5 --- /dev/null +++ b/.claude/skills/pdf/scripts/convert_pdf_to_images.py @@ -0,0 +1,33 @@ +import os +import sys + +from pdf2image import convert_from_path + + + + +def convert(pdf_path, output_dir, max_dim=1000): + images = convert_from_path(pdf_path, dpi=200) + + for i, image in enumerate(images): + width, height = image.size + if width > max_dim or height > max_dim: + scale_factor = min(max_dim / width, max_dim / height) + new_width = int(width * scale_factor) + new_height = int(height * scale_factor) + image = image.resize((new_width, new_height)) + + image_path = os.path.join(output_dir, f"page_{i+1}.png") + image.save(image_path) + print(f"Saved page {i+1} as {image_path} (size: {image.size})") + + print(f"Converted {len(images)} pages to PNG images") + + +if __name__ == "__main__": + if len(sys.argv) != 3: + print("Usage: convert_pdf_to_images.py [input pdf] [output directory]") + sys.exit(1) + pdf_path = sys.argv[1] + output_directory = sys.argv[2] + convert(pdf_path, output_directory) diff --git a/.claude/skills/pdf/scripts/create_validation_image.py b/.claude/skills/pdf/scripts/create_validation_image.py new file mode 100644 index 00000000..10eadd81 --- /dev/null +++ b/.claude/skills/pdf/scripts/create_validation_image.py @@ -0,0 +1,37 @@ +import json +import sys + +from PIL import Image, ImageDraw + + + + +def create_validation_image(page_number, fields_json_path, input_path, output_path): + with open(fields_json_path, 'r') as f: + data = json.load(f) + + img = Image.open(input_path) + draw = ImageDraw.Draw(img) + num_boxes = 0 + + for field in data["form_fields"]: + if field["page_number"] == page_number: + entry_box = field['entry_bounding_box'] + label_box = field['label_bounding_box'] + draw.rectangle(entry_box, outline='red', width=2) + draw.rectangle(label_box, outline='blue', width=2) + num_boxes += 2 + + img.save(output_path) + print(f"Created validation image at {output_path} with {num_boxes} bounding boxes") + + +if __name__ == "__main__": + if len(sys.argv) != 5: + print("Usage: create_validation_image.py [page number] [fields.json file] [input image path] [output image path]") + sys.exit(1) + page_number = int(sys.argv[1]) + fields_json_path = sys.argv[2] + input_image_path = sys.argv[3] + output_image_path = sys.argv[4] + create_validation_image(page_number, fields_json_path, input_image_path, output_image_path) diff --git a/.claude/skills/pdf/scripts/extract_form_field_info.py b/.claude/skills/pdf/scripts/extract_form_field_info.py new file mode 100644 index 00000000..64cd4703 --- /dev/null +++ b/.claude/skills/pdf/scripts/extract_form_field_info.py @@ -0,0 +1,122 @@ +import json +import sys + +from pypdf import PdfReader + + + + +def get_full_annotation_field_id(annotation): + components = [] + while annotation: + field_name = annotation.get('/T') + if field_name: + components.append(field_name) + annotation = annotation.get('/Parent') + return ".".join(reversed(components)) if components else None + + +def make_field_dict(field, field_id): + field_dict = {"field_id": field_id} + ft = field.get('/FT') + if ft == "/Tx": + field_dict["type"] = "text" + elif ft == "/Btn": + field_dict["type"] = "checkbox" + states = field.get("/_States_", []) + if len(states) == 2: + if "/Off" in states: + field_dict["checked_value"] = states[0] if states[0] != "/Off" else states[1] + field_dict["unchecked_value"] = "/Off" + else: + print(f"Unexpected state values for checkbox `${field_id}`. Its checked and unchecked values may not be correct; if you're trying to check it, visually verify the results.") + field_dict["checked_value"] = states[0] + field_dict["unchecked_value"] = states[1] + elif ft == "/Ch": + field_dict["type"] = "choice" + states = field.get("/_States_", []) + field_dict["choice_options"] = [{ + "value": state[0], + "text": state[1], + } for state in states] + else: + field_dict["type"] = f"unknown ({ft})" + return field_dict + + +def get_field_info(reader: PdfReader): + fields = reader.get_fields() + + field_info_by_id = {} + possible_radio_names = set() + + for field_id, field in fields.items(): + if field.get("/Kids"): + if field.get("/FT") == "/Btn": + possible_radio_names.add(field_id) + continue + field_info_by_id[field_id] = make_field_dict(field, field_id) + + + radio_fields_by_id = {} + + for page_index, page in enumerate(reader.pages): + annotations = page.get('/Annots', []) + for ann in annotations: + field_id = get_full_annotation_field_id(ann) + if field_id in field_info_by_id: + field_info_by_id[field_id]["page"] = page_index + 1 + field_info_by_id[field_id]["rect"] = ann.get('/Rect') + elif field_id in possible_radio_names: + try: + on_values = [v for v in ann["/AP"]["/N"] if v != "/Off"] + except KeyError: + continue + if len(on_values) == 1: + rect = ann.get("/Rect") + if field_id not in radio_fields_by_id: + radio_fields_by_id[field_id] = { + "field_id": field_id, + "type": "radio_group", + "page": page_index + 1, + "radio_options": [], + } + radio_fields_by_id[field_id]["radio_options"].append({ + "value": on_values[0], + "rect": rect, + }) + + fields_with_location = [] + for field_info in field_info_by_id.values(): + if "page" in field_info: + fields_with_location.append(field_info) + else: + print(f"Unable to determine location for field id: {field_info.get('field_id')}, ignoring") + + def sort_key(f): + if "radio_options" in f: + rect = f["radio_options"][0]["rect"] or [0, 0, 0, 0] + else: + rect = f.get("rect") or [0, 0, 0, 0] + adjusted_position = [-rect[1], rect[0]] + return [f.get("page"), adjusted_position] + + sorted_fields = fields_with_location + list(radio_fields_by_id.values()) + sorted_fields.sort(key=sort_key) + + return sorted_fields + + +def write_field_info(pdf_path: str, json_output_path: str): + reader = PdfReader(pdf_path) + field_info = get_field_info(reader) + with open(json_output_path, "w") as f: + json.dump(field_info, f, indent=2) + print(f"Wrote {len(field_info)} fields to {json_output_path}") + + +if __name__ == "__main__": + if len(sys.argv) != 3: + print("Usage: extract_form_field_info.py [input pdf] [output json]") + sys.exit(1) + write_field_info(sys.argv[1], sys.argv[2]) diff --git a/.claude/skills/pdf/scripts/extract_form_structure.py b/.claude/skills/pdf/scripts/extract_form_structure.py new file mode 100755 index 00000000..f219e7d5 --- /dev/null +++ b/.claude/skills/pdf/scripts/extract_form_structure.py @@ -0,0 +1,115 @@ +""" +Extract form structure from a non-fillable PDF. + +This script analyzes the PDF to find: +- Text labels with their exact coordinates +- Horizontal lines (row boundaries) +- Checkboxes (small rectangles) + +Output: A JSON file with the form structure that can be used to generate +accurate field coordinates for filling. + +Usage: python extract_form_structure.py <input.pdf> <output.json> +""" + +import json +import sys +import pdfplumber + + +def extract_form_structure(pdf_path): + structure = { + "pages": [], + "labels": [], + "lines": [], + "checkboxes": [], + "row_boundaries": [] + } + + with pdfplumber.open(pdf_path) as pdf: + for page_num, page in enumerate(pdf.pages, 1): + structure["pages"].append({ + "page_number": page_num, + "width": float(page.width), + "height": float(page.height) + }) + + words = page.extract_words() + for word in words: + structure["labels"].append({ + "page": page_num, + "text": word["text"], + "x0": round(float(word["x0"]), 1), + "top": round(float(word["top"]), 1), + "x1": round(float(word["x1"]), 1), + "bottom": round(float(word["bottom"]), 1) + }) + + for line in page.lines: + if abs(float(line["x1"]) - float(line["x0"])) > page.width * 0.5: + structure["lines"].append({ + "page": page_num, + "y": round(float(line["top"]), 1), + "x0": round(float(line["x0"]), 1), + "x1": round(float(line["x1"]), 1) + }) + + for rect in page.rects: + width = float(rect["x1"]) - float(rect["x0"]) + height = float(rect["bottom"]) - float(rect["top"]) + if 5 <= width <= 15 and 5 <= height <= 15 and abs(width - height) < 2: + structure["checkboxes"].append({ + "page": page_num, + "x0": round(float(rect["x0"]), 1), + "top": round(float(rect["top"]), 1), + "x1": round(float(rect["x1"]), 1), + "bottom": round(float(rect["bottom"]), 1), + "center_x": round((float(rect["x0"]) + float(rect["x1"])) / 2, 1), + "center_y": round((float(rect["top"]) + float(rect["bottom"])) / 2, 1) + }) + + lines_by_page = {} + for line in structure["lines"]: + page = line["page"] + if page not in lines_by_page: + lines_by_page[page] = [] + lines_by_page[page].append(line["y"]) + + for page, y_coords in lines_by_page.items(): + y_coords = sorted(set(y_coords)) + for i in range(len(y_coords) - 1): + structure["row_boundaries"].append({ + "page": page, + "row_top": y_coords[i], + "row_bottom": y_coords[i + 1], + "row_height": round(y_coords[i + 1] - y_coords[i], 1) + }) + + return structure + + +def main(): + if len(sys.argv) != 3: + print("Usage: extract_form_structure.py <input.pdf> <output.json>") + sys.exit(1) + + pdf_path = sys.argv[1] + output_path = sys.argv[2] + + print(f"Extracting structure from {pdf_path}...") + structure = extract_form_structure(pdf_path) + + with open(output_path, "w") as f: + json.dump(structure, f, indent=2) + + print(f"Found:") + print(f" - {len(structure['pages'])} pages") + print(f" - {len(structure['labels'])} text labels") + print(f" - {len(structure['lines'])} horizontal lines") + print(f" - {len(structure['checkboxes'])} checkboxes") + print(f" - {len(structure['row_boundaries'])} row boundaries") + print(f"Saved to {output_path}") + + +if __name__ == "__main__": + main() diff --git a/.claude/skills/pdf/scripts/fill_fillable_fields.py b/.claude/skills/pdf/scripts/fill_fillable_fields.py new file mode 100644 index 00000000..51c2600f --- /dev/null +++ b/.claude/skills/pdf/scripts/fill_fillable_fields.py @@ -0,0 +1,98 @@ +import json +import sys + +from pypdf import PdfReader, PdfWriter + +from extract_form_field_info import get_field_info + + + + +def fill_pdf_fields(input_pdf_path: str, fields_json_path: str, output_pdf_path: str): + with open(fields_json_path) as f: + fields = json.load(f) + fields_by_page = {} + for field in fields: + if "value" in field: + field_id = field["field_id"] + page = field["page"] + if page not in fields_by_page: + fields_by_page[page] = {} + fields_by_page[page][field_id] = field["value"] + + reader = PdfReader(input_pdf_path) + + has_error = False + field_info = get_field_info(reader) + fields_by_ids = {f["field_id"]: f for f in field_info} + for field in fields: + existing_field = fields_by_ids.get(field["field_id"]) + if not existing_field: + has_error = True + print(f"ERROR: `{field['field_id']}` is not a valid field ID") + elif field["page"] != existing_field["page"]: + has_error = True + print(f"ERROR: Incorrect page number for `{field['field_id']}` (got {field['page']}, expected {existing_field['page']})") + else: + if "value" in field: + err = validation_error_for_field_value(existing_field, field["value"]) + if err: + print(err) + has_error = True + if has_error: + sys.exit(1) + + writer = PdfWriter(clone_from=reader) + for page, field_values in fields_by_page.items(): + writer.update_page_form_field_values(writer.pages[page - 1], field_values, auto_regenerate=False) + + writer.set_need_appearances_writer(True) + + with open(output_pdf_path, "wb") as f: + writer.write(f) + + +def validation_error_for_field_value(field_info, field_value): + field_type = field_info["type"] + field_id = field_info["field_id"] + if field_type == "checkbox": + checked_val = field_info["checked_value"] + unchecked_val = field_info["unchecked_value"] + if field_value != checked_val and field_value != unchecked_val: + return f'ERROR: Invalid value "{field_value}" for checkbox field "{field_id}". The checked value is "{checked_val}" and the unchecked value is "{unchecked_val}"' + elif field_type == "radio_group": + option_values = [opt["value"] for opt in field_info["radio_options"]] + if field_value not in option_values: + return f'ERROR: Invalid value "{field_value}" for radio group field "{field_id}". Valid values are: {option_values}' + elif field_type == "choice": + choice_values = [opt["value"] for opt in field_info["choice_options"]] + if field_value not in choice_values: + return f'ERROR: Invalid value "{field_value}" for choice field "{field_id}". Valid values are: {choice_values}' + return None + + +def monkeypatch_pydpf_method(): + from pypdf.generic import DictionaryObject + from pypdf.constants import FieldDictionaryAttributes + + original_get_inherited = DictionaryObject.get_inherited + + def patched_get_inherited(self, key: str, default = None): + result = original_get_inherited(self, key, default) + if key == FieldDictionaryAttributes.Opt: + if isinstance(result, list) and all(isinstance(v, list) and len(v) == 2 for v in result): + result = [r[0] for r in result] + return result + + DictionaryObject.get_inherited = patched_get_inherited + + +if __name__ == "__main__": + if len(sys.argv) != 4: + print("Usage: fill_fillable_fields.py [input pdf] [field_values.json] [output pdf]") + sys.exit(1) + monkeypatch_pydpf_method() + input_pdf = sys.argv[1] + fields_json = sys.argv[2] + output_pdf = sys.argv[3] + fill_pdf_fields(input_pdf, fields_json, output_pdf) diff --git a/.claude/skills/pdf/scripts/fill_pdf_form_with_annotations.py b/.claude/skills/pdf/scripts/fill_pdf_form_with_annotations.py new file mode 100644 index 00000000..b430069f --- /dev/null +++ b/.claude/skills/pdf/scripts/fill_pdf_form_with_annotations.py @@ -0,0 +1,107 @@ +import json +import sys + +from pypdf import PdfReader, PdfWriter +from pypdf.annotations import FreeText + + + + +def transform_from_image_coords(bbox, image_width, image_height, pdf_width, pdf_height): + x_scale = pdf_width / image_width + y_scale = pdf_height / image_height + + left = bbox[0] * x_scale + right = bbox[2] * x_scale + + top = pdf_height - (bbox[1] * y_scale) + bottom = pdf_height - (bbox[3] * y_scale) + + return left, bottom, right, top + + +def transform_from_pdf_coords(bbox, pdf_height): + left = bbox[0] + right = bbox[2] + + pypdf_top = pdf_height - bbox[1] + pypdf_bottom = pdf_height - bbox[3] + + return left, pypdf_bottom, right, pypdf_top + + +def fill_pdf_form(input_pdf_path, fields_json_path, output_pdf_path): + + with open(fields_json_path, "r") as f: + fields_data = json.load(f) + + reader = PdfReader(input_pdf_path) + writer = PdfWriter() + + writer.append(reader) + + pdf_dimensions = {} + for i, page in enumerate(reader.pages): + mediabox = page.mediabox + pdf_dimensions[i + 1] = [mediabox.width, mediabox.height] + + annotations = [] + for field in fields_data["form_fields"]: + page_num = field["page_number"] + + page_info = next(p for p in fields_data["pages"] if p["page_number"] == page_num) + pdf_width, pdf_height = pdf_dimensions[page_num] + + if "pdf_width" in page_info: + transformed_entry_box = transform_from_pdf_coords( + field["entry_bounding_box"], + float(pdf_height) + ) + else: + image_width = page_info["image_width"] + image_height = page_info["image_height"] + transformed_entry_box = transform_from_image_coords( + field["entry_bounding_box"], + image_width, image_height, + float(pdf_width), float(pdf_height) + ) + + if "entry_text" not in field or "text" not in field["entry_text"]: + continue + entry_text = field["entry_text"] + text = entry_text["text"] + if not text: + continue + + font_name = entry_text.get("font", "Arial") + font_size = str(entry_text.get("font_size", 14)) + "pt" + font_color = entry_text.get("font_color", "000000") + + annotation = FreeText( + text=text, + rect=transformed_entry_box, + font=font_name, + font_size=font_size, + font_color=font_color, + border_color=None, + background_color=None, + ) + annotations.append(annotation) + writer.add_annotation(page_number=page_num - 1, annotation=annotation) + + with open(output_pdf_path, "wb") as output: + writer.write(output) + + print(f"Successfully filled PDF form and saved to {output_pdf_path}") + print(f"Added {len(annotations)} text annotations") + + +if __name__ == "__main__": + if len(sys.argv) != 4: + print("Usage: fill_pdf_form_with_annotations.py [input pdf] [fields.json] [output pdf]") + sys.exit(1) + input_pdf = sys.argv[1] + fields_json = sys.argv[2] + output_pdf = sys.argv[3] + + fill_pdf_form(input_pdf, fields_json, output_pdf) diff --git a/.claude/skills/project-analyze/SKILL.md b/.claude/skills/project-analyze/SKILL.md new file mode 100644 index 00000000..ea73b2d5 --- /dev/null +++ b/.claude/skills/project-analyze/SKILL.md @@ -0,0 +1,73 @@ +--- +name: project-analyze +license: Apache-2.0 +metadata: + source: https://github.com/open-elements/claude-base + author: Open Elements +description: Analyze the current project and generate or update the project-specific documentation files (features, tech stack, structure, architecture). Use this skill when setting up claude-project-base in a new project, or when the project has changed significantly and the documentation needs to be refreshed. +--- + +# Analyze Project + +Scan the current project and generate or update the four project-specific documentation files that give Claude Code persistent context about the project. + +## Target Files + +All files live in `conventions/project-specific/` relative to this skill (at `../../conventions/project-specific/`): + +- `project-features.md` — Core features and user-facing capabilities +- `project-tech.md` — Languages, frameworks, libraries, databases, external services +- `project-structure.md` — Repository layout and directory structure +- `project-architecture.md` — Technical architecture, component interactions, data flow + +## Instructions + +### 1. Scan the project + +Explore the project systematically to gather information: + +- **Root files** — Read `README.md`, `package.json`, `pom.xml`, `build.gradle`, `docker-compose.yml`, `Dockerfile`s, `.sdkmanrc`, `.nvmrc`, and similar configuration files +- **Directory structure** — List top-level directories and key sub-directories to understand the layout +- **Source code** — Scan key entry points (main classes, app routers, index files) to understand what the application does +- **Dependencies** — Read dependency files (pom.xml, package.json, requirements.txt) to identify the tech stack +- **Existing documentation** — Read any existing docs, ADRs, or architecture notes +- **CI/CD** — Check `.github/workflows/` to understand the build and deployment pipeline + +### 2. Read existing project-specific files + +If the four target files already contain content (not just placeholder comments), read them first. The goal is to **update** them, not to start from scratch. Preserve any manually added details that are still accurate. + +### 3. Generate or update each file + +Write each file with concrete, factual content based on what was found. Follow these guidelines: + +**`project-features.md`:** +- Start with a 2–3 sentence overview of what the project is and who it is for +- List core features as bullet points with brief descriptions +- Focus on what the project *does*, not how it is built + +**`project-tech.md`:** +- List languages with versions (from .sdkmanrc, .nvmrc, pom.xml, package.json) +- List frameworks and their versions +- List build tools and package managers +- List databases, caches, message brokers, and external services +- List key libraries (logging, testing, ORM, etc.) + +**`project-structure.md`:** +- Show the repository layout as a tree diagram (top-level + one or two levels deep for important directories) +- Describe what each key directory contains +- Note where to find entry points, configuration, tests, and documentation + +**`project-architecture.md`:** +- Describe the main components and their responsibilities +- Explain how components communicate (REST, gRPC, message queues, JDBC, etc.) +- Include a Mermaid diagram showing the high-level architecture +- Note any important architectural decisions or patterns (e.g., event sourcing, CQRS, microservices) + +### 4. Present changes to the user + +Show a summary of what was found and what will be written. If the files already had content, highlight what changed. Ask the user to review before writing the files. + +### 5. Write the files + +After user confirmation, write all four files. Do not include HTML comments or placeholder text — only real content. diff --git a/.claude/skills/project-setup/SKILL.md b/.claude/skills/project-setup/SKILL.md new file mode 100644 index 00000000..4a0ff8ca --- /dev/null +++ b/.claude/skills/project-setup/SKILL.md @@ -0,0 +1,63 @@ +--- +name: project-setup +license: Apache-2.0 +metadata: + source: https://github.com/open-elements/claude-base + author: Open Elements +description: Set up, review, or update Open Elements projects (Java libraries, TypeScript libraries, Java backends, web frontends, or fullstack applications). Use this skill when the user wants to create a new project, review an existing project's structure against Open Elements conventions, or update a project to match current best practices. +--- + +# Open Elements Project Setup and Review + +This skill is designed to help with the setup and review of projects at Open Elements. +A project in that case is most often a GitHub repository that contains code for a library, backend, frontend or full application. +It provides guidance on project structure, best practices, and helps ensure that projects align with our standards and guidelines. +Whether you're setting up a new project or reviewing an existing one, this skill can provide valuable insights and recommendations. + +## Project types + +A project can be a Java library, a TypeScript library, a Java Backend (Spring Boot or Helidon SE based), a Web Frontend or a full application (containing 1-N back-ends and 1-N front-ends). +Depending on the project type, the skill will provide specific guidance on how to set up the project structure, what files and folders to include, and how to organize the code. + +## Instructions + +Before performing any review or setup task, **read all convention documents first** to have full knowledge of Open Elements standards. The docs are located relative to this skill at `../../conventions/`: + +1. Read all of the following files: + - `../../conventions/software-quality.md` — API design, technical integrity, namespace, SBOM, CI + - `../../conventions/repo-setup.md` — required root files (README, LICENSE, CoC, .gitignore) + - `../../conventions/documentation.md` — Markdown, MkDocs, GitHub Pages, ADRs + - `../../conventions/java.md` — Java conventions + - `../../conventions/typescript.md` — TypeScript conventions + - `../../conventions/backend.md` — Backend frameworks, REST/OpenAPI, database, observability + - `../../conventions/fullstack-architecture.md` — Frontend/backend separation, Docker, configuration, pinned tool versions + - `../../conventions/project-specific/README.md` — Project-specific docs (if any exist) + +2. Determine the project type (Java library, TypeScript library, Java backend, web frontend, or fullstack application). If the project type is not obvious from the existing codebase, **ask the user** which type they want. + +3. If the project includes a backend (Java backend or fullstack application), **ask the user** which backend framework to use: **Spring Boot** or **Helidon SE**. Do not assume a default — the user must make this choice explicitly. + +4. Based on the project type, apply only the relevant conventions: + - **All projects**: `software-quality.md`, `repo-setup.md`, `documentation.md` + - **Java projects**: additionally `java.md` + - **TypeScript projects**: additionally `typescript.md` + - **Backend projects**: additionally `backend.md`, `java.md` + - **Frontend projects**: additionally `typescript.md` + - **Fullstack projects**: additionally `fullstack-architecture.md`, `backend.md`, `java.md`, `typescript.md` + +5. When **reviewing** an existing project: compare the project structure, files, and conventions against the applicable docs. List what matches, what is missing, and what should be changed. + +6. When **setting up a new project**, create only a **minimal runnable skeleton** — no business logic, no entities, no feature code. The goal is a project that builds, starts, and can be verified with `docker-compose up --build`. Business logic and features are added later via `/spec-create` and `/spec-implement`. + + The skeleton includes: + - **Root**: `.editorconfig`, `.gitignore`, `LICENSE`, `.env.example`, `docker-compose.yml`, `README.md` + - **Backend**: `pom.xml` (with all required plugins and dependencies), Maven Wrapper, `Dockerfile`, `.dockerignore`, `.sdkmanrc`, application config, and a single main application class with one health/ping endpoint to verify the backend starts correctly + - **Frontend**: `package.json`, `next.config.ts`, `tailwind.config.ts`, `tsconfig.json`, `.nvmrc`, `Dockerfile`, `.dockerignore`, `public/favicon.ico`, and a single landing page that shows the project name and confirms the frontend is running. Apply the Open Elements Brand Guidelines (`../open-elements-brand-guidelines/SKILL.md`) and Frontend Design skill (`../frontend-design/SKILL.md`) for the landing page styling. + + **Do not create**: entities, DTOs, repositories, services, controllers (beyond the health endpoint), database migrations, multiple pages, or any business-logic code. + + **IMPORTANT — Avoid output limits and content filter issues**: Do not create all files in a single response. Split the file creation into sequential batches with **at most 2–3 files per batch**. Create each file individually if it is large (e.g., `pom.xml`). Additionally, **never combine credential-related files** (`.env.example`, `docker-compose.yml`, database config) with other files in the same batch — create them one at a time in separate responses to avoid triggering API content filters. After each batch, verify the files were created successfully before proceeding to the next batch. + +7. After creating all project files: If a `.env.example` exists and no `.env` file is present, **copy `.env.example` to `.env`** so the project is immediately runnable without manual configuration. + +8. After the skeleton is complete, verify it works by running `docker-compose up --build`. If errors occur, fix them before considering the setup done. diff --git a/.claude/skills/quality-review/SKILL.md b/.claude/skills/quality-review/SKILL.md new file mode 100644 index 00000000..8c70b088 --- /dev/null +++ b/.claude/skills/quality-review/SKILL.md @@ -0,0 +1,107 @@ +--- +name: quality-review +license: Apache-2.0 +metadata: + source: https://github.com/open-elements/claude-base + author: Open Elements +description: Review code changes for quality, conventions, and potential issues. Checks against the project's convention documents (code quality, security, language-specific rules, testing). Use this skill after implementing a feature or bug fix, or when reviewing someone else's code changes. +--- + +# Quality Review + +Review code changes for quality and convention compliance. Unlike `spec-review` (which checks completeness against a spec), this skill checks whether the code is well-written, secure, and follows project conventions. + +## Instructions + +### 1. Determine the scope + +Ask the user what to review. Options: + +- **Uncommitted changes** — run `git diff` and `git diff --staged` to see what changed +- **A branch or PR** — run `git diff main...HEAD` (or the appropriate base branch) to see all changes +- **Specific files** — the user points to files or directories to review + +Read all changed files completely — diffs alone are not enough to judge quality, since context matters. + +### 2. Load the relevant conventions + +Read the convention documents that apply to the project. Determine which are relevant based on the languages and files in the changeset: + +- Always read `../../conventions/software-quality.md` — applies to all projects +- For Java files: read `../../conventions/java.md` +- For TypeScript files: read `../../conventions/typescript.md` +- For backend code: read `../../conventions/backend.md` +- For security-sensitive changes: read `../../conventions/security.md` + +Also read the project's `CLAUDE.md` for any project-specific rules. + +### 3. Review the code + +Check each changed file against the applicable conventions. Focus on these areas: + +**Code quality:** +- DRY — Is there duplicated logic that should be extracted? +- KISS — Are there overly complex solutions where simpler ones would work? +- Dead code — Unused imports, unreachable branches, commented-out code? +- Naming — Are variables, functions, and classes named meaningfully? +- Focus — Does each function/method do one thing well? +- Unnecessary code — Is there code added "for future use" that is not needed yet? + +**Security:** +- Are secrets, keys, or tokens hardcoded? +- Is user input validated and sanitized? +- Are database queries parameterized? +- Are there new dependencies with known vulnerabilities? + +**Testing:** +- Do new features and bug fixes have corresponding tests? +- Are tests deterministic and clearly named? +- Do tests cover edge cases and error scenarios? +- Are assertions specific with clear failure messages? + +**Language-specific conventions:** +- Apply the rules from the relevant language doc (java.md, typescript.md) +- Check for language-specific anti-patterns (e.g., wildcard imports in Java, `any` type in TypeScript) + +**Architecture:** +- Does the change respect existing patterns in the codebase? +- Are public APIs well-designed and encapsulated? +- Are there unintended breaking changes? + +### 4. Report + +Present the findings grouped by severity: + +```markdown +## Critical + +Issues that must be fixed before merging (security vulnerabilities, data loss risks, broken functionality). + +## Improvements + +Issues that should be fixed (convention violations, code quality concerns, missing tests). + +## Suggestions + +Optional improvements (simplification opportunities, better naming, minor refactors). + +## Positive + +Things done well (good test coverage, clean abstractions, thoughtful error handling). +``` + +For each finding: +- Reference the specific file and line +- Explain **what** the issue is and **why** it matters +- Suggest a concrete fix where possible + +Always include the "Positive" section — a review that only lists problems is demoralizing and incomplete. + +### 5. Discuss with the user + +Walk through the findings. For each issue, the user may: +- Agree and want it fixed — offer to make the change +- Disagree — discuss the reasoning, update conventions if the rule is wrong +- Defer — acknowledge it as known technical debt + +Do not make changes without the user's agreement. diff --git a/.claude/skills/spec-create/SKILL.md b/.claude/skills/spec-create/SKILL.md new file mode 100644 index 00000000..80858aef --- /dev/null +++ b/.claude/skills/spec-create/SKILL.md @@ -0,0 +1,103 @@ +--- +name: spec-create +license: Apache-2.0 +metadata: + source: https://github.com/open-elements/claude-base + author: Open Elements +description: Plan a feature or bug fix by creating a structured specification. Starts from a GitHub issue or a description, produces a design document and behavioral scenarios (given-when-then) through interactive discussion. Use this skill when the user wants to plan a new feature, fix a complex bug, or define the technical approach for a ticket before implementation. +--- + +# Create Specification + +Plan a feature or bug fix collaboratively. Produces a `design.md` (technical design) and a `behaviors.md` (behavioral scenarios in given-when-then format) in a dedicated spec folder. + +Before starting, read `../../conventions/spec-driven-development.md` for the full spec folder structure, file formats, and conventions. + +## Instructions + +### 1. Gather the input + +Accept one of the following as starting point: +- A **GitHub issue URL** — fetch the issue details using `gh issue view`. + If `gh` is not available, use `WebFetch` to retrieve the issue content from the URL instead. +- A **free-text description** from the user + +**If no GitHub issue exists yet:** Every feature or bug fix should be tracked by a GitHub issue — there should be no PR without a corresponding issue. Before proceeding with the spec, offer to help the user draft a GitHub issue first. Write a suggested issue title and body (with description, context, and acceptance criteria) that the user can review, adjust, and create on GitHub themselves. **Do not create the issue on GitHub** — the user does that. Once the issue exists, continue with the spec using the issue as the starting point. + +**Important:** A GitHub issue is a starting point, not a complete specification. Issues are often vague, incomplete, or written from a user perspective without technical detail. Always discuss the requirement with the user — ask clarifying questions about intended behavior, affected components, constraints, and acceptance criteria before moving on. Do not assume the issue text is sufficient. + +Summarize the requirement back to the user in 2–3 sentences to confirm understanding. + +Then ask the user: **"Do you want to get grilled on this before we continue? This will stress-test your understanding of the problem — surfacing hidden assumptions, missing requirements, and blind spots — before we commit to a design."** + +If the user says yes, invoke `/grill-me` with the gathered requirement as input. The grill session will systematically challenge the user's thinking. Once the grill session concludes, incorporate the resolved decisions and clarifications into the spec work and continue with step 2. + +### 2. Evaluate scope + +Assess whether the task is realistically completable in a few hours of focused work. Consider: +- Number of components/files affected +- New APIs, database changes, or infrastructure needed +- Cross-cutting concerns (auth, migrations, etc.) + +If the scope is too large, **propose splitting** it into smaller, independently deliverable tasks. Each sub-task should be viable on its own. + +For each proposed sub-task, draft a GitHub issue title and description (in Markdown) that the user can copy into GitHub. Include: +- A clear title +- A short description of the sub-task +- Acceptance criteria +- A reference to the original issue (if one exists) + +Present the drafted issues to the user for review and adjustment. **Do not create issues on GitHub** — the user will do that themselves. Once the issues are created, the user can start a new `/spec-create` for any of them. + +### 3. Create the spec folder + +Create the spec folder under `specs/` following the naming convention from the spec-driven development doc. + +### 4. Write `design.md` — Interactive planning + +Enter plan mode to discuss the technical design with the user. The goal is to produce a `design.md` following the structure defined in the spec-driven development doc. + +Not every section is needed for every task — adapt the content to the type of change: + +**For all designs**, consider **GDPR (DSGVO) compliance**: If the feature involves personal data (user input, profiles, tracking, analytics, etc.), the design must address data minimization, legal basis for processing, data subject rights (access, rectification, erasure, portability), and retention/deletion strategy. Add a dedicated section in the design doc when personal data is affected. + +**For features with UI components**, the design must reference the Open Elements Brand Guidelines (colors, typography, logo) and the Frontend Design skill for design quality. Note in the design doc which brand colors, fonts, and assets will be used. + +**For features**, the full design structure applies: Summary, Goals, Non-goals, Technical approach, API design, Data model, Key flows, etc. + +**For bug fixes**, the design focuses on different priorities: +- **Summary** — What is broken and what is the user-visible impact +- **Reproduction** — Steps to reproduce the bug, including preconditions and environment details +- **Root cause analysis** — Why the bug occurs, which component is responsible, and what the underlying issue is (not just the symptom) +- **Fix approach** — How the bug will be fixed, which files/components are affected, and why this approach is correct +- **Regression risk** — What could break as a side effect of the fix + +Keep bug fix designs lean — the goal is to understand the problem deeply before writing code, not to produce extensive documentation. + +For key design decisions (e.g., choice of technology, data model structure, API style, fix strategy), include a brief rationale explaining **why** this approach was chosen over alternatives. + +Where it helps clarity, use **Mermaid diagrams** — e.g., sequence diagrams for key flows, ER diagrams for data models, or component diagrams for architecture. Only add diagrams when they communicate better than text alone. + +Iterate with the user until both sides are confident the design is solid. Then write the file. + +### 5. Write `behaviors.md` — Behavioral scenarios + +Based on the finalized design, create `behaviors.md` with given-when-then scenarios following the format from the spec-driven development doc. + +Aim for comprehensive coverage: +- **Happy paths** — The main success scenarios +- **Edge cases** — Boundary values, empty inputs, concurrent access +- **Error cases** — Invalid input, missing permissions, downstream failures +- **State transitions** — Before/after states where relevant + +Each scenario should be specific enough that a developer can directly translate it into a test case. + +Review the scenarios with the user. Ask explicitly: "Are there edge cases or error scenarios we are missing?" + +### 6. Summary + +After both files are written, provide a short summary: +- Link to the created spec folder +- Count of behavioral scenarios +- Any open questions from the design +- Suggest next steps: implement manually, use `/spec-implement` for a step-by-step plan, or use `/spec-review` after implementation to verify completeness diff --git a/.claude/skills/spec-implement/SKILL.md b/.claude/skills/spec-implement/SKILL.md new file mode 100644 index 00000000..474a461f --- /dev/null +++ b/.claude/skills/spec-implement/SKILL.md @@ -0,0 +1,93 @@ +--- +name: spec-implement +license: Apache-2.0 +metadata: + source: https://github.com/open-elements/claude-base + author: Open Elements +description: Generate a concrete step-by-step implementation plan from a specification. Creates an ordered list of tasks that can be executed one by one, either manually by a developer or by Claude Code. Use this skill when you have a completed spec (design.md + behaviors.md) and want a clear roadmap for implementation. +--- + +# Create Implementation Plan + +Turn a completed specification into an ordered, actionable list of implementation steps. + +Before starting, read `../../conventions/spec-driven-development.md` for the full spec folder structure and file formats. + +## Instructions + +### 1. Load the spec + +Ask the user which spec to use, or detect it from context. Read both `design.md` and `behaviors.md` from the spec folder. + +Also read any relevant existing code that the implementation will modify or extend. Understand the current state of the codebase before planning changes. + +If the spec involves **frontend or UI work**, also read the **Open Elements Brand Guidelines** skill (`../open-elements-brand-guidelines/SKILL.md`) and the **Frontend Design** skill (`../frontend-design/SKILL.md`). All frontend implementation steps must reference and apply the brand colors, typography, and design quality standards. + +### 2. Break down into steps + +Create an ordered list of implementation steps. Each step should be: + +- **Atomic** — One focused change (a single file or a small group of closely related files) +- **Independently verifiable** — After completing the step, you can confirm it works (compiles, tests pass, behavior is observable) +- **Sequenced by dependency** — Earlier steps provide the foundation for later ones + +A typical ordering is: +1. Data model / entities / migrations +2. Core business logic / service layer +3. API endpoints / controllers +4. Integration with external services +5. Frontend / UI components (apply Open Elements Brand Guidelines and Frontend Design skill) +6. Unit tests for core logic +7. **Backend tests for all backend behavioral scenarios** — Every scenario in `behaviors.md` that describes backend behavior (API responses, data persistence, business logic, validation) must have a corresponding test (unit or integration). Map each given-when-then scenario to at least one test case. +8. **Frontend tests for all frontend behavioral scenarios** — Every scenario in `behaviors.md` that describes UI behavior (user interactions, form submissions, dialog flows, navigation, error displays, loading states) must have a corresponding frontend test (component test, integration test, or e2e test). This includes CRUD dialogs, form validation visible to the user, conditional UI elements, and any behavior the user can see or trigger. Frontend behaviors are not covered by backend tests — they require their own dedicated tests. +9. Edge case and error handling tests (both backend and frontend) +10. Documentation updates (if applicable) + +Adapt the ordering to the project and technology stack. + +**Important:** The implementation is not complete until every scenario in `behaviors.md` is covered by a passing test. This is a hard requirement, not a nice-to-have. When writing `steps.md`, explicitly assign each behavior scenario to a step so that none are missed. + +**Important:** Behavioral scenarios that describe what the user sees or does in the UI (e.g., "the user clicks save and sees a success message", "the dialog shows a validation error") are frontend scenarios. They must be tested with frontend tests — a passing backend API test does not verify that the UI actually works. If the project has no frontend test setup yet, the plan must include a step to set it up before the frontend test steps. + +### 3. Write the plan + +Write `steps.md` in the spec folder following the format from the spec-driven development doc. Use GitHub-flavored Markdown checkboxes (`- [ ]` / `- [x]`) for all changes and acceptance criteria so developers can track progress. + +For each step, include: +- **Step number and title** +- **Changes** — Concrete list of what to create or modify +- **Acceptance criteria** — How to verify the step is done. Every step must include acceptance criteria that the project builds successfully and that unit tests for any new code exist and pass. +- **Related behaviors** — Which scenarios from `behaviors.md` this step covers. Use the exact scenario names/IDs from `behaviors.md`. + +### 4. Verify full behavior coverage + +Before presenting the plan, cross-check: create a mapping of every scenario in `behaviors.md` to the step that tests it. Classify each scenario by layer (Backend, Frontend, or Both). If any scenario is not assigned to a step, add a step or extend an existing one. Present the coverage mapping to the user: + +```markdown +## Behavior Coverage + +| Scenario | Layer | Covered in Step | +|----------|-------|-----------------| +| ... | ... | ... | +``` + +Every row must have a step assigned. No gaps allowed. Scenarios classified as "Frontend" or "Both" must have a frontend test step — a backend-only test step is insufficient. Scenarios classified as "Both" need tests in both layers. + +### 5. Review with the user + +Present the plan and ask: +- Does the ordering make sense? +- Are any steps too large and should be split further? +- Are there steps missing? + +Adjust based on feedback. + +### 6. Execution options + +After the plan is finalized, explain the options to the user: + +- **Manual implementation** — The developer works through the steps on their own, using the plan as a guide. Ideal for learning and skill development. +- **Guided implementation** — The developer works through the steps and asks Claude Code for help on individual steps as needed. +- **Automated implementation** — Ask Claude Code to execute the steps one by one. The user reviews after each step before proceeding to the next. + +For automated execution: work through the steps sequentially. After completing each step, **update `steps.md`** by checking off the completed items (`- [ ]` → `- [x]`). Then briefly report what was done and confirm with the user before moving to the next step. Do not batch multiple steps without review. diff --git a/.claude/skills/spec-review/SKILL.md b/.claude/skills/spec-review/SKILL.md new file mode 100644 index 00000000..5dfa2109 --- /dev/null +++ b/.claude/skills/spec-review/SKILL.md @@ -0,0 +1,112 @@ +--- +name: spec-review +license: Apache-2.0 +metadata: + source: https://github.com/open-elements/claude-base + author: Open Elements +description: Review an implementation for completeness against its specification. Checks whether the design document and behavioral scenarios from a spec are fully covered by the actual code and tests. Use this skill after implementing a feature that was planned with spec-create. +--- + +# Review Implementation Against Specification + +Verify that an implementation fully satisfies its specification by checking the code against the design document and behavioral scenarios. + +Before starting, read `../../conventions/spec-driven-development.md` for the full spec folder structure and file formats. + +## Instructions + +### 1. Identify the spec + +Ask the user which spec to review, or detect it from context. Locate the spec folder under `specs/` and read both `design.md` and `behaviors.md` completely. + +### 2. Review against `design.md` + +Check the codebase for each element defined in the design: + +- **API design** — Are all endpoints/interfaces implemented with the correct signatures, status codes, and response shapes? +- **Data model** — Are all entities, fields, relationships, and migrations present? +- **Key flows** — Does the code implement the described execution paths? +- **Dependencies** — Are the specified libraries/services integrated correctly? +- **Security considerations** — Are the described security measures in place? + +For each item, classify it as: +- **Covered** — Fully implemented as designed +- **Partially covered** — Implemented but deviates from the design or is incomplete +- **Missing** — Not implemented at all +- **Intentionally skipped** — Not applicable (explain why) + +### 3. Review against `behaviors.md` + +For each given-when-then scenario: + +- Check if a corresponding **test exists** (unit test, integration test, or e2e test) +- Check if the **code behavior matches** the scenario even without a dedicated test +- Flag scenarios that are **not covered by any test** + +Classify each scenario as: +- **Tested** — A test directly covers this scenario +- **Implemented but untested** — The code handles this case but no test verifies it +- **Not implemented** — The behavior described in the scenario is missing from the code + +### 4. Report + +Present a structured report: + +```markdown +## Design Coverage + +| Design Element | Status | Notes | +|----------------|--------|-------| +| ... | ... | ... | + +## Behavior Coverage + +| Scenario | Status | Test Location | +|----------|--------|---------------| +| ... | ... | ... | + +## Summary + +- X of Y design elements covered +- X of Y behavioral scenarios tested +- X scenarios implemented but untested +- X scenarios not implemented + +## Recommended Actions + +1. ... +``` + +### 5. Review documentation freshness + +Check that documentation artifacts are up to date with the implementation: + +- **Code comments and Javadoc/JSDoc** — Do they reflect the current behavior? Flag comments that describe old logic, removed parameters, or outdated examples. +- **README and user-facing docs** — If the feature changes behavior visible to users or developers, are the relevant docs updated? +- **API documentation** — If endpoints or interfaces changed, are OpenAPI specs, Swagger annotations, or similar kept in sync? +- **Inline TODOs** — Flag any `TODO`, `FIXME`, or `HACK` comments left in the new code that should be resolved before merging. +- **Changelog / release notes** — If the project maintains a changelog, is there an entry for this change? + +Add a section to the report: + +```markdown +## Documentation + +| Item | Status | Notes | +|------|--------|-------| +| ... | ... | ... | +``` + +Classify each as: +- **Up to date** — Documentation matches the implementation +- **Outdated** — Documentation describes old behavior or is missing updates +- **Missing** — No documentation exists where it should + +### 6. Discuss with the user + +Walk through the findings. For missing or partially covered items, discuss whether they are: +- Oversights that need to be fixed +- Intentional deviations that should be reflected back in the spec +- Out of scope for the current iteration + +If the spec needs to be updated to reflect implementation decisions, offer to update `design.md` or `behaviors.md` accordingly. diff --git a/.claude/skills/support-and-care-info/SKILL.md b/.claude/skills/support-and-care-info/SKILL.md new file mode 100644 index 00000000..5bbd3d07 --- /dev/null +++ b/.claude/skills/support-and-care-info/SKILL.md @@ -0,0 +1,171 @@ +--- +name: support-and-care-info +license: Apache-2.0 +metadata: + source: https://github.com/open-elements/claude-base + author: Open Elements +description: Background information about Open Elements' Support & Care offering — professional maintenance and support for critical open-source Java components (JUnit, Apache Maven, Log4j, Commons, Eclipse Temurin). Use when generating content about Support & Care, Java OSS maintenance, CRA compliance for open-source dependencies, or when the user mentions open-source support services, Java supply chain security, or OSS stewardship. +--- + +# Support & Care + +## Logo + +The Support & Care logo is available in this skill's folder in three formats: + +- **Support & Care-01.svg** — SVG vector format (preferred) +- **Support & Care-01.png** — PNG with transparent background +- **Support & Care-01-w.png** — PNG white version for dark backgrounds + +## Overview + +Support & Care is Open Elements' core business offering: professional maintenance and support for critical open-source components in the Java ecosystem. Modern software consists of over 70% open-source components. Starting in 2027, the Cyber Resilience Act (CRA) makes manufacturers responsible for 100% of their software — including all OSS dependencies. + +Support & Care addresses this by providing continuous maintenance, monitoring, and proactive care for the foundational Java components that enterprises depend on. + +**Motto:** Open Source — aber richtig. / Open Source made right. + +## Supported Components + +### JUnit + +- Over 1 billion downloads per month +- Used by approximately 85% of all Java projects +- Foundation of modern quality assurance — enables automated, repeatable, continuous testing + +### Apache Log4j + +- Approximately 76% of all Java applications use Log4j for logging — more than any other logging tool +- Critical component for logging, monitoring, and error analysis +- The Log4Shell vulnerability (December 2021) demonstrated the risks of unmanaged base dependencies — a critical security flaw that was latently present in millions of software stacks worldwide. More information: https://www.bsi.bund.de/dok/log4j + +### Apache Maven + +- Over 75% of all Java projects use Maven for build and project management +- Approximately 2 billion downloads per year +- Fundamental part of modern software development + +### Apache Commons + +- One of the central utility library collections in the Java ecosystem +- Approximately 49% of Java developers actively use Apache Commons +- Modular collection (Commons Lang, IO, Collections, etc.) providing proven, reusable standard functions + +### Eclipse Temurin + +- One of the leading OpenJDK distributions worldwide +- Over 500,000 downloads per day +- TCK-certified, AQAvit-verified, community-supported Java runtime +- Runtime foundation for countless enterprise Java applications + +### What These Components Cover + +Together, these components form the foundation of the entire technical trust chain of Java applications: + +- **Build pipeline** — Apache Maven +- **Test strategy** — JUnit +- **Logging infrastructure** — Apache Log4j +- **Standard libraries** — Apache Commons +- **Java runtime** — Eclipse Temurin + +## Where Support & Care Fits + +Java applications can be structured into three vertical layers: + +1. **Application code** — Business logic, developed in-house +2. **Frameworks** — Spring Boot, Quarkus, Jakarta EE, etc. +3. **Base components** — Runtime, build tools, logging, testing, utilities + +The base components provide reusable infrastructure functionality but also carry the majority of technical risks: security vulnerabilities, transitive dependencies, and compliance responsibility. Support & Care targets this lowest layer directly — ensuring security, stability, and regulatory compliance at the foundation of the application. + +Framework support alone is not sufficient. The Log4Shell vulnerability showed that a critical flaw in a widely-used base library can have enormous global impact, even when framework updates and vendor advisories exist — because they often reach affected applications too late or not at all. + +## Services + +### Long Term Support (LTS) + +Continued support for the most important versions to better organize updates. + +### Security Updates & Bugfixes + +Timely information and notifications to ensure smooth and fast vulnerability remediation. + +### Documentation & Transparency + +Support with SBOM strategies and technical documentation — optionally provided in German or English. + +### Workshops & Consulting + +Direct exchange with maintainers and committers — available in German or English. + +### Regular Webinars & Status Updates + +Information on current security risks, important version changes, best-practice recommendations, and concrete impacts on the OSS supply chain. + +### Custom Builds & Tooling + +Tailored implementations directly from the maintainers. + +## Business Model + +Support & Care uses a transparent **cost-share model with strategic sponsorship**. This means: + +- Customers share the ongoing maintenance and improvement costs for the supported open-source components — openly, transparently, and measurably +- **Funds flow directly to the maintainers** of the projects. Instead of adding superficial support layers, the investment goes into the vitality of each project's core +- Customer requirements and priorities are actively integrated into the project roadmaps, so development directly reflects real enterprise needs + +### Proactive Communication + +Customers are proactively kept informed about: + +- Security warnings and new patches +- Planned API or major version changes +- Recommendations for version updates or dependency cleanups +- Trends and risks in the OSS ecosystem + +## CRA Compliance + +Open Elements acts as an **Open-Source Steward** with direct participation in developing best practices for regulatory compliance. + +Through the founding membership in the **Open Regulatory Compliance Working Group (ORC WG)** of the Eclipse Foundation, Open Elements works together with leading open-source foundations, major technology companies, and EU representatives on concrete specifications, recommendations, and practical guidelines for implementing CRA requirements. + +Support & Care helps with: + +- Significantly reducing patch times +- Systematic vulnerability monitoring +- Making updates predictably available +- Ensuring documentation and transparency +- Guaranteeing long-term maintainability +- Prospective support for CRA-compliant attestations for supported projects — based on best practices developed in the ORC WG + +See the `eclipse-info` skill (ORC WG section) for more details on the regulatory compliance work. + +## Subscription Models + +Support & Care offers three subscription tiers with varying levels of availability, compliance support, and SLA commitments. Contact Open Elements for details. + +## Why Open Elements + +Open Elements combines: + +- **Community proximity** — Board seat at Eclipse Foundation, Technical Advisory Board at Linux Foundation +- **Enterprise experience** — Working with organizations on critical Java infrastructure +- **Regulatory know-how** — Active involvement in CRA compliance (ORC WG) +- **Sustainable OSS funding** — Revenue from Support & Care flows directly into the supported open-source projects +- **Transparency** — Open, traceable, and measurable contributions + +Active contributions to critical OSS projects including Eclipse Adoptium, Jakarta EE, Apache Maven, and other key projects. See the `open-elements-info` skill for the full list of foundation memberships and roles. + +## Key Links + +| Resource | URL | +|----------|-----| +| Support & Care GitHub | https://github.com/support-and-care | +| Open Elements Website | https://open-elements.com | +| ORC WG | https://orcwg.org | +| BSI Log4Shell Info | https://www.bsi.bund.de/dok/log4j | + +## Sources for Statistics + +- JetBrains Developer Ecosystem Survey: https://www.jetbrains.com/lp/devecosystem-2021/java/ +- New Relic State of the Java Ecosystem 2024: https://newrelic.com/de/resources/report/2024-state-of-the-java-ecosystem diff --git a/.claude/skills/support-and-care-info/Support & Care-01-w.png b/.claude/skills/support-and-care-info/Support & Care-01-w.png new file mode 100644 index 00000000..aad2dd19 Binary files /dev/null and b/.claude/skills/support-and-care-info/Support & Care-01-w.png differ diff --git a/.claude/skills/support-and-care-info/Support & Care-01.png b/.claude/skills/support-and-care-info/Support & Care-01.png new file mode 100644 index 00000000..b14f1efb Binary files /dev/null and b/.claude/skills/support-and-care-info/Support & Care-01.png differ diff --git a/.claude/skills/support-and-care-info/Support & Care-01.svg b/.claude/skills/support-and-care-info/Support & Care-01.svg new file mode 100644 index 00000000..831ad3cc --- /dev/null +++ b/.claude/skills/support-and-care-info/Support & Care-01.svg @@ -0,0 +1,62 @@ +<?xml version="1.0" encoding="UTF-8"?> +<svg id="Layer_1" xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 689.94 149.31"> + <!-- Generator: Adobe Illustrator 29.0.0, SVG Export Plug-In . SVG Version: 2.1.0 Build 186) --> + <defs> + <style> + .st0 { + fill: #5dba9f; + } + + .st1 { + fill: #9cd5fd; + } + + .st2 { + fill: #020144; + } + </style> + </defs> + <g> + <g> + <g> + <path class="st1" d="M8.1,79.54h25.3c-.62-2.75-.96-5.61-.96-8.55,0-2.62.26-5.18.76-7.65h-16.41c3.93-26.63,26.93-47.14,54.64-47.14,21.27,0,39.76,12.09,48.99,29.75.38.73,1.12,1.19,1.95,1.19h13.04c1.55,0,2.63-1.58,2.03-3.02C126.7,18.25,101.16,0,71.44,0,32.05,0,0,32.05,0,71.44c0,.95.02,1.89.06,2.82.12,2.94,2.52,5.28,5.47,5.28h2.58Z"/> + <path class="st1" d="M142.82,68.61c-.12-2.94-2.52-5.27-5.47-5.27h-2.68s-21.81,0-21.81,0h0s-.7,0-.7,0h-1.34c-.19,0-.38.05-.55.15l-12.12,7c-.74.43-.74,1.49,0,1.91l12.11,6.99c.17.1.36.15.55.15h5.15s10.11,0,10.11,0c-3.93,26.63-26.93,47.14-54.64,47.14-21.27,0-39.76-12.09-48.99-29.75-.38-.73-1.12-1.19-1.95-1.19H7.46c-1.55,0-2.63,1.58-2.03,3.02,10.75,25.88,36.29,44.12,66.01,44.12,39.39,0,71.44-32.05,71.44-71.44,0-.95-.02-1.89-.06-2.82Z"/> + </g> + <path class="st0" d="M71.44,88.95c-10.04,0-18.11-8.45-17.47-18.63.53-8.44,7.2-15.43,15.62-16.29s15.05,3.75,17.95,10.53c.8,1.86,3.06,2.59,4.81,1.58l17.38-10.03c1.57-.91,2.14-2.88,1.33-4.5-7.46-14.88-23.05-24.99-40.96-24.46-23.54.69-42.6,20.05-42.97,43.59-.39,24.8,19.6,45.02,44.31,45.02,17.34,0,32.34-9.96,39.62-24.47.81-1.62.24-3.6-1.33-4.5l-17.38-10.04c-1.76-1.02-4.02-.27-4.82,1.6-2.68,6.23-8.86,10.6-16.08,10.6Z"/> + </g> + <g> + <path class="st2" d="M193.32,55.74c-1.87-3.11-7-6.07-12.92-6.07-7.63,0-11.28,3.19-11.28,7.24,0,4.75,5.6,6.07,12.14,6.85,11.36,1.4,21.94,4.36,21.94,17.35,0,12.14-10.74,17.35-22.88,17.35-11.13,0-19.69-3.42-23.73-13.38l8.56-4.43c2.41,5.99,8.71,8.64,15.33,8.64s12.53-2.26,12.53-8.17c0-5.14-5.37-7.24-12.61-8.01-11.13-1.32-21.4-4.28-21.4-16.5,0-11.2,11.05-15.8,21.09-15.87,8.48,0,17.27,2.41,21.4,10.82l-8.17,4.2Z"/> + <path class="st2" d="M218.59,58.69v20.07c0,5.84,3.19,10.27,9.26,10.27s9.8-4.9,9.8-10.74v-19.61h9.41v38.44h-8.48l-.62-5.21c-3.97,3.89-7.63,5.76-12.99,5.76-9.18,0-15.87-6.92-15.87-18.83v-20.15h9.49Z"/> + <path class="st2" d="M254.19,113.08v-54.39h8.87l.62,5.29c2.96-4.28,8.09-6.15,12.45-6.15,11.83,0,19.69,8.79,19.69,20.08s-7.08,20.07-19.37,20.07c-4.05,0-10.04-1.24-12.76-5.45v20.54h-9.49ZM286.32,77.91c0-5.99-4.05-10.89-10.89-10.89s-10.89,4.9-10.89,10.89,4.43,10.89,10.89,10.89,10.89-4.9,10.89-10.89Z"/> + <path class="st2" d="M301.53,113.08v-54.39h8.87l.62,5.29c2.96-4.28,8.09-6.15,12.45-6.15,11.83,0,19.69,8.79,19.69,20.08s-7.08,20.07-19.37,20.07c-4.05,0-10.04-1.24-12.76-5.45v20.54h-9.49ZM333.67,77.91c0-5.99-4.05-10.89-10.89-10.89s-10.89,4.9-10.89,10.89,4.43,10.89,10.89,10.89,10.89-4.9,10.89-10.89Z"/> + <path class="st2" d="M388.29,77.91c0,11.05-7.55,20-20,20s-19.92-8.95-19.92-20,7.63-20,19.84-20,20.07,9.03,20.07,20ZM357.87,77.91c0,5.84,3.5,11.28,10.43,11.28s10.43-5.45,10.43-11.28-4.05-11.36-10.43-11.36c-6.85,0-10.43,5.6-10.43,11.36Z"/> + <path class="st2" d="M402.33,58.69l.7,4.44c2.96-4.75,6.93-5.45,10.82-5.45s7.78,1.56,9.88,3.66l-4.28,8.25c-1.95-1.63-3.73-2.49-6.85-2.49-4.98,0-9.57,2.65-9.57,9.73v20.23h-9.49v-38.36h8.79Z"/> + <path class="st2" d="M444.39,47.88v10.89h10.58v8.17h-10.66v16.57c0,3.66,2.02,5.45,4.98,5.45,1.48,0,3.19-.47,4.59-1.17l2.65,8.09c-2.72,1.09-4.98,1.56-7.86,1.63-8.33.31-13.77-4.43-13.77-14.01v-16.57h-7.16v-8.17h7.16v-4.89l9.49-6.01Z"/> + <path class="st2" d="M566.78,90.21c-5.6,5.52-12.84,8.09-20.7,8.09-20.23,0-28.79-13.93-28.87-28.09-.08-14.24,9.18-28.71,28.87-28.71,7.39,0,14.39,2.8,20,8.33l-6.85,6.61c-3.58-3.5-8.4-5.14-13.15-5.14-13.15,0-18.83,9.8-18.75,18.91.08,9.03,5.29,18.44,18.75,18.44,4.75,0,10.12-1.95,13.69-5.52l7,7.08Z"/> + <path class="st2" d="M601.27,58.69h9.1v38.36h-8.95l-.47-5.6c-2.18,4.51-8.17,6.69-12.45,6.77-11.36.08-19.76-6.93-19.76-20.39s8.79-20.15,20-20.08c5.14,0,10.04,2.41,12.22,6.22l.31-5.29ZM578.24,77.84c0,7.31,5.06,11.67,11.36,11.67,14.94,0,14.94-23.27,0-23.27-6.3,0-11.36,4.28-11.36,11.59Z"/> + <path class="st2" d="M625.25,58.69l.7,4.44c2.96-4.75,6.93-5.45,10.82-5.45s7.78,1.56,9.88,3.66l-4.28,8.25c-1.95-1.63-3.73-2.49-6.85-2.49-4.98,0-9.57,2.65-9.57,9.73v20.23h-9.49v-38.36h8.79Z"/> + <path class="st2" d="M658.32,81.26c.62,4.75,4.75,8.17,11.44,8.17,3.5,0,8.09-1.32,10.27-3.58l6.07,5.99c-4.05,4.2-10.66,6.22-16.5,6.22-13.23,0-21.09-8.17-21.09-20.46s7.94-20.07,20.39-20.07,20.85,7.94,19.37,23.73h-29.96ZM679.17,73.4c-.62-4.98-4.51-7.47-9.96-7.47-5.14,0-9.34,2.49-10.74,7.47h20.7Z"/> + </g> + </g> + <g> + <path class="st2" d="M398.34,126.27c.79-1.06,1.71-1.9,2.76-2.51,1.05-.61,2.27-.92,3.67-.92,1.09,0,2.06.2,2.92.6.86.4,1.59.97,2.19,1.72s1.06,1.67,1.37,2.77c.31,1.1.47,2.34.47,3.73,0,1.46-.18,2.8-.53,4-.35,1.2-.86,2.23-1.53,3.09-.67.85-1.49,1.51-2.46,1.98-.97.47-2.08.7-3.32.7s-2.38-.25-3.28-.74-1.68-1.22-2.33-2.19l-.13,2.23c-.04.3-.2.45-.49.45h-1.05v-26.41h1.74v11.49ZM398.34,137.25c.7,1.04,1.47,1.77,2.31,2.19.84.42,1.79.63,2.84.63s2.02-.19,2.82-.58c.8-.39,1.48-.94,2.02-1.66.54-.72.94-1.59,1.21-2.62.27-1.03.4-2.18.4-3.47,0-2.49-.5-4.37-1.49-5.63-.99-1.26-2.38-1.89-4.18-1.89-1.28,0-2.4.31-3.36.93-.96.62-1.82,1.48-2.58,2.58v9.53Z"/> + <path class="st2" d="M430.78,123.13l-10.38,23.87c-.07.17-.17.31-.28.42-.12.11-.28.16-.5.16h-1.23l3.18-7.06-7.64-17.39h1.43c.18,0,.33.05.44.14.11.09.18.19.22.3l6.08,14.05c.07.18.14.37.19.55.05.19.11.38.15.57.06-.19.12-.38.19-.57.07-.19.14-.37.21-.55l6.01-14.05c.06-.13.15-.24.25-.32.11-.08.23-.12.36-.12h1.33Z"/> + <g> + <path class="st2" d="M465.12,129.08c-.07,6.63-4.14,13.26-13.15,13.26s-13.19-6.49-13.19-13.23,4.32-13.52,13.19-13.52,13.23,6.78,13.15,13.48ZM443.54,129.19c.11,4.21,2.38,8.72,8.43,8.72s8.32-4.54,8.39-8.76c.07-4.32-2.35-9.16-8.39-9.16s-8.54,4.87-8.43,9.2Z"/> + <path class="st2" d="M468.34,149.31v-25.61h4.18l.29,2.49c1.39-2.02,3.81-2.89,5.86-2.89,5.57,0,9.27,4.14,9.27,9.45s-3.33,9.45-9.12,9.45c-1.91,0-4.73-.59-6.01-2.57v9.67h-4.47ZM483.47,132.75c0-2.82-1.91-5.13-5.13-5.13s-5.13,2.31-5.13,5.13,2.09,5.13,5.13,5.13,5.13-2.31,5.13-5.13Z"/> + <path class="st2" d="M495.05,134.32c.29,2.24,2.24,3.85,5.39,3.85,1.65,0,3.81-.62,4.84-1.69l2.86,2.82c-1.91,1.98-5.02,2.93-7.77,2.93-6.23,0-9.93-3.85-9.93-9.64s3.74-9.45,9.6-9.45,9.82,3.74,9.12,11.18h-14.11ZM504.87,130.62c-.29-2.35-2.13-3.52-4.69-3.52-2.42,0-4.4,1.17-5.06,3.52h9.75Z"/> + <path class="st2" d="M525.9,141.76v-9.45c0-2.75-1.5-4.84-4.36-4.84s-4.62,2.31-4.62,5.06v9.23h-4.43v-18.1h3.99l.29,2.46c1.83-1.8,3.66-2.71,5.94-2.71,4.25,0,7.66,3.19,7.66,8.87v9.49h-4.47Z"/> + <rect class="st2" x="535.1" y="116.11" width="17.7" height="1.87"/> + <polygon class="st2" points="535.1 139.83 535.1 141.76 553.23 141.76 553.23 139.85 535.1 139.83"/> + <polygon class="st2" points="552.06 129.74 552.06 127.95 535.1 127.93 535.1 129.74 552.06 129.74"/> + <path class="st2" d="M559.06,116.11v25.65h-1.8v-25.65h1.8Z"/> + <path class="st2" d="M563.05,132.71c0-5.42,4.1-9.34,9.2-9.34s9.64,3.11,8.94,10.19h-16.31c.37,4.25,3.63,6.71,7.37,6.71,2.38,0,5.17-.95,6.52-2.75l1.28,1.03c-1.76,2.31-4.91,3.48-7.8,3.48-5.09,0-9.2-3.55-9.2-9.31ZM579.58,131.98c-.04-4.47-2.97-6.96-7.33-6.96-3.74,0-6.96,2.53-7.37,6.96h14.69Z"/> + <path class="st2" d="M612.3,141.76v-10.85c0-3.48-2.35-5.94-5.79-5.94s-5.83,2.57-5.83,6.05v10.74h-1.8v-10.74c0-3.48-2.38-6.01-5.83-6.01s-5.79,2.53-5.79,6.01v10.74h-1.8v-18.1h1.69l.04,3c1.25-2.38,3.55-3.37,5.9-3.37,2.75,0,5.64,1.25,6.71,4.47,1.1-2.97,3.92-4.47,6.71-4.47,4.43,0,7.58,3.11,7.58,7.62v10.85h-1.8Z"/> + <path class="st2" d="M618.12,132.71c0-5.42,4.1-9.34,9.2-9.34s9.64,3.11,8.94,10.19h-16.31c.37,4.25,3.63,6.71,7.37,6.71,2.38,0,5.17-.95,6.52-2.75l1.28,1.03c-1.76,2.31-4.91,3.48-7.8,3.48-5.09,0-9.2-3.55-9.2-9.31ZM634.64,131.98c-.04-4.47-2.97-6.96-7.33-6.96-3.74,0-6.96,2.53-7.37,6.96h14.69Z"/> + <path class="st2" d="M642.66,123.66v3.22c1.39-2.49,3.92-3.52,6.45-3.55,4.84,0,8.17,2.97,8.17,7.99v10.44h-1.8v-10.41c0-4.1-2.53-6.3-6.45-6.27-3.74.04-6.34,2.86-6.34,6.6v10.08h-1.8v-18.1h1.76Z"/> + <path class="st2" d="M665.34,118.2v5.46h6.16v1.5h-6.16v11.03c0,2.45.51,4.18,3.33,4.18.88,0,1.87-.29,2.78-.73l.62,1.47c-1.14.55-2.27.92-3.41.92-3.85,0-5.09-2.27-5.09-5.83v-11.03h-3.85v-1.5h3.85v-5.28l1.76-.18Z"/> + <path class="st2" d="M688.06,126.96c-1.83-1.61-3.63-1.91-5.64-1.91-2.82-.04-5.53,1.03-5.46,3.33.07,2.42,3.22,2.89,5.5,3.3,3.22.55,7.66,1.1,7.48,5.31-.11,3.99-4.25,5.06-7.44,5.06s-6.34-1.21-7.92-3.63l1.32-1.17c1.5,2.16,4.21,3.08,6.63,3.08,2.2,0,5.53-.59,5.64-3.44.07-2.6-2.93-3.11-5.9-3.59-3.52-.59-7-1.25-7.04-4.87-.04-3.55,3.52-5.09,7.18-5.06,2.64,0,4.95.73,6.74,2.42l-1.1,1.17Z"/> + </g> + </g> + <path class="st2" d="M517.26,97.66h-3.57c-.48,0-.88-.05-1.18-.16-.31-.11-.66-.35-1.06-.72l-8.23-8.07c-1.18,1.39-2.49,2.67-3.93,3.83-1.44,1.16-3.01,2.17-4.69,3.03-1.69.86-3.49,1.52-5.42,2.01s-3.95.72-6.06.72-3.99-.33-5.94-1c-1.95-.67-3.7-1.65-5.24-2.95-1.54-1.3-2.78-2.89-3.73-4.77-.95-1.89-1.42-4.03-1.42-6.44,0-1.93.35-3.77,1.04-5.52.7-1.75,1.64-3.36,2.85-4.81,1.2-1.46,2.63-2.76,4.29-3.91,1.66-1.15,3.45-2.09,5.38-2.81-1.93-2.17-3.36-4.25-4.29-6.26-.94-2.01-1.4-4.16-1.4-6.46,0-1.87.34-3.6,1.02-5.2.68-1.59,1.65-2.98,2.91-4.15,1.26-1.18,2.76-2.1,4.51-2.77,1.75-.67,3.71-1,5.88-1,1.79,0,3.49.31,5.1.92,1.6.62,3,1.44,4.19,2.49,1.19,1.04,2.14,2.25,2.85,3.63.71,1.38,1.09,2.82,1.14,4.31l-2.17.44c-.27.05-.52,0-.74-.14-.23-.15-.41-.41-.54-.78-.13-.72-.42-1.54-.86-2.45-.44-.91-1.06-1.77-1.87-2.57-.8-.8-1.79-1.48-2.97-2.03-1.18-.55-2.55-.82-4.13-.82s-3.06.25-4.37.74c-1.31.5-2.43,1.19-3.37,2.09-.94.9-1.67,1.96-2.19,3.19-.52,1.23-.78,2.58-.78,4.05,0,2.19.56,4.29,1.69,6.3,1.12,2.01,2.86,4.16,5.22,6.46l17.94,17.62c1.2-1.93,2.15-3.93,2.85-6,.7-2.07,1.15-4.09,1.36-6.04.05-.35.16-.62.32-.82.16-.2.4-.3.72-.3h2.21c-.05,2.51-.52,5.1-1.4,7.76-.88,2.66-2.15,5.21-3.81,7.64l11.92,11.72ZM482.19,68.04c-1.77.72-3.36,1.6-4.8,2.65-1.43,1.04-2.64,2.21-3.63,3.49-.99,1.28-1.75,2.66-2.29,4.13-.54,1.47-.8,3-.8,4.57,0,2.06.39,3.85,1.18,5.38.79,1.52,1.81,2.8,3.07,3.83,1.26,1.03,2.65,1.8,4.19,2.31,1.54.51,3.06.76,4.55.76,1.9,0,3.68-.21,5.36-.64,1.67-.43,3.23-1.02,4.67-1.79,1.44-.76,2.78-1.67,4.01-2.73,1.23-1.06,2.34-2.2,3.33-3.43l-18.42-18.1-.44-.44Z"/> +</svg> \ No newline at end of file diff --git a/.claude/skills/update-claude-base/SKILL.md b/.claude/skills/update-claude-base/SKILL.md new file mode 100644 index 00000000..13bdfa31 --- /dev/null +++ b/.claude/skills/update-claude-base/SKILL.md @@ -0,0 +1,41 @@ +--- +name: update-claude-base +license: Apache-2.0 +metadata: + source: https://github.com/open-elements/claude-base + author: Open Elements +description: Update the claude-project-base directory with the latest shared conventions and skills from the upstream repository, without overwriting project-specific customizations. +--- + +# Update Claude Base + +Updates the `claude-project-base/` directory in the current project with the latest version from the upstream repository, preserving all project-specific content. + +## Instructions + +1. Locate the `claude-project-base/` directory in the project root. If it does not exist, inform the user and stop. + +2. Clone the latest version of the upstream repository into a temporary directory: + ```bash + tmp_dir=$(mktemp -d) + git clone --depth 1 https://github.com/OpenElementsLabs/claude-base.git "$tmp_dir" + ``` + +3. Before updating, show the user a summary of what will be updated by comparing the current `claude-project-base/` with the upstream `claude-project-base/`: + - List files that will be added (new upstream files) + - List files that will be updated (changed upstream files) + - List files that will be removed (deleted upstream files) + - Explicitly note that `conventions/project-specific/` will NOT be touched + +4. Ask the user for confirmation before proceeding. + +5. Update all shared files by syncing from the temporary clone's `claude-project-base/` to the project's `claude-project-base/`, with these exclusions: + - **Do NOT overwrite or delete** anything inside `conventions/project-specific/` — this directory contains project-specific content + - **Do NOT overwrite or delete** any skills that do not exist in the upstream repository — these are project-specific skills + +6. Clean up the temporary directory: + ```bash + rm -rf "$tmp_dir" + ``` + +7. Show the user a summary of what was updated and remind them to review the changes with `git diff`. diff --git a/.claude/skills/web-accessibility/SKILL.md b/.claude/skills/web-accessibility/SKILL.md new file mode 100644 index 00000000..97d814ec --- /dev/null +++ b/.claude/skills/web-accessibility/SKILL.md @@ -0,0 +1,94 @@ +--- +name: web-accessibility +description: Audit and improve web accessibility following WCAG 2.1 guidelines. Use when the user mentions accessibility, a11y, ARIA, screen readers, keyboard navigation, color contrast, alt text, focus management, or accessible forms. Also use during front-end development to ensure accessible web experiences, or when reviewing HTML for accessibility compliance. +license: MIT +metadata: + source: https://github.com/addyosmani/web-quality-skills + author: Addy Osmani + modifications: Adapted for Open Elements projects +--- + +# Accessibility (a11y) for web developers + +Accessibility guidelines based on [WCAG 2.1](https://www.w3.org/TR/WCAG21/) +and [Lighthouse accessibility audits](https://developer.chrome.com/docs/lighthouse/accessibility/scoring). +The goal of this skill: make content usable by everyone, including people with disabilities. + +## WCAG Principles: POUR + +| Principle | Description | +|--------------------|---------------------------------------------------| +| **P**erceivable | Content can be perceived through different senses | +| **O**perable | Interface can be operated by all users | +| **U**nderstandable | Content and interface are understandable | +| **R**obust | Content works with assistive technologies | + +## Examples + +### Text alternatives + +**Images require alt text:** + +```html +<!-- ❌ Missing alt --> +<img src="chart.png"> + +<!-- ✅ Descriptive alt --> +<img src="chart.png" alt="Bar chart showing 40% increase in Q3 sales"> + +<!-- ✅ Decorative image (empty alt) --> +<img src="decorative-border.png" alt="" role="presentation"> + +<!-- ✅ Complex image with longer description --> +<figure> + <img src="infographic.png" alt="2024 market trends infographic" + aria-describedby="infographic-desc"> + <figcaption id="infographic-desc"> + <!-- Detailed description --> + </figcaption> +</figure> +``` + +**Icon buttons need accessible names:** + +```html +<!-- ❌ No accessible name --> +<button> + <svg><!-- menu icon --></svg> +</button> + +<!-- ✅ Using aria-label --> +<button aria-label="Open menu"> + <svg aria-hidden="true"><!-- menu icon --></svg> +</button> + +<!-- ✅ Using visually hidden text --> +<button> + <svg aria-hidden="true"><!-- menu icon --></svg> + <span class="visually-hidden">Open menu</span> +</button> +``` + +### Additonal examples + +more examples will be added soon. + +## Testing checklist + +### Automated testing with Lighthouse or axe-core + +```bash +# Lighthouse accessibility audit +npx lighthouse https://example.com --only-categories=accessibility + +# axe-core +npm install @axe-core/cli -g +axe https://example.com +``` + +## References + +- [WCAG 2.1 Quick Reference](https://www.w3.org/WAI/WCAG21/quickref/) +- [WAI-ARIA Authoring Practices](https://www.w3.org/WAI/ARIA/apg/) +- [Deque axe Rules](https://dequeuniversity.com/rules/axe/) +- [Web Quality Audit](../web-quality-audit/SKILL.md) \ No newline at end of file diff --git a/.claude/skills/web-frontend-builder/SKILL.md b/.claude/skills/web-frontend-builder/SKILL.md new file mode 100644 index 00000000..bc50c342 --- /dev/null +++ b/.claude/skills/web-frontend-builder/SKILL.md @@ -0,0 +1,170 @@ +--- +name: web-frontend-builder +license: Apache-2.0 +metadata: + source: https://github.com/open-elements/claude-base + author: Open Elements +description: Build and develop web frontend applications using the Open Elements tech stack (Next.js, React, TypeScript, Tailwind CSS, shadcn/ui, pnpm). Use when the user asks to create a new frontend project, add pages or components, set up routing, or develop features in a web application. Not for simple HTML snippets — use for real application development. +--- + +# Web Frontend Builder + +Build production-grade web frontend applications using the Open Elements tech stack. Follow these steps to create or extend a frontend project. + +**Stack**: Next.js + React 18 + TypeScript (strict) + Tailwind CSS + shadcn/ui + pnpm + +**IMPORTANT**: All conventions from `../../conventions/typescript.md` apply. When in doubt, defer to that document. + +## Design Guidelines + +For design direction and visual quality, apply the `frontend-design` skill. Key principles: + +- Every page and component must have a polished, professional appearance — even for early-stage projects. +- Use shadcn/ui components instead of bare HTML elements. +- Apply Open Elements brand colors and typography via the `open-elements-brand-guidelines` skill. +- Avoid generic AI aesthetics: no excessive centered layouts, purple gradients, uniform rounded corners, or default Inter font. + +## Creating a New Project + +### Step 1: Scaffold with Next.js + +```bash +pnpm create next-app <project-name> --typescript --tailwind --eslint --app --src-dir --import-alias "@/*" +cd <project-name> +``` + +### Step 2: Configure Next.js + +Edit `next.config.ts` to set standalone output (required for Docker deployments): + +```typescript +const nextConfig = { + output: 'standalone', +}; +``` + +### Step 3: Enable Strict TypeScript + +Verify `tsconfig.json` has `"strict": true`. This is non-negotiable. + +### Step 4: Initialize shadcn/ui + +```bash +pnpm dlx shadcn@latest init +``` + +When prompted, select the defaults that match the project's design direction. Then install the components needed: + +```bash +pnpm dlx shadcn@latest add button card input table dialog +``` + +Add more components as needed during development. + +### Step 5: Configure shadcn MCP Server + +Add to the project's `.mcp.json`: + +```json +{ + "mcpServers": { + "shadcn": { + "command": "npx", + "args": ["shadcn@latest", "mcp"] + } + } +} +``` + +### Step 6: Set Up Brand Colors + +Configure Open Elements brand colors in `tailwind.config.ts` so they are available as utility classes. Use the `open-elements-brand-guidelines` skill to get the exact color values. + +### Step 7: Verify Setup + +```bash +pnpm dev +``` + +Confirm the dev server starts without errors. + +## Developing Features + +### Adding Pages + +Create pages in `src/app/` following Next.js App Router conventions: + +- `src/app/page.tsx` — home page +- `src/app/<route>/page.tsx` — additional pages +- `src/app/layout.tsx` — root layout with consistent header/navigation and footer + +**IMPORTANT**: Pages that fetch data from a backend API must not be statically pre-rendered. Use `export const dynamic = 'force-dynamic'` to ensure request-time rendering. + +### Adding Components + +Place reusable components in `src/components/`. Follow these conventions: + +- One component per file, named in PascalCase matching the export +- Use shadcn/ui components as building blocks — do not create bare HTML equivalents +- Use shadcn/ui Blocks as starting points for layout structures (sidebar shells, dashboard layouts) +- Apply consistent spacing using Tailwind's spacing scale (`p-4`, `p-6`, `gap-4`, `gap-6`) +- Constrain content width for readability (`max-w-screen-xl mx-auto`) +- Ensure responsive design with Tailwind's responsive prefixes (`sm:`, `md:`, `lg:`) + +### Internationalization + +All user-facing text must be i18n-ready from the start: + +- Extract all display strings into a central location (constants file or translation file) +- Use consistent key naming (`page.section.element`) +- Use parameterized messages with placeholders (`"Welcome, {name}"` not `"Welcome, " + name`) +- Keep date, number, and currency formatting locale-aware (`Intl.DateTimeFormat`, `Intl.NumberFormat`) + +### Error Handling + +- Log detailed errors to the browser console (HTTP status, endpoint URL, error body) +- Never show raw backend error messages to the user — display simplified, user-friendly messages +- Centralize backend error handling in a shared API client layer + +### Testing + +Use the testing framework present in the project (Jest, Vitest, or Node test runner): + +```bash +pnpm test +``` + +- Name tests descriptively: `it('should return empty array when no items exist')` +- Group related tests with `describe` blocks +- Avoid excessive mocking — prefer simple stub/dummy implementations + +## Common Commands + +- **Install dependencies**: `pnpm install` +- **Dev server**: `pnpm dev` +- **Build**: `pnpm build` +- **Run tests**: `pnpm test` +- **Lint**: `pnpm lint` +- **Type check**: `pnpm tsc --noEmit` + +## Quality Checklist + +Before considering a feature complete, verify: + +- [ ] `pnpm build` succeeds without errors +- [ ] `pnpm lint` passes +- [ ] `pnpm tsc --noEmit` reports no type errors +- [ ] All pages are responsive (mobile, tablet, desktop) +- [ ] No bare HTML elements where shadcn/ui components exist +- [ ] No hardcoded user-facing strings — all are i18n-ready +- [ ] No `console.log` in production code — use `console.error`, `console.warn`, `console.info` +- [ ] No sensitive data logged to the browser console +- [ ] Standalone output configured in `next.config.ts` +- [ ] Brand colors applied via Tailwind config + +## Reference + +- **Next.js docs**: https://nextjs.org/docs +- **shadcn/ui components**: https://ui.shadcn.com/docs/components +- **shadcn/ui Blocks**: https://ui.shadcn.com/blocks +- **Tailwind CSS**: https://tailwindcss.com/docs diff --git a/.mcp.json b/.mcp.json new file mode 100644 index 00000000..b22547f6 --- /dev/null +++ b/.mcp.json @@ -0,0 +1,41 @@ +{ + "mcpServers": { + "hedera-docs": { + "type": "http", + "url": "https://docs.hedera.com/mcp" + }, + "coolify": { + "command": "npx", + "args": ["-y", "coolify-mcp"], + "env": { + "COOLIFY_API_URL": "${COOLIFY_API_URL}", + "COOLIFY_API_TOKEN": "${COOLIFY_API_TOKEN}" + } + }, + "github": { + "command": "npx", + "args": ["-y", "@modelcontextprotocol/server-github"], + "env": { + "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_PERSONAL_ACCESS_TOKEN}" + } + }, + "drawio": { + "command": "npx", + "args": ["-y", "drawio-mcp"] + }, + "figma": { + "command": "npx", + "args": ["-y", "figma-developer-mcp", "--figma-api-key=${FIGMA_API_KEY}"] + }, + "docker": { + "command": "docker", + "args": ["mcp", "gateway", "run"], + "type": "stdio" + }, + "maven-central": { + "command": "npx", + "args": ["mcp-maven-deps"], + "type": "stdio" + } + } +} \ No newline at end of file diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 00000000..d9022e59 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,163 @@ +The merged content is ready. Here it is: + +--- + +# Claude Code Base Configuration + +This file provides base rules and conventions for Claude Code in Open Elements projects. +Projects that use this as a base can override or extend these rules in their own `CLAUDE.md`. + +## Core Philosophy + +- **Quality over speed.** Getting it right matters more than getting it done fast. Take the time needed for clean APIs, proper tests, correct architecture, and polished design. +- **Iterative improvement is expected.** Code and design will evolve through iterations. It is normal and encouraged that things change and improve as new features are added or understanding deepens. Do not over-optimize for a "final" state on the first pass. + +## Code Quality + +- Follow the DRY principle — avoid duplicating logic. Extract shared code into reusable functions or modules. +- Follow the KISS principle — prefer simple, readable solutions over clever or complex ones. +- Remove dead code. Do not leave commented-out code, unused imports, or unreachable branches. +- Keep functions and methods focused — each should do one thing well. +- Prefer meaningful names for variables, functions, and classes. Avoid abbreviations unless they are widely understood (e.g., `id`, `url`). +- Do not add code "for future use." Only implement what is currently needed. + +## Security + +- **IMPORTANT**: Never read or write files outside the project directory unless the user explicitly asks for it. +- **IMPORTANT**: Never modify system-level configuration files (shell profiles, system packages, etc.). +- **IMPORTANT**: Never commit, log, or echo secrets, API keys, passwords, or tokens. Use environment variables or secret management tools. +- **IMPORTANT**: Always include `.env` in `.gitignore` to prevent accidental commits of local configuration with secrets. +- Validate and sanitize all external input (user input, API responses, file contents). +- **IMPORTANT**: Use parameterized queries for database access — never build SQL from string concatenation. +- Keep dependencies up to date to avoid known vulnerabilities. +- See [Security Configuration](.claude/conventions/security.md) for concrete `.claude/settings.json` deny rules, sandbox setup, and hook examples. + +## Testing + +- Write tests for new features and bug fixes. +- Tests should be deterministic — no flaky tests that depend on timing, network, or random state. +- Each test should test one behavior and have a clear name that describes what it verifies. +- Prefer assertion libraries that produce clear failure messages. + +## Documentation + +- Use GitHub Flavored Markdown (GFM) as the default syntax for all documentation (`README.md`, docs, ADRs, etc.). + +## Pull Requests and Reviews + +- Keep PRs focused on a single change. Avoid mixing unrelated changes in one PR. +- Write a clear PR description that explains what changed and why. +- Ensure all tests pass before requesting review. +- Address review comments before merging. + +## Additional Conventions + +**IMPORTANT**: Only include the documents that are relevant to your project. Do not reference all docs — each referenced file is loaded into Claude's context and excessive context causes rules to be ignored. + +Typical combinations: + +- **Java library**: `software-quality.md`, `java.md`, `repo-setup.md` +- **Java backend**: `software-quality.md`, `java.md`, `backend.md`, `repo-setup.md` +- **TypeScript frontend**: `software-quality.md`, `typescript.md`, `repo-setup.md` +- **Fullstack application**: `software-quality.md`, `java.md`, `typescript.md`, `backend.md`, `fullstack-architecture.md`, `repo-setup.md` + +Available documents: + +### Language-Specific + +- [Java Conventions](.claude/conventions/java.md) +- [TypeScript Conventions](.claude/conventions/typescript.md) + +### Security + +- [Security Configuration](.claude/conventions/security.md) + +### Architecture and Infrastructure + +- [Software Quality and Architecture](.claude/conventions/software-quality.md) +- [Fullstack Architecture](.claude/conventions/fullstack-architecture.md) +- [Backend Conventions](.claude/conventions/backend.md) + +### Development Workflow + +- [Spec-Driven Development](.claude/conventions/spec-driven-development.md) + +### CI/CD + +- [GitHub Actions](.claude/conventions/github-actions.md) + +### Documentation and Repository Setup + +- [Repository Setup](.claude/conventions/repo-setup.md) +- [EditorConfig](.claude/conventions/editorconfig.md) +- [Project Documentation](.claude/conventions/documentation.md) + +### Project-Specific + +- [Project-Specific Docs](.claude/conventions/project-specific/README.md) + +--- + +# Open Elements Website — Project Rules + +This repository contains the corporate website for Open Elements GmbH (https://open-elements.com / https://open-elements.de). + +## Tech Stack + +- **Static Site Generator:** Hugo (v0.118.2) +- **CSS Framework:** Tailwind CSS 3.4 +- **Interactive Components:** React 19 (bundled via esbuild) +- **Deployment:** Netlify (two sites: EN + DE) +- **Linting:** htmlhint, enforced via Husky pre-commit hook +- **Font:** Montserrat (Google Fonts) + +## Repository Structure + +- `content/` — Markdown content (blog posts, pages, articles, team profiles) +- `layouts/` — Hugo templates (`_default/`, `page/`, `partials/`, `shortcodes/`) +- `data/` — Structured JSON/YAML data (`team.json`, `mainMenu.json`, `social.json`, etc.) +- `i18n/` — Translation strings (`en.toml`, `de.toml`) +- `assets/` — CSS, icons, SVG illustrations +- `static/` — Static files copied to output (images, JS bundles, service worker) +- `react-src/` — React component source (Maven PR dashboard), built with esbuild +- `config.toml` — Hugo site configuration (languages, permalinks, markdown settings) +- `tailwind.config.js` — Tailwind theme (custom colors, shadows, plugins) +- `input.css` — Tailwind base styles with custom utility classes + +## Content Conventions + +- Blog posts live in `content/posts/` as Markdown with YAML front matter. +- The site is bilingual (English + German). Language-specific data is in `data/en/` and `data/de/`. +- Navigation is defined in `data/mainMenu.json`. Landing page section visibility is controlled by `data/landingpage.json`. +- Custom Hugo shortcodes exist for YouTube embeds, centered buttons, and support-care packages. + +## Build & Development + +- `npm run dev` — Start development server (Hugo + Tailwind + React in parallel) +- `npm run build` — Full production build +- `npm run netlify:build:production` — Netlify production build (sets base URL) +- `npm run lint:html` — HTML linting (runs automatically on pre-commit) + +## Working with Templates + +- Base template: `layouts/_default/baseof.html` +- Page-specific layouts: `layouts/page/` (about-us, contact, support-care, etc.) +- Reusable partials: `layouts/partials/` (navbar, footer, head, pagination, etc.) +- Custom markdown renderers: `layouts/_default/_markup/` (headings, links, images) + +## Styling Rules + +- Use Tailwind utility classes. Custom utilities are defined in `input.css` (`.h1`–`.h4`, `.badge-*`, `.link-*`, `.nav-*`). +- Brand colors are defined in `tailwind.config.js`: green (#5CBA9E), rose, sky, yellow, purple, blue. +- SVG illustrations are in `assets/illustrations/` and referenced via Hugo's `resources.Get`. + +## What NOT to do + +- Do not commit secrets, credentials, or environment-specific values. +- Do not bypass the pre-commit HTML lint hook. +- Do not edit files in `public/` — this directory is generated by Hugo. +- Do not hardcode URLs; use Hugo's `relref`/`absURL` functions in templates. + +--- + +The write to `CLAUDE.md` was blocked by permissions. Please approve the write if you'd like me to save this merged content to the file. diff --git a/content/support-care-landingpage/component-logos/apache-commons.svg b/content/support-care-landingpage/component-logos/apache-commons.svg new file mode 100644 index 00000000..3594bd62 --- /dev/null +++ b/content/support-care-landingpage/component-logos/apache-commons.svg @@ -0,0 +1,70 @@ +<?xml version="1.0" encoding="UTF-8" standalone="no"?> +<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"> +<svg width="100%" height="100%" viewBox="0 0 9584 4167" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;"> + <g transform="matrix(3.848242,0,0,3.848242,182.593552,113.81876)"> + <path d="M276.709,398.152C302.237,335.027 330.72,272.027 361.282,216.188C315.661,182.303 271.855,109.235 253.856,76.861C247.392,84.205 243.196,92.663 241.293,99.545C224.337,160.766 284.695,234.695 236.08,207.684C195.574,185.176 104.364,135.887 69.573,184.877C108.538,234.942 210.451,360.904 276.709,398.152Z" style="fill:rgb(221,85,44);fill-rule:nonzero;"/> + </g> + <g transform="matrix(3.848242,0,0,3.848242,182.593552,113.81876)"> + <path d="M361.282,216.188C390.896,162.082 422.455,114.695 455.174,80.556C455.174,80.556 422.54,127.793 375.928,222.222C404.157,229.996 484.553,245.948 596.537,217.022C599.29,196.671 585.609,174.288 517.431,166.794C472.921,161.906 570.856,60.511 499.909,12.557C497.618,11.006 495.367,9.638 493.161,8.413C490.782,7.559 488.27,6.777 485.589,6.08C402.73,-15.541 391.245,124.959 358.18,94.755C304.749,45.947 271.024,57.351 253.856,76.861C271.855,109.235 315.661,182.303 361.282,216.188L361.282,216.188Z" style="fill:rgb(247,154,35);fill-rule:nonzero;"/> + </g> + <g transform="matrix(3.848242,0,0,3.848242,182.593552,113.81876)"> + <path d="M210.066,580.024C228.771,523.99 251.273,461.035 276.709,398.152C210.451,360.904 108.538,234.942 69.573,184.877C62.617,194.664 57.863,208.316 56.279,226.986C47.782,327.266 151.236,401.508 130.612,415.068C103.331,433.008 49.033,371.975 27.633,410.754C58.651,450.602 121.834,522.602 210.066,580.024L210.066,580.024Z" style="fill:rgb(210,33,40);fill-rule:nonzero;"/> + </g> + <g transform="matrix(3.848242,0,0,3.848242,182.593552,113.81876)"> + <path d="M496.716,363.752C444.334,345.069 551.453,294.965 586.238,241.81C590.688,235.014 595.289,226.23 596.537,217.022C484.553,245.948 404.157,229.996 375.928,222.222C351.798,271.115 323.934,332.727 294.874,407.014C325.139,419.955 448.716,467.76 623.264,468.007C652.61,391.57 546.429,381.476 496.716,363.752L496.716,363.752Z" style="fill:rgb(221,85,44);fill-rule:nonzero;"/> + </g> + <g transform="matrix(3.848242,0,0,3.848242,182.593552,113.81876)"> + <path d="M230.306,590.111C261.086,599.703 363.074,628.356 471.39,624.042C485.941,584.644 431.539,580.799 427.108,549.201C423.677,524.752 570.276,569.748 617.445,480.845C619.83,476.348 621.69,472.106 623.264,468.007C448.716,467.76 325.139,419.955 294.874,407.014C273.637,461.302 251.791,522.23 230.306,590.111L230.306,590.111Z" style="fill:rgb(210,33,40);fill-rule:nonzero;"/> + </g> + <g transform="matrix(3.848242,0,0,3.848242,182.593552,113.81876)"> + <path d="M230.306,590.111C216.475,633.804 202.83,680.481 189.585,729.81C184.887,747.3 180.244,765.115 175.666,783.322C278.472,817.26 373.139,783.4 376.348,741.435C376.374,741.103 376.312,740.855 376.332,740.536C378.779,696.087 312.158,720.726 313.735,694.002C315.319,667.083 430.043,693.846 465.522,636.13C468.242,631.705 470.015,627.776 471.39,624.042C363.074,628.356 261.086,599.703 230.306,590.111Z" style="fill:rgb(124,41,125);fill-rule:nonzero;"/> + </g> + <g transform="matrix(3.848242,0,0,3.848242,182.593552,113.81876)"> + <path d="M27.633,410.754C26.135,413.472 24.782,416.613 23.629,420.366C3.705,485.119 144.59,572.107 125.422,591.069C108.143,608.155 85.626,569.109 57.86,585.237C54.817,587.01 51.728,589.245 48.558,592.496C17.155,624.668 48.066,717.35 137.161,766.823C116.37,836.633 95.671,914.627 75.408,996.193C82.759,993.619 91.556,991.039 93.745,984.105C97.033,970.59 117.351,888.353 150.34,776.786C150.34,776.786 156.361,753.933 167.384,716.282C177.575,681.465 192.058,633.98 210.066,580.024C121.834,522.602 58.651,450.602 27.633,410.754Z" style="fill:rgb(124,41,125);fill-rule:nonzero;"/> + </g> + <g transform="matrix(96.405275,0,0,96.405275,-59036.737004,-58246.867832)"> + <g transform="matrix(12,0,0,12,643.885418,621.776042)"> + <path d="M-0.009,-0L0.303,-0.7L0.463,-0.7L0.776,-0L0.606,-0L0.35,-0.618L0.414,-0.618L0.157,-0L-0.009,-0ZM0.147,-0.15L0.19,-0.273L0.55,-0.273L0.594,-0.15L0.147,-0.15Z" style="fill:rgb(124,41,125);fill-rule:nonzero;"/> + </g> + <g transform="matrix(12,0,0,12,653.079523,621.776042)"> + <path d="M0.39,0.008C0.345,0.008 0.305,-0.002 0.271,-0.022C0.237,-0.042 0.21,-0.073 0.191,-0.114C0.172,-0.154 0.163,-0.206 0.163,-0.269C0.163,-0.332 0.172,-0.384 0.19,-0.425C0.208,-0.466 0.234,-0.496 0.268,-0.516C0.302,-0.536 0.343,-0.546 0.39,-0.546C0.44,-0.546 0.486,-0.534 0.526,-0.511C0.567,-0.489 0.599,-0.456 0.622,-0.415C0.646,-0.374 0.658,-0.325 0.658,-0.269C0.658,-0.213 0.646,-0.164 0.622,-0.122C0.599,-0.081 0.567,-0.049 0.526,-0.026C0.486,-0.004 0.44,0.008 0.39,0.008ZM0.072,0.194L0.072,-0.538L0.221,-0.538L0.221,-0.428L0.218,-0.268L0.228,-0.109L0.228,0.194L0.072,0.194ZM0.363,-0.12C0.389,-0.12 0.412,-0.126 0.433,-0.138C0.453,-0.15 0.47,-0.167 0.482,-0.189C0.494,-0.212 0.5,-0.238 0.5,-0.269C0.5,-0.3 0.494,-0.327 0.482,-0.349C0.47,-0.371 0.453,-0.388 0.433,-0.4C0.412,-0.412 0.389,-0.418 0.363,-0.418C0.337,-0.418 0.314,-0.412 0.293,-0.4C0.272,-0.388 0.256,-0.371 0.244,-0.349C0.232,-0.327 0.226,-0.3 0.226,-0.269C0.226,-0.238 0.232,-0.212 0.244,-0.189C0.256,-0.167 0.272,-0.15 0.293,-0.138C0.314,-0.126 0.337,-0.12 0.363,-0.12Z" style="fill:rgb(124,41,125);fill-rule:nonzero;"/> + </g> + <g transform="matrix(12,0,0,12,661.255669,621.776042)"> + <path d="M0.402,-0L0.402,-0.105L0.392,-0.128L0.392,-0.316C0.392,-0.35 0.382,-0.376 0.362,-0.394C0.341,-0.412 0.31,-0.422 0.268,-0.422C0.239,-0.422 0.211,-0.417 0.184,-0.408C0.156,-0.399 0.132,-0.387 0.113,-0.372L0.057,-0.481C0.086,-0.502 0.122,-0.518 0.163,-0.529C0.204,-0.54 0.246,-0.546 0.289,-0.546C0.371,-0.546 0.435,-0.526 0.48,-0.488C0.526,-0.449 0.548,-0.389 0.548,-0.307L0.548,-0L0.402,-0ZM0.238,0.008C0.196,0.008 0.16,0.001 0.13,-0.014C0.1,-0.028 0.077,-0.047 0.061,-0.072C0.045,-0.096 0.037,-0.124 0.037,-0.155C0.037,-0.187 0.045,-0.215 0.061,-0.239C0.076,-0.263 0.101,-0.282 0.135,-0.295C0.169,-0.309 0.214,-0.316 0.268,-0.316L0.411,-0.316L0.411,-0.225L0.285,-0.225C0.249,-0.225 0.223,-0.219 0.21,-0.207C0.196,-0.195 0.189,-0.18 0.189,-0.162C0.189,-0.142 0.197,-0.126 0.213,-0.115C0.228,-0.103 0.249,-0.097 0.277,-0.097C0.303,-0.097 0.326,-0.103 0.347,-0.115C0.368,-0.127 0.383,-0.146 0.392,-0.17L0.416,-0.098C0.405,-0.063 0.384,-0.037 0.354,-0.019C0.324,-0.001 0.285,0.008 0.238,0.008Z" style="fill:rgb(124,41,125);fill-rule:nonzero;"/> + </g> + <g transform="matrix(12,0,0,12,668.703758,621.776042)"> + <path d="M0.332,0.008C0.274,0.008 0.223,-0.004 0.177,-0.028C0.132,-0.051 0.097,-0.084 0.071,-0.126C0.045,-0.168 0.032,-0.215 0.032,-0.269C0.032,-0.323 0.045,-0.371 0.071,-0.413C0.097,-0.454 0.132,-0.487 0.177,-0.51C0.223,-0.534 0.274,-0.546 0.332,-0.546C0.389,-0.546 0.438,-0.534 0.48,-0.51C0.522,-0.487 0.553,-0.453 0.573,-0.409L0.452,-0.344C0.438,-0.369 0.42,-0.388 0.399,-0.4C0.378,-0.412 0.355,-0.418 0.331,-0.418C0.305,-0.418 0.281,-0.412 0.259,-0.4C0.238,-0.388 0.221,-0.371 0.209,-0.349C0.196,-0.327 0.19,-0.3 0.19,-0.269C0.19,-0.238 0.196,-0.211 0.209,-0.189C0.221,-0.167 0.238,-0.15 0.259,-0.138C0.281,-0.126 0.305,-0.12 0.331,-0.12C0.355,-0.12 0.378,-0.126 0.399,-0.138C0.42,-0.149 0.438,-0.168 0.452,-0.194L0.573,-0.128C0.553,-0.085 0.522,-0.052 0.48,-0.028C0.438,-0.004 0.389,0.008 0.332,0.008Z" style="fill:rgb(124,41,125);fill-rule:nonzero;"/> + </g> + <g transform="matrix(12,0,0,12,675.753365,621.776042)"> + <path d="M0.072,-0L0.072,-0.742L0.228,-0.742L0.228,-0.389L0.193,-0.434C0.212,-0.47 0.24,-0.498 0.276,-0.517C0.312,-0.536 0.353,-0.546 0.399,-0.546C0.441,-0.546 0.48,-0.537 0.513,-0.52C0.547,-0.504 0.573,-0.478 0.593,-0.443C0.612,-0.408 0.622,-0.363 0.622,-0.308L0.622,-0L0.466,-0L0.466,-0.284C0.466,-0.328 0.456,-0.36 0.437,-0.38C0.418,-0.401 0.392,-0.411 0.357,-0.411C0.332,-0.411 0.31,-0.406 0.29,-0.395C0.271,-0.385 0.256,-0.369 0.245,-0.348C0.234,-0.327 0.228,-0.299 0.228,-0.266L0.228,-0L0.072,-0Z" style="fill:rgb(124,41,125);fill-rule:nonzero;"/> + </g> + <g transform="matrix(12,0,0,12,684.087789,621.776042)"> + <path d="M0.339,0.008C0.277,0.008 0.224,-0.004 0.177,-0.028C0.131,-0.052 0.096,-0.085 0.07,-0.127C0.045,-0.168 0.032,-0.216 0.032,-0.269C0.032,-0.323 0.045,-0.371 0.07,-0.412C0.094,-0.454 0.129,-0.487 0.172,-0.51C0.215,-0.534 0.264,-0.546 0.319,-0.546C0.372,-0.546 0.419,-0.534 0.461,-0.512C0.504,-0.49 0.537,-0.458 0.562,-0.416C0.586,-0.375 0.599,-0.325 0.599,-0.267C0.599,-0.261 0.599,-0.254 0.598,-0.246C0.598,-0.239 0.597,-0.232 0.596,-0.225L0.159,-0.225L0.159,-0.316L0.514,-0.316L0.454,-0.289C0.454,-0.317 0.448,-0.341 0.437,-0.362C0.425,-0.383 0.41,-0.399 0.39,-0.411C0.37,-0.422 0.346,-0.428 0.32,-0.428C0.293,-0.428 0.27,-0.422 0.249,-0.411C0.229,-0.399 0.213,-0.383 0.202,-0.362C0.191,-0.341 0.185,-0.316 0.185,-0.287L0.185,-0.263C0.185,-0.233 0.192,-0.208 0.205,-0.186C0.218,-0.163 0.236,-0.146 0.26,-0.135C0.284,-0.123 0.311,-0.117 0.343,-0.117C0.372,-0.117 0.397,-0.121 0.418,-0.13C0.44,-0.138 0.46,-0.151 0.478,-0.169L0.561,-0.079C0.536,-0.051 0.505,-0.029 0.468,-0.015C0.431,0 0.388,0.008 0.339,0.008Z" style="fill:rgb(124,41,125);fill-rule:nonzero;"/> + </g> + <g transform="matrix(12,0,0,12,691.663119,621.776042)"> + </g> + <g transform="matrix(12,0,0,12,643.885418,636.404042)"> + <path d="M0.418,0.012C0.364,0.012 0.314,0.003 0.267,-0.015C0.221,-0.032 0.181,-0.057 0.147,-0.09C0.113,-0.122 0.087,-0.161 0.068,-0.205C0.049,-0.249 0.039,-0.297 0.039,-0.35C0.039,-0.403 0.049,-0.451 0.068,-0.495C0.087,-0.539 0.113,-0.578 0.147,-0.61C0.182,-0.643 0.222,-0.668 0.268,-0.685C0.314,-0.703 0.365,-0.712 0.419,-0.712C0.48,-0.712 0.535,-0.701 0.584,-0.68C0.633,-0.659 0.674,-0.629 0.707,-0.588L0.603,-0.492C0.579,-0.519 0.553,-0.54 0.523,-0.554C0.494,-0.568 0.462,-0.574 0.427,-0.574C0.394,-0.574 0.364,-0.569 0.337,-0.558C0.31,-0.547 0.286,-0.532 0.266,-0.512C0.246,-0.492 0.231,-0.468 0.22,-0.441C0.209,-0.413 0.203,-0.383 0.203,-0.35C0.203,-0.317 0.209,-0.287 0.22,-0.259C0.231,-0.232 0.246,-0.208 0.266,-0.188C0.286,-0.168 0.31,-0.153 0.337,-0.142C0.364,-0.131 0.394,-0.126 0.427,-0.126C0.462,-0.126 0.494,-0.132 0.523,-0.146C0.553,-0.16 0.579,-0.181 0.603,-0.209L0.707,-0.113C0.674,-0.072 0.633,-0.042 0.584,-0.02C0.535,0.001 0.479,0.012 0.418,0.012Z" style="fill:rgb(124,41,125);fill-rule:nonzero;"/> + </g> + <g transform="matrix(12,0,0,12,652.34212,636.404042)"> + <path d="M0.328,0.008C0.271,0.008 0.22,-0.004 0.176,-0.028C0.131,-0.052 0.096,-0.084 0.071,-0.126C0.045,-0.168 0.032,-0.216 0.032,-0.269C0.032,-0.323 0.045,-0.371 0.071,-0.413C0.096,-0.454 0.131,-0.487 0.176,-0.51C0.22,-0.534 0.27,-0.546 0.328,-0.546C0.385,-0.546 0.436,-0.534 0.48,-0.51C0.525,-0.487 0.559,-0.454 0.585,-0.413C0.61,-0.371 0.623,-0.323 0.623,-0.269C0.623,-0.215 0.61,-0.168 0.585,-0.126C0.56,-0.084 0.525,-0.052 0.48,-0.028C0.435,-0.004 0.385,0.008 0.328,0.008ZM0.328,-0.12C0.354,-0.12 0.377,-0.126 0.398,-0.138C0.418,-0.15 0.435,-0.167 0.447,-0.189C0.459,-0.212 0.465,-0.239 0.465,-0.269C0.465,-0.3 0.459,-0.327 0.447,-0.349C0.435,-0.371 0.418,-0.388 0.398,-0.4C0.377,-0.412 0.354,-0.418 0.328,-0.418C0.302,-0.418 0.278,-0.412 0.258,-0.4C0.237,-0.388 0.221,-0.371 0.209,-0.349C0.196,-0.327 0.19,-0.3 0.19,-0.269C0.19,-0.239 0.196,-0.212 0.209,-0.189C0.221,-0.167 0.237,-0.15 0.258,-0.138C0.278,-0.126 0.302,-0.12 0.328,-0.12Z" style="fill:rgb(124,41,125);fill-rule:nonzero;"/> + </g> + <g transform="matrix(12,0,0,12,660.202968,636.404042)"> + <path d="M0.072,-0L0.072,-0.538L0.221,-0.538L0.221,-0.391L0.193,-0.434C0.211,-0.471 0.238,-0.498 0.272,-0.517C0.307,-0.536 0.346,-0.546 0.39,-0.546C0.439,-0.546 0.482,-0.533 0.519,-0.508C0.556,-0.484 0.581,-0.445 0.593,-0.394L0.538,-0.409C0.556,-0.451 0.585,-0.484 0.624,-0.509C0.664,-0.533 0.709,-0.546 0.761,-0.546C0.804,-0.546 0.842,-0.537 0.875,-0.52C0.908,-0.504 0.934,-0.478 0.952,-0.443C0.971,-0.408 0.981,-0.363 0.981,-0.308L0.981,-0L0.825,-0L0.825,-0.284C0.825,-0.328 0.816,-0.36 0.798,-0.38C0.78,-0.401 0.755,-0.411 0.723,-0.411C0.7,-0.411 0.679,-0.406 0.661,-0.396C0.643,-0.385 0.629,-0.37 0.619,-0.349C0.609,-0.329 0.604,-0.302 0.604,-0.27L0.604,-0L0.448,-0L0.448,-0.284C0.448,-0.328 0.44,-0.36 0.422,-0.38C0.404,-0.401 0.379,-0.411 0.346,-0.411C0.323,-0.411 0.303,-0.406 0.285,-0.396C0.267,-0.385 0.253,-0.37 0.243,-0.349C0.233,-0.329 0.228,-0.302 0.228,-0.27L0.228,-0L0.072,-0Z" style="fill:rgb(124,41,125);fill-rule:nonzero;"/> + </g> + <g transform="matrix(12,0,0,12,672.79158,636.404042)"> + <path d="M0.072,-0L0.072,-0.538L0.221,-0.538L0.221,-0.391L0.193,-0.434C0.211,-0.471 0.238,-0.498 0.272,-0.517C0.307,-0.536 0.346,-0.546 0.39,-0.546C0.439,-0.546 0.482,-0.533 0.519,-0.508C0.556,-0.484 0.581,-0.445 0.593,-0.394L0.538,-0.409C0.556,-0.451 0.585,-0.484 0.624,-0.509C0.664,-0.533 0.709,-0.546 0.761,-0.546C0.804,-0.546 0.842,-0.537 0.875,-0.52C0.908,-0.504 0.934,-0.478 0.952,-0.443C0.971,-0.408 0.981,-0.363 0.981,-0.308L0.981,-0L0.825,-0L0.825,-0.284C0.825,-0.328 0.816,-0.36 0.798,-0.38C0.78,-0.401 0.755,-0.411 0.723,-0.411C0.7,-0.411 0.679,-0.406 0.661,-0.396C0.643,-0.385 0.629,-0.37 0.619,-0.349C0.609,-0.329 0.604,-0.302 0.604,-0.27L0.604,-0L0.448,-0L0.448,-0.284C0.448,-0.328 0.44,-0.36 0.422,-0.38C0.404,-0.401 0.379,-0.411 0.346,-0.411C0.323,-0.411 0.303,-0.406 0.285,-0.396C0.267,-0.385 0.253,-0.37 0.243,-0.349C0.233,-0.329 0.228,-0.302 0.228,-0.27L0.228,-0L0.072,-0Z" style="fill:rgb(124,41,125);fill-rule:nonzero;"/> + </g> + <g transform="matrix(12,0,0,12,685.428193,636.404042)"> + <path d="M0.328,0.008C0.271,0.008 0.22,-0.004 0.176,-0.028C0.131,-0.052 0.096,-0.084 0.071,-0.126C0.045,-0.168 0.032,-0.216 0.032,-0.269C0.032,-0.323 0.045,-0.371 0.071,-0.413C0.096,-0.454 0.131,-0.487 0.176,-0.51C0.22,-0.534 0.27,-0.546 0.328,-0.546C0.385,-0.546 0.436,-0.534 0.48,-0.51C0.525,-0.487 0.559,-0.454 0.585,-0.413C0.61,-0.371 0.623,-0.323 0.623,-0.269C0.623,-0.215 0.61,-0.168 0.585,-0.126C0.56,-0.084 0.525,-0.052 0.48,-0.028C0.435,-0.004 0.385,0.008 0.328,0.008ZM0.328,-0.12C0.354,-0.12 0.377,-0.126 0.398,-0.138C0.418,-0.15 0.435,-0.167 0.447,-0.189C0.459,-0.212 0.465,-0.239 0.465,-0.269C0.465,-0.3 0.459,-0.327 0.447,-0.349C0.435,-0.371 0.418,-0.388 0.398,-0.4C0.377,-0.412 0.354,-0.418 0.328,-0.418C0.302,-0.418 0.278,-0.412 0.258,-0.4C0.237,-0.388 0.221,-0.371 0.209,-0.349C0.196,-0.327 0.19,-0.3 0.19,-0.269C0.19,-0.239 0.196,-0.212 0.209,-0.189C0.221,-0.167 0.237,-0.15 0.258,-0.138C0.278,-0.126 0.302,-0.12 0.328,-0.12Z" style="fill:rgb(124,41,125);fill-rule:nonzero;"/> + </g> + <g transform="matrix(12,0,0,12,693.289041,636.404042)"> + <path d="M0.072,-0L0.072,-0.538L0.221,-0.538L0.221,-0.389L0.193,-0.434C0.212,-0.47 0.24,-0.498 0.276,-0.517C0.312,-0.536 0.353,-0.546 0.399,-0.546C0.441,-0.546 0.48,-0.537 0.513,-0.52C0.547,-0.504 0.573,-0.478 0.593,-0.443C0.612,-0.408 0.622,-0.363 0.622,-0.308L0.622,-0L0.466,-0L0.466,-0.284C0.466,-0.328 0.456,-0.36 0.437,-0.38C0.418,-0.401 0.392,-0.411 0.357,-0.411C0.332,-0.411 0.31,-0.406 0.29,-0.395C0.271,-0.385 0.256,-0.369 0.245,-0.348C0.234,-0.327 0.228,-0.299 0.228,-0.266L0.228,-0L0.072,-0Z" style="fill:rgb(124,41,125);fill-rule:nonzero;"/> + </g> + <g transform="matrix(12,0,0,12,701.575465,636.404042)"> + <path d="M0.253,0.008C0.207,0.008 0.163,0.002 0.121,-0.009C0.079,-0.02 0.045,-0.034 0.02,-0.05L0.072,-0.162C0.096,-0.146 0.125,-0.134 0.159,-0.124C0.193,-0.115 0.226,-0.11 0.259,-0.11C0.295,-0.11 0.321,-0.115 0.336,-0.123C0.351,-0.132 0.358,-0.144 0.358,-0.159C0.358,-0.172 0.352,-0.181 0.341,-0.188C0.329,-0.194 0.313,-0.199 0.294,-0.202C0.275,-0.206 0.254,-0.209 0.231,-0.212C0.207,-0.215 0.184,-0.22 0.161,-0.226C0.138,-0.232 0.116,-0.24 0.097,-0.251C0.078,-0.262 0.062,-0.278 0.051,-0.297C0.039,-0.316 0.033,-0.341 0.033,-0.372C0.033,-0.406 0.043,-0.436 0.063,-0.462C0.083,-0.488 0.111,-0.509 0.148,-0.523C0.185,-0.538 0.23,-0.546 0.282,-0.546C0.319,-0.546 0.356,-0.542 0.394,-0.534C0.432,-0.526 0.464,-0.514 0.489,-0.499L0.437,-0.388C0.411,-0.403 0.385,-0.414 0.358,-0.419C0.332,-0.425 0.307,-0.428 0.282,-0.428C0.247,-0.428 0.222,-0.423 0.206,-0.414C0.19,-0.404 0.182,-0.393 0.182,-0.378C0.182,-0.365 0.188,-0.355 0.199,-0.348C0.211,-0.341 0.227,-0.336 0.246,-0.332C0.265,-0.328 0.286,-0.325 0.309,-0.322C0.333,-0.318 0.356,-0.314 0.379,-0.308C0.402,-0.302 0.423,-0.294 0.442,-0.283C0.462,-0.272 0.477,-0.257 0.489,-0.237C0.501,-0.218 0.507,-0.193 0.507,-0.163C0.507,-0.13 0.497,-0.1 0.477,-0.075C0.457,-0.049 0.428,-0.029 0.39,-0.014C0.353,0 0.307,0.008 0.253,0.008Z" style="fill:rgb(124,41,125);fill-rule:nonzero;"/> + </g> + <g transform="matrix(12,0,0,12,707.942737,636.404042)"> + </g> + </g> +</svg> diff --git a/content/support-care-landingpage/component-logos/apache-log4j.png b/content/support-care-landingpage/component-logos/apache-log4j.png new file mode 100644 index 00000000..b6d34cec Binary files /dev/null and b/content/support-care-landingpage/component-logos/apache-log4j.png differ diff --git a/content/support-care-landingpage/component-logos/apache-maven.svg b/content/support-care-landingpage/component-logos/apache-maven.svg new file mode 100644 index 00000000..24f2345a --- /dev/null +++ b/content/support-care-landingpage/component-logos/apache-maven.svg @@ -0,0 +1,998 @@ +<?xml version="1.0" encoding="UTF-8" standalone="no"?> +<!-- Created with Inkscape (http://www.inkscape.org/) --> + +<svg + xmlns:dc="http://purl.org/dc/elements/1.1/" + xmlns:cc="http://creativecommons.org/ns#" + xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" + xmlns:svg="http://www.w3.org/2000/svg" + xmlns="http://www.w3.org/2000/svg" + xmlns:xlink="http://www.w3.org/1999/xlink" + xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" + xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" + version="1.1" + width="340" + height="86" + id="svg3055" + inkscape:version="0.92.4 (5da689c313, 2019-01-14)" + sodipodi:docname="maven.svg"> + <sodipodi:namedview + pagecolor="#ffffff" + bordercolor="#666666" + borderopacity="1" + objecttolerance="10" + gridtolerance="10" + guidetolerance="10" + inkscape:pageopacity="0" + inkscape:pageshadow="2" + inkscape:window-width="1600" + inkscape:window-height="877" + id="namedview188" + showgrid="false" + inkscape:zoom="0.91176471" + inkscape:cx="170" + inkscape:cy="43" + inkscape:window-x="-8" + inkscape:window-y="-8" + inkscape:window-maximized="1" + inkscape:current-layer="svg3055"/> + <metadata + id="metadata3061"> + <rdf:RDF> + <cc:Work + rdf:about=""> + <dc:format>image/svg+xml</dc:format> + <dc:type + rdf:resource="http://purl.org/dc/dcmitype/StillImage"/> + <dc:title></dc:title> + </cc:Work> + </rdf:RDF> + </metadata> + <defs + id="defs3059"> + <linearGradient + x1="0" + y1="0" + x2="1" + y2="0" + id="linearGradient12648" + xlink:href="#linearGradient11392" + gradientUnits="userSpaceOnUse" + gradientTransform="translate(-44.21456,-9.8500092)"/> + <linearGradient + x1="-7708.7969" + y1="-803.36011" + x2="-7633.1528" + y2="-714.90741" + id="linearGradient5344" + xlink:href="#SVGID_1_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"/> + <linearGradient + x1="-8268.6387" + y1="-813.12323" + x2="-7728.9585" + y2="-813.12323" + id="linearGradient5346" + xlink:href="#SVGID_2_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"/> + <linearGradient + x1="-8203.4922" + y1="-758.99402" + x2="-7881.895" + y2="-758.99402" + id="linearGradient5348" + xlink:href="#SVGID_3_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"/> + <linearGradient + x1="-8238.3281" + y1="-818.15222" + x2="-7698.647" + y2="-818.15222" + id="linearGradient5350" + xlink:href="#SVGID_4_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"/> + <linearGradient + x1="-8198.9678" + y1="-810.85059" + x2="-7915.3501" + y2="-810.85059" + id="linearGradient5352" + xlink:href="#SVGID_5_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"/> + <linearGradient + x1="-8238.3281" + y1="-762.29712" + x2="-7698.647" + y2="-762.29712" + id="linearGradient5354" + xlink:href="#SVGID_6_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"/> + <linearGradient + x1="-8271.8057" + y1="-765.07068" + x2="-7732.125" + y2="-765.07068" + id="linearGradient5356" + xlink:href="#SVGID_7_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"/> + <linearGradient + x1="-8238.3281" + y1="-745.68481" + x2="-7698.647" + y2="-745.68481" + id="linearGradient5358" + xlink:href="#SVGID_8_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"/> + <linearGradient + x1="-8238.3281" + y1="-747.58557" + x2="-7698.647" + y2="-747.58557" + id="linearGradient5360" + xlink:href="#SVGID_9_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"/> + <linearGradient + x1="-7935.1431" + y1="-747.9668" + x2="-7815.856" + y2="-747.9668" + id="linearGradient5362" + xlink:href="#SVGID_10_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"/> + <linearGradient + x1="-7708.7969" + y1="-803.36011" + x2="-7633.1528" + y2="-714.90741" + id="linearGradient7396" + xlink:href="#SVGID_1_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"/> + <linearGradient + x1="-8268.6387" + y1="-813.12323" + x2="-7728.9585" + y2="-813.12323" + id="linearGradient7398" + xlink:href="#SVGID_2_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"/> + <linearGradient + x1="-8203.4922" + y1="-758.99402" + x2="-7881.895" + y2="-758.99402" + id="linearGradient7400" + xlink:href="#SVGID_3_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"/> + <linearGradient + x1="-8238.3281" + y1="-818.15222" + x2="-7698.647" + y2="-818.15222" + id="linearGradient7402" + xlink:href="#SVGID_4_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"/> + <linearGradient + x1="-8198.9678" + y1="-810.85059" + x2="-7915.3501" + y2="-810.85059" + id="linearGradient7404" + xlink:href="#SVGID_5_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"/> + <linearGradient + x1="-8238.3281" + y1="-762.29712" + x2="-7698.647" + y2="-762.29712" + id="linearGradient7406" + xlink:href="#SVGID_6_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"/> + <linearGradient + x1="-8271.8057" + y1="-765.07068" + x2="-7732.125" + y2="-765.07068" + id="linearGradient7408" + xlink:href="#SVGID_7_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"/> + <linearGradient + x1="-8238.3281" + y1="-745.68481" + x2="-7698.647" + y2="-745.68481" + id="linearGradient7410" + xlink:href="#SVGID_8_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"/> + <linearGradient + x1="-8238.3281" + y1="-747.58557" + x2="-7698.647" + y2="-747.58557" + id="linearGradient7412" + xlink:href="#SVGID_9_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"/> + <linearGradient + x1="-7935.1431" + y1="-747.9668" + x2="-7815.856" + y2="-747.9668" + id="linearGradient7414" + xlink:href="#SVGID_10_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"/> + </defs> + <text + x="199.61313" + y="196.18768" + id="text11870" + xml:space="preserve" + style="font-style:italic;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:14px;line-height:0%;font-family:'Alte Haas Grotesk';-inkscape-font-specification:'Sans Italic';letter-spacing:0px;word-spacing:0px;fill:url(#linearGradient12648);fill-opacity:1;stroke:none"><tspan + x="199.61313" + y="196.18768" + id="tspan11872" + style="fill:url(#linearGradient12648);fill-opacity:1" /></text> + <g + id="g8927"> + <g + transform="matrix(0.09561334,-0.07017507,0.07017507,0.09561334,132.73733,36.368381)" + id="g7248"> + <linearGradient + x1="-7708.7969" + y1="-803.36011" + x2="-7633.1528" + y2="-714.90741" + id="linearGradient7250" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"> + <stop + id="stop7252" + style="stop-color:#f69923;stop-opacity:1" + offset="0"/> + <stop + id="stop7254" + style="stop-color:#f79a23;stop-opacity:1" + offset="0.3123"/> + <stop + id="stop7256" + style="stop-color:#e97826;stop-opacity:1" + offset="0.83829999"/> + </linearGradient> + <path + d="m 267.1,19.6 c -8.4,5 -22.4,19 -39,39.3 l 15.3,28.9 c 10.7,-15.4 21.7,-29.2 32.7,-41 0.8,-0.9 1.3,-1.4 1.3,-1.4 -0.4,0.5 -0.9,0.9 -1.3,1.4 -3.6,3.9 -14.4,16.5 -30.7,41.6 15.7,-0.8 39.8,-4 59.5,-7.4 5.9,-32.8 -5.7,-47.8 -5.7,-47.8 0,0 -14.8,-23.9 -32.1,-13.6 z" + id="path7258" + style="fill:url(#linearGradient7396)"/> + <path + d="m 241.1,184.4 c 0.1,0 0.2,0 0.3,-0.1 l -2.2,0.2 c -0.1,0.1 -0.3,0.1 -0.4,0.2 0.8,-0.1 1.6,-0.2 2.3,-0.3 z" + id="path7260" + style="fill:none"/> + <path + d="m 225.5,236.1 c -1.2,0.3 -2.5,0.5 -3.8,0.7 1.3,-0.2 2.6,-0.4 3.8,-0.7 z" + id="path7262" + style="fill:none"/> + <path + d="m 119.3,352.2 c 0.2,-0.4 0.3,-0.9 0.5,-1.3 3.4,-8.9 6.7,-17.5 10,-26 3.7,-9.4 7.4,-18.6 11,-27.5 3.8,-9.3 7.6,-18.4 11.3,-27.1 3.9,-9.2 7.7,-18 11.5,-26.5 3.1,-6.9 6.1,-13.6 9.1,-20.1 1,-2.2 2,-4.3 3,-6.4 2,-4.2 3.9,-8.3 5.8,-12.3 1.8,-3.7 3.5,-7.3 5.2,-10.9 0.6,-1.2 1.2,-2.4 1.7,-3.5 0.1,-0.2 0.2,-0.4 0.3,-0.6 l -1.9,0.2 -1.5,-2.9 c -0.1,0.3 -0.3,0.6 -0.4,0.9 -2.7,5.3 -5.4,10.7 -8,16.2 -1.5,3.1 -3,6.3 -4.6,9.5 -4.2,8.8 -8.3,17.6 -12.3,26.6 -4.1,9 -8.1,18.1 -12,27.1 -3.9,8.9 -7.6,17.8 -11.3,26.7 -3.7,8.9 -7.3,17.7 -10.8,26.5 -3.7,9.2 -7.3,18.3 -10.7,27.3 -0.8,2 -1.6,4.1 -2.3,6.1 -2.8,7.3 -5.5,14.4 -8.1,21.5 l 2.4,4.7 2.1,-0.2 c 0.1,-0.2 0.2,-0.4 0.2,-0.6 3.1,-9.5 6.5,-18.6 9.8,-27.4 z" + id="path7264" + style="fill:none"/> + <path + d="m 220.7,236.9 0,0 c 0,0 0,0 0,0 0,0 0,0 0,0 z" + id="path7266" + style="fill:none"/> + <path + d="m 215.6,262.2 c -2,0.4 -4,0.7 -6,1 0,0 0,0 0,0 1,-0.1 2.1,-0.3 3.1,-0.5 1,-0.1 2,-0.3 2.9,-0.5 z" + id="path7268" + style="fill:#be202e"/> + <path + d="m 215.6,262.2 c -2,0.4 -4,0.7 -6,1 0,0 0,0 0,0 1,-0.1 2.1,-0.3 3.1,-0.5 1,-0.1 2,-0.3 2.9,-0.5 z" + id="path7270" + style="opacity:0.35;fill:#be202e"/> + <path + d="m 220.8,236.9 c 0,0 0,0 0,0 -0.1,0 -0.1,0 0,0 0.3,0 0.6,-0.1 0.9,-0.1 1.3,-0.2 2.6,-0.4 3.8,-0.7 -1.5,0.3 -3.1,0.5 -4.7,0.8 l 0,0 0,0 z" + id="path7272" + style="fill:#be202e"/> + <path + d="m 220.8,236.9 c 0,0 0,0 0,0 -0.1,0 -0.1,0 0,0 0.3,0 0.6,-0.1 0.9,-0.1 1.3,-0.2 2.6,-0.4 3.8,-0.7 -1.5,0.3 -3.1,0.5 -4.7,0.8 l 0,0 0,0 z" + id="path7274" + style="opacity:0.35;fill:#be202e"/> + <linearGradient + x1="-8268.6387" + y1="-813.12323" + x2="-7728.9585" + y2="-813.12323" + id="linearGradient7276" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"> + <stop + id="stop7278" + style="stop-color:#9e2064;stop-opacity:1" + offset="0.3233"/> + <stop + id="stop7280" + style="stop-color:#c92037;stop-opacity:1" + offset="0.63020003"/> + <stop + id="stop7282" + style="stop-color:#cd2335;stop-opacity:1" + offset="0.75139999"/> + <stop + id="stop7284" + style="stop-color:#e97826;stop-opacity:1" + offset="1"/> + </linearGradient> + <path + d="m 198.2,162.4 c 4.7,-8.7 9.4,-17.2 14.1,-25.5 4.9,-8.6 9.9,-16.9 15,-25 0.3,-0.5 0.6,-1 0.9,-1.4 5,-7.9 10,-15.5 15.1,-22.8 L 228,58.9 c -1.1,1.4 -2.3,2.8 -3.5,4.3 -4.4,5.5 -9,11.4 -13.7,17.7 -5.3,7.1 -10.7,14.6 -16.3,22.5 -5.1,7.3 -10.3,15 -15.5,22.9 -4.4,6.8 -8.8,13.7 -13.2,20.8 -0.2,0.3 -0.3,0.5 -0.5,0.8 l 19.9,39.3 c 4.4,-8.3 8.7,-16.6 13,-24.8 z" + id="path7286" + style="fill:url(#linearGradient7398)"/> + <linearGradient + x1="-8203.4922" + y1="-758.99402" + x2="-7881.895" + y2="-758.99402" + id="linearGradient7288" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"> + <stop + id="stop7290" + style="stop-color:#282662;stop-opacity:1" + offset="0"/> + <stop + id="stop7292" + style="stop-color:#662e8d;stop-opacity:1" + offset="0.0954839"/> + <stop + id="stop7294" + style="stop-color:#9f2064;stop-opacity:1" + offset="0.78820002"/> + <stop + id="stop7296" + style="stop-color:#cd2032;stop-opacity:1" + offset="0.94870001"/> + </linearGradient> + <path + d="m 107.5,384.1 c -2.6,7.2 -5.3,14.6 -7.9,22.2 0,0.1 -0.1,0.2 -0.1,0.3 -0.4,1.1 -0.8,2.1 -1.1,3.2 -1.8,5.1 -3.3,9.7 -6.9,20.1 5.9,2.7 10.6,9.7 15,17.7 -0.5,-8.3 -3.9,-16.1 -10.4,-22.1 28.9,1.3 53.9,-6 66.7,-27.2 1.1,-1.9 2.2,-3.9 3.2,-6 -5.9,7.4 -13.1,10.6 -26.8,9.8 0,0 -0.1,0 -0.1,0 0,0 0.1,0 0.1,0 20.1,-9 30.2,-17.7 39.1,-32 2.1,-3.4 4.2,-7.1 6.3,-11.2 -17.6,18.1 -38,23.2 -59.5,19.3 L 109,380 c -0.5,1.4 -1,2.7 -1.5,4.1 z" + id="path7298" + style="fill:url(#linearGradient7400)"/> + <linearGradient + x1="-8238.3281" + y1="-818.15222" + x2="-7698.647" + y2="-818.15222" + id="linearGradient7300" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"> + <stop + id="stop7302" + style="stop-color:#9e2064;stop-opacity:1" + offset="0.3233"/> + <stop + id="stop7304" + style="stop-color:#c92037;stop-opacity:1" + offset="0.63020003"/> + <stop + id="stop7306" + style="stop-color:#cd2335;stop-opacity:1" + offset="0.75139999"/> + <stop + id="stop7308" + style="stop-color:#e97826;stop-opacity:1" + offset="1"/> + </linearGradient> + <path + d="m 115,348 c 3.5,-9 7.1,-18.1 10.7,-27.3 3.5,-8.8 7.1,-17.6 10.8,-26.5 3.7,-8.9 7.5,-17.8 11.3,-26.7 3.9,-9.1 7.9,-18.1 12,-27.1 4,-8.9 8.2,-17.8 12.3,-26.6 1.5,-3.2 3,-6.3 4.6,-9.5 2.6,-5.4 5.3,-10.8 8,-16.2 0.1,-0.3 0.3,-0.6 0.4,-0.9 L 165.4,148 c -0.3,0.5 -0.6,1.1 -1,1.6 -4.6,7.6 -9.3,15.3 -13.8,23.2 -4.6,8 -9.1,16.1 -13.5,24.4 -3.7,7 -7.3,14 -10.9,21.1 -0.7,1.4 -1.4,2.9 -2.1,4.3 -4.3,8.9 -8.3,17.6 -11.8,25.9 -4,9.4 -7.5,18.4 -10.6,26.9 -2,5.6 -3.9,11 -5.6,16.2 -1.4,4.4 -2.7,8.9 -4,13.3 -3,10.4 -5.5,20.8 -7.6,31.2 l 20,39.5 c 2.6,-7.1 5.4,-14.2 8.1,-21.5 0.8,-2 1.6,-4 2.4,-6.1 z" + id="path7310" + style="fill:url(#linearGradient7402)"/> + <linearGradient + x1="-8198.9678" + y1="-810.85059" + x2="-7915.3501" + y2="-810.85059" + id="linearGradient7312" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"> + <stop + id="stop7314" + style="stop-color:#282662;stop-opacity:1" + offset="0"/> + <stop + id="stop7316" + style="stop-color:#662e8d;stop-opacity:1" + offset="0.0954839"/> + <stop + id="stop7318" + style="stop-color:#9f2064;stop-opacity:1" + offset="0.78820002"/> + <stop + id="stop7320" + style="stop-color:#cd2032;stop-opacity:1" + offset="0.94870001"/> + </linearGradient> + <path + d="m 84.2,337.5 c -2.5,12.6 -4.3,25.2 -5.2,37.8 0,0.4 -0.1,0.9 -0.1,1.3 -6.2,-10 -23,-19.8 -22.9,-19.7 12,17.4 21.1,34.6 22.4,51.5 -6.4,1.3 -15.2,-0.6 -25.3,-4.3 10.6,9.7 18.5,12.4 21.6,13.1 -9.7,0.6 -19.8,7.3 -30,15 14.9,-6.1 27,-8.5 35.6,-6.5 -13.7,38.7 -27.4,81.5 -41.1,126.9 4.2,-1.2 6.7,-4.1 8.1,-7.9 2.4,-8.2 18.7,-62.2 44.1,-133.1 0.7,-2 1.5,-4 2.2,-6.1 0.2,-0.6 0.4,-1.1 0.6,-1.7 2.7,-7.4 5.5,-15 8.4,-22.8 0.7,-1.8 1.3,-3.5 2,-5.3 0,0 0,-0.1 0,-0.1 l -20,-39.5 c -0.2,0.5 -0.3,0.9 -0.4,1.4 z" + id="path7322" + style="fill:url(#linearGradient7404)"/> + <linearGradient + x1="-8238.3281" + y1="-762.29712" + x2="-7698.647" + y2="-762.29712" + id="linearGradient7324" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"> + <stop + id="stop7326" + style="stop-color:#9e2064;stop-opacity:1" + offset="0.3233"/> + <stop + id="stop7328" + style="stop-color:#c92037;stop-opacity:1" + offset="0.63020003"/> + <stop + id="stop7330" + style="stop-color:#cd2335;stop-opacity:1" + offset="0.75139999"/> + <stop + id="stop7332" + style="stop-color:#e97826;stop-opacity:1" + offset="1"/> + </linearGradient> + <path + d="m 188.4,190.6 c -0.6,1.2 -1.1,2.3 -1.7,3.5 -1.7,3.6 -3.5,7.2 -5.2,10.9 -1.9,4 -3.8,8.1 -5.8,12.3 -1,2.1 -2,4.2 -3,6.4 -3,6.5 -6,13.2 -9.1,20.1 -3.8,8.5 -7.6,17.3 -11.5,26.5 -3.7,8.7 -7.5,17.8 -11.3,27.1 -3.6,8.9 -7.3,18 -11,27.5 -3.3,8.4 -6.6,17.1 -10,26 -0.2,0.4 -0.3,0.9 -0.5,1.3 -3.3,8.8 -6.7,17.9 -10.1,27.2 -0.1,0.2 -0.2,0.4 -0.2,0.6 l 16.1,-1.8 c -0.3,-0.1 -0.6,-0.1 -1,-0.2 19.3,-2.4 44.9,-16.8 61.4,-34.6 7.6,-8.2 14.5,-17.8 20.9,-29.1 4.8,-8.4 9.2,-17.7 13.5,-28.1 3.7,-9 7.3,-18.8 10.7,-29.4 -4.4,2.3 -9.5,4 -15.1,5.2 -1,0.2 -2,0.4 -3,0.6 -1,0.2 -2,0.3 -3.1,0.5 l 0,0 0,0 c 0,0 0,0 0,0 18,-6.9 29.3,-20.2 37.5,-36.6 -4.7,3.2 -12.4,7.4 -21.6,9.5 -1.2,0.3 -2.5,0.5 -3.8,0.7 -0.3,0 -0.6,0.1 -1,0.1 l 0,0 0,0 c 0,0 0,0 0,0 0,0 0,0 0,0 l 0,0 c 6.2,-2.6 11.5,-5.5 16.1,-9 1,-0.7 1.9,-1.5 2.8,-2.3 1.4,-1.2 2.7,-2.5 4,-3.8 0.8,-0.9 1.6,-1.7 2.4,-2.6 1.8,-2.1 3.5,-4.4 5,-6.9 0.5,-0.8 1,-1.5 1.4,-2.3 0.6,-1.2 1.2,-2.3 1.7,-3.4 2.5,-5 4.5,-9.5 6.1,-13.5 0.8,-2 1.5,-3.8 2.1,-5.5 0.2,-0.7 0.5,-1.3 0.7,-2 0.6,-1.9 1.2,-3.6 1.6,-5.1 0.6,-2.2 1,-4 1.2,-5.3 l 0,0 0,0 c -0.6,0.5 -1.3,1 -2.1,1.4 -5.4,3.2 -14.7,6.2 -22.2,7.6 l 14.8,-1.6 -14.8,1.6 c -0.1,0 -0.2,0 -0.3,0.1 -0.7,0.1 -1.5,0.2 -2.3,0.4 0.1,-0.1 0.3,-0.1 0.4,-0.2 l -50.6,5.5 c 0.1,0.4 0,0.6 -0.1,0.7 z" + id="path7334" + style="fill:url(#linearGradient7406)"/> + <linearGradient + x1="-8271.8057" + y1="-765.07068" + x2="-7732.125" + y2="-765.07068" + id="linearGradient7336" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"> + <stop + id="stop7338" + style="stop-color:#9e2064;stop-opacity:1" + offset="0.3233"/> + <stop + id="stop7340" + style="stop-color:#c92037;stop-opacity:1" + offset="0.63020003"/> + <stop + id="stop7342" + style="stop-color:#cd2335;stop-opacity:1" + offset="0.75139999"/> + <stop + id="stop7344" + style="stop-color:#e97826;stop-opacity:1" + offset="1"/> + </linearGradient> + <path + d="m 245.4,88.4 c -4.5,6.9 -9.4,14.8 -14.7,23.6 -0.3,0.5 -0.6,0.9 -0.8,1.4 -4.6,7.7 -9.4,16.1 -14.5,25.4 -4.4,8 -9,16.5 -13.8,25.8 -4.2,8 -8.4,16.5 -12.9,25.5 l 50.6,-5.5 c 14.7,-6.8 21.3,-12.9 27.7,-21.8 1.7,-2.4 3.4,-5 5.1,-7.7 5.2,-8.1 10.3,-17 14.8,-25.9 4.4,-8.6 8.3,-17.1 11.2,-24.7 1.9,-4.9 3.4,-9.4 4.5,-13.4 0.9,-3.5 1.6,-6.8 2.2,-10 -19.6,3.3 -43.7,6.5 -59.4,7.3 z" + id="path7346" + style="fill:url(#linearGradient7408)"/> + <path + d="m 212.7,262.8 c -1,0.2 -2,0.3 -3.1,0.5 l 0,0 c 1,-0.2 2,-0.4 3.1,-0.5 z" + id="path7348" + style="fill:#be202e"/> + <path + d="m 212.7,262.8 c -1,0.2 -2,0.3 -3.1,0.5 l 0,0 c 1,-0.2 2,-0.4 3.1,-0.5 z" + id="path7350" + style="opacity:0.35;fill:#be202e"/> + <linearGradient + x1="-8238.3281" + y1="-745.68481" + x2="-7698.647" + y2="-745.68481" + id="linearGradient7352" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"> + <stop + id="stop7354" + style="stop-color:#9e2064;stop-opacity:1" + offset="0.3233"/> + <stop + id="stop7356" + style="stop-color:#c92037;stop-opacity:1" + offset="0.63020003"/> + <stop + id="stop7358" + style="stop-color:#cd2335;stop-opacity:1" + offset="0.75139999"/> + <stop + id="stop7360" + style="stop-color:#e97826;stop-opacity:1" + offset="1"/> + </linearGradient> + <path + d="m 212.7,262.8 c -1,0.2 -2,0.3 -3.1,0.5 l 0,0 c 1,-0.2 2,-0.4 3.1,-0.5 z" + id="path7362" + style="fill:url(#linearGradient7410)"/> + <path + d="m 220.7,236.9 c 0.3,0 0.6,-0.1 1,-0.1 -0.3,0 -0.6,0.1 -1,0.1 l 0,0 z" + id="path7364" + style="fill:#be202e"/> + <path + d="m 220.7,236.9 c 0.3,0 0.6,-0.1 1,-0.1 -0.3,0 -0.6,0.1 -1,0.1 l 0,0 z" + id="path7366" + style="opacity:0.35;fill:#be202e"/> + <linearGradient + x1="-8238.3281" + y1="-747.58557" + x2="-7698.647" + y2="-747.58557" + id="linearGradient7368" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"> + <stop + id="stop7370" + style="stop-color:#9e2064;stop-opacity:1" + offset="0.3233"/> + <stop + id="stop7372" + style="stop-color:#c92037;stop-opacity:1" + offset="0.63020003"/> + <stop + id="stop7374" + style="stop-color:#cd2335;stop-opacity:1" + offset="0.75139999"/> + <stop + id="stop7376" + style="stop-color:#e97826;stop-opacity:1" + offset="1"/> + </linearGradient> + <path + d="m 220.7,236.9 c 0.3,0 0.6,-0.1 1,-0.1 -0.3,0 -0.6,0.1 -1,0.1 l 0,0 z" + id="path7378" + style="fill:url(#linearGradient7412)"/> + <path + d="m 220.8,236.9 c 0,0 0,0 0,0 l 0,0 0,0 0,0 c 0,0 0,0 0,0 z" + id="path7380" + style="fill:#be202e"/> + <path + d="m 220.8,236.9 c 0,0 0,0 0,0 l 0,0 0,0 0,0 c 0,0 0,0 0,0 z" + id="path7382" + style="opacity:0.35;fill:#be202e"/> + <linearGradient + x1="-7935.1431" + y1="-747.9668" + x2="-7815.856" + y2="-747.9668" + id="linearGradient7384" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"> + <stop + id="stop7386" + style="stop-color:#9e2064;stop-opacity:1" + offset="0.3233"/> + <stop + id="stop7388" + style="stop-color:#c92037;stop-opacity:1" + offset="0.63020003"/> + <stop + id="stop7390" + style="stop-color:#cd2335;stop-opacity:1" + offset="0.75139999"/> + <stop + id="stop7392" + style="stop-color:#e97826;stop-opacity:1" + offset="1"/> + </linearGradient> + <path + d="m 220.8,236.9 c 0,0 0,0 0,0 l 0,0 0,0 0,0 c 0,0 0,0 0,0 z" + id="path7394" + style="fill:url(#linearGradient7414)"/> + </g> + <g + style="font-style:italic;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:100px;line-height:125%;font-family:'Alte Haas Grotesk';-inkscape-font-specification:'Sans Italic';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none" + id="text5492"> + <path + d="m 23.541406,2.7166473 13.1,0 q 1.6,0 3.2,0 1.7,0 2.4,0.7 0.6,0.5 0.7,1.5 0.1,0.9 0.3,1.8 0.2,1.6 0.4,3.2999997 0.3,1.6 0.5,3.3 1.1,6.3 1.8,12.8 0.8,6.5 1.9,12.9 0.4,2 0.6,4.1 0.2,2.1 0.6,4.1 0.1,0.5 0.2,1 0.1,0.5 0.5,0.8 0.2,0.1 0.3,0.2 0.2,0.1 0.5,-0.1 0.8,-0.2 1.3,-1.2 0.5,-1 1,-1.8 1.2,-2.3 2.3,-4.5 1.1,-2.3 2.4,-4.6 3.2,-6.1 6.4,-12.2 3.3,-6.2 6.5,-12.4 0.8,-1.6 1.6,-3.0999997 0.9,-1.6 1.7,-3.2 0.4,-0.8 0.9,-1.6 0.5,-0.8 1.4,-1.3 0.7,-0.5 1.6,-0.5 1,0 2,0 l 6.5,0 6.9,0 q 0.9,0 1.8,0 1,0 1.4,0.4 1,0.6 0.6,2.3 -0.3,1.6 -0.6,3.3 l -3,14.9999997 -7.5,37.2 -1.7,8.7 q -0.2,1.1 -0.5,2.2 -0.3,1 -1,1.5 -0.7,0.5 -1.6,0.6 -0.9,0 -2,0 l -4.8,0 -2.7,0 q -0.7,-0.2 -1.3,-0.3 -0.5,-0.1 -0.8,-0.7 -0.3,-0.5 -0.2,-1.3 0.2,-0.8 0.4,-1.7 l 1,-5.1 5.2,-25.7 q 0.2,-1.4 0.4,-2.6 0.3,-1.3 0.5,-2.6 0.2,-0.8 0.4,-1.6 0.2,-0.9 0.2,-1.7 -0.1,-0.7 0,-1.5 0.2,-0.8 -0.3,-1 -0.3,-0.1 -0.5,0.1 -0.2,0.2 -0.3,0.3 -0.5,0.4 -0.9,1 -0.3,0.5 -0.6,1 -0.9,1.5 -1.8,3.1 -0.8,1.6 -1.8,3.2 -0.3,0.6 -0.6,1.2 -0.2,0.6 -0.6,1.2 -0.8,1.3 -1.5,2.6 -0.6,1.3 -1.4,2.6 -0.2,0.3 -0.3,0.7 -0.1,0.3 -0.3,0.6 -0.6,0.9 -1.1,1.9 -0.4,1 -1.1,2 -0.6,0.9 -1.1,1.9 -0.4,1 -1,2 -1.8,2.9 -3.3,5.9 -1.5,2.9 -3.1,5.8 -0.3,0.3 -0.4,0.6 0,0.3 -0.3,0.6 -0.7,1.1 -1.3,2.3 -0.5,1.1 -1.2,2.2 -0.4,0.7 -0.8,1.3 -0.4,0.6 -0.9,1 -0.6,0.4 -1.1,0.5 -0.5,0 -1.3,0.2 l -2.3,0 q -0.7,0 -1.7,0.1 -0.9,0 -1.9,0 -0.9,0 -1.7,-0.1 -0.8,-0.1 -1.1,-0.4 -0.7,-0.5 -0.9,-1.1 -0.1,-0.7 -0.4,-1.6 -0.2,-1.2 -0.3,-2.4 -0.1,-1.3 -0.4,-2.5 l -0.1,-0.9 q -0.3,-1.2 -0.4,-2.5 -0.1,-1.4 -0.4,-2.6 0,-0.3 0,-0.5 0,-0.3 -0.1,-0.6 -0.3,-0.9 -0.4,-1.9 -0.1,-1 -0.3,-2 0,-0.2 0,-0.5 0,-0.3 -0.1,-0.5 -0.2,-1 -0.3,-2 0,-1 -0.3,-2 -0.4,-2 -0.7,-4.2 -0.2,-2.2 -0.6,-4.3 -0.4,-2.5 -0.7,-5.1 -0.2,-2.6 -0.9,-5 -0.2,-1.4 -0.6,-2.3 -0.2,-0.2 -0.4,-0.3 -0.1,-0.2 -0.4,0 -0.6,0.3 -0.8,1 -0.1,0.7 -0.4,1.4 -0.4,0.7 -0.5,1.5 -0.1,0.7 -0.2,1.5 -0.2,1.1 -0.5,2.2 -0.2,1.1 -0.5,2.2 l -5.3,26.6 -1,4.9 q -0.2,0.8 -0.4,1.6 -0.1,0.8 -0.6,1.3 -0.5,0.7 -1.7,0.9 -0.7,0.2 -1.5,0.2 -0.8,-0.1 -1.6,-0.1 l -5.2,0 q -1.1000002,0 -2.0000002,0 -0.9,-0.1 -1.4,-0.6 -0.5,-0.5 -0.4,-1.5 0.2,-1.1 0.4,-2.2 l 1.7,-8.8 7.5000002,-37.2 2.8,-13.9999997 q 0.1,-0.6 0.2,-1.4 0.2,-0.9 0.4,-1.7 0.2,-0.8 0.4,-1.5 0.3,-0.8 0.5,-1.2 0.6,-0.7 1.8,-1 0.3,-0.1 0.4,0 0.2,0 0.5,-0.1 z" + style="" + id="path4317"/> + <path + d="m 143.06641,70.016647 q 0,1.1 -0.2,2.2 -0.2,1.1 -1.3,1.5 -0.7,0.3 -1.5,0.3 -0.8,0 -1.6,0 l -5.4,0 q -0.9,0 -1.8,0 -0.8,-0.1 -1.2,-0.5 -0.6,-0.4 -0.8,-1.1 -0.2,-0.8 -0.7,-1.3 -0.2,-0.2 -0.5,-0.3 -0.2,-0.2 -0.7,-0.1 -0.6,0.2 -1.1,0.5 -0.5,0.3 -1,0.5 -0.6,0.4 -1.3,0.7 -0.6,0.3 -1.3,0.6 -1.4,0.6 -2.9,1 -1.5,0.3 -3,0.7 -0.8,0.2 -1.5,0.2 -0.6,0.1 -1.3,0.2 -0.3,0 -0.6,0 -0.3,0.1 -0.6,0.1 l -1.1,0 q -1.1,0.2 -2,0 l -0.9,0 q -0.7,-0.2 -1.4,-0.2 -0.6,0.1 -1.2,-0.1 -0.9,-0.2 -1.8,-0.4 -0.9,-0.1 -1.6,-0.5 -2.7,-1.1 -4.400004,-2.8 -1.7,-1.8 -2.3,-4.7 -0.2,-0.7 -0.3,-1.5 0,-0.8 -0.1,-1.7 -0.1,-0.5 0,-1 0.2,-0.5 0.2,-1 0,-0.3 0.1,-1.2 0.2,-1 0.4,-1.4 0.4,-1 0.5,-1.7 0.5,-1.1 1,-2.2 0.6,-1.2 1.3,-2.1 2.200004,-2.9 4.700004,-4.4 2.5,-1.5 6.2,-2.6 1.4,-0.5 2.8,-0.7 1.4,-0.2 2.9,-0.5 0.8,-0.2 1.7,-0.2 1,-0.1 1.9,-0.3 0.7,-0.2 1.4,-0.1 0.7,0 1.6,-0.2 0.7,-0.2 1.4,-0.2 0.7,0 1.5,-0.2 2.2,-0.5 4,-0.8 1.9,-0.4 3.6,-1.8 1,-0.9 1.6,-2 0.1,-0.3 0.1,-0.5 0,-0.2 0.1,-0.4 0.2,-0.2 0.2,-0.6 0.1,-0.4 0.2,-0.6 0,-0.4 0,-0.8 0,-0.4 0,-0.7 -0.4,-3 -3.4,-4.1 -0.8,-0.3 -2.1,-0.4 -1.2,-0.2 -2.5,-0.1 -1.3,0 -2.6,0.2 -1.2,0.2 -2.1,0.5 -0.7,0.2 -1.3,0.6 -0.6,0.3 -1.2,0.7 -0.6,0.4 -1.3,1.1 -0.7,0.7 -1,1.3 -0.7,1 -1.2,1.9 -0.5,0.9 -1.7,1.2 -0.8,0.2 -1.7,0.2 -0.9,0 -1.8,0 l -3.8,0 q -0.5,0 -1.1,0.1 -0.5,0 -0.8,-0.1 l -0.9,0 q -0.2,-0.1 -0.5,-0.1 -0.3,0 -0.5,-0.2 -0.7,-0.2 -0.8,-1.3 0,-0.5 0.2,-1 0.2,-0.5 0.4,-0.9 0.5,-1.1 1,-2 0.6,-1 1.2,-1.8 0.4,-0.5 0.8,-1 0.4,-0.5 0.8,-1 1,-1.1 2.4,-2.1 0.3,-0.1 0.7,-0.5 0.6,-0.4 1,-0.7 0.5,-0.3 1.1,-0.6 1.9,-1.1 3.9,-1.7 2.1,-0.7 4.2,-1.3 1.3,-0.3 2.6,-0.4 1.3,-0.1 2.7,-0.4 0.4,-0.1 1.2,0 0.8,0.1 1.1,-0.1 4.1,-0.1 7.7,0.3 3.7,0.4 6.5,1.5 2.9,1.1 4.7,3 1.9,1.8 2.5,4.7 0.3,1.7 0,3.9 -0.3,2.2 -0.8,4.5 l -4.5,22.3 q -0.3,1.9 -0.7,3.9 -0.4,1.9 -0.3,3.5 0,0.3 -0.1,0.7 0,0.3 0,0.6 z m -11.6,-15.4 q 0.2,-0.5 0.3,-1.1 0.1,-0.7 0.1,-1.2 0,-0.6 0.1,-1.1 0.1,-0.5 -0.3,-0.8 -0.4,-0.4 -1.4,-0.4 -0.4,0.1 -0.7,0.2 -0.3,0 -0.8,0.1 -0.7,0.2 -1.5,0.3 -0.8,0.1 -1.7,0.3 -0.3,0.1 -0.9,0.1 -1.4,0.3 -2.7,0.4 -1.3,0.1 -2.6,0.5 -0.8,0.2 -1.6,0.4 -0.7,0.1 -1.4,0.4 -2.3,0.9 -4.1,2.7 -1.8,1.8 -2.1,5 -0.1,1.7 0.6,2.8 0.4,1.1 1.7,1.8 1.3,0.6 2.9,0.9 1.6,0.3 3.4,0.2 1.9,-0.2 3.6,-0.7 2.8,-0.8 4.6,-2.5 1.9,-1.8 3.2,-4.4 0.3,-0.7 0.5,-1.4 0.2,-0.8 0.6,-1.6 l 0.2,-0.9 z" + style="" + id="path4319"/> + <path + d="m 161.28828,22.416647 7.3,0 q 1.1,0 2.1,0.1 1,0 1.6,0.4 1,0.7 1,2.6 0.1,1.8 0.4,3.2 0.4,3.3 0.7,6.8 0.3,3.4 0.7,6.8 0.4,2.4 0.6,4.9 0.2,2.5 0.6,4.8 0.1,0.9 0.2,1.9 0.2,1 1.3,1 0.3,-0.2 0.4,-0.2 0.1,-0.1 0.3,-0.3 0.4,-0.5 0.7,-1 0.3,-0.5 0.6,-1.1 0.8,-1.1 1.2,-2.3 0.5,-1.2 1.2,-2.3 2.2,-4.2 4.3,-8.4 2.1,-4.3 4.3,-8.5 0.8,-1.2 1.3,-2.4 0.6,-1.3 1.2,-2.4 0.4,-0.8 0.8,-1.6 0.5,-0.8 1.2,-1.3 0.3,-0.2 1.4,-0.6 0.6,-0.2 1.3,-0.1 0.7,0 1.3,0 l 4.9,0 q 1.1,0 2,0.1 1,0 1.4,0.5 0.5,0.5 0.1,1.5 -0.3,0.9 -0.6,1.5 -0.8,1.4 -1.6,3 -0.8,1.5 -1.6,2.9 -0.4,0.7 -0.7,1.4 -0.3,0.6 -0.6,1.2 -0.7,1.1 -1.3,2.2 -0.6,1.1 -1.2,2.2 -0.1,0.3 -0.3,0.7 -0.1,0.3 -0.3,0.6 -0.9,1.5 -1.7,3.1 -0.8,1.5 -1.6,3 -1.7,3 -3.3,6.2 -1.6,3.1 -3.4,6.1 -0.8,1.4 -1.5,2.8 -0.6,1.3 -1.4,2.7 -0.3,0.5 -0.5,0.9 -0.2,0.3 -0.5,0.8 -0.6,1.1 -1.2,2.3 -0.5,1.1 -1.2,2.2 -0.7,1.1 -1.3,2.1 -0.6,0.9 -1.7,1.3 -0.9,0.3 -1.8,0.3 -0.9,-0.1 -1.8,-0.1 l -6.5,0 q -1.1,0 -2.2,0 -1,0 -1.7,-0.4 -0.6,-0.5 -0.8,-1.2 -0.1,-0.8 -0.2,-1.7 -0.3,-1.2 -0.5,-2.5 -0.1,-1.3 -0.3,-2.5 -0.1,-0.4 -0.1,-0.7 0,-0.4 -0.1,-0.9 -0.3,-1.2 -0.4,-2.5 -0.1,-1.3 -0.4,-2.6 -0.1,-0.5 -0.1,-0.9 0,-0.5 -0.1,-1 -0.2,-0.9 -0.3,-1.8 -0.1,-1 -0.3,-1.9 -0.1,-0.3 -0.1,-0.6 0.1,-0.4 0,-0.7 -0.2,-0.9 -0.3,-1.8 -0.1,-0.9 -0.3,-1.9 -0.4,-2.3 -0.7,-4.7 -0.3,-2.5 -0.6,-4.9 -0.6,-2.7 -0.9,-5.4 -0.2,-2.8 -0.7,-5.5 l -0.3,-2.7 q -0.1,-0.3 -0.1,-0.7 0.1,-0.5 0.4,-0.9 0.4,-0.7 1.6,-1 0.5,0 0.7,-0.1 z" + style="fill:none;stroke:none" + id="path4321"/> + <path + d="m 259.04141,47.716647 q 0,0.8 -0.4,1.8 -0.4,1 -1,1.3 -0.5,0.4 -1.5,0.6 -1,0.1 -2.2,0.2 -1.1,0 -2.3,0 -1.1,-0.1 -2,-0.1 l -24.4,0 q -0.7,0 -1.4,0 -0.6,0 -1.1,0.2 -0.9,0.4 -1.2,0.8 -0.2,0.2 -0.6,0.8 -0.3,0.5 -0.3,1 0.1,0.6 0,1.2 0,0.5 0.1,1.1 0.3,2.4 1.1,4 0.9,1.5 2.6,2.7 0.7,0.5 1.5,0.7 0.9,0.1 1.7,0.4 0.8,0.2 2.1,0.3 1.4,0.1 2.5,-0.1 l 0.9,0 q 1,-0.2 1.9,-0.4 0.9,-0.3 1.8,-0.6 1.1,-0.5 2.5,-1.3 1.4,-0.8 2.2,-1.6 0.6,-0.7 1.3,-1.3 0.7,-0.7 1.5,-1 1.1,-0.5 2.6,-0.4 1.6,0 2.9,0 0.6,0 1.2,0 0.7,-0.1 1.2,0.1 l 1,0 q 0.9,0.2 1.3,0.5 0.3,0.2 0.2,0.9 0,0.7 -0.3,1.2 -0.8,1.4 -1.7,2.5 -0.8,1.1 -1.8,2.2 -2.8,3.3 -6,5.3 -3.2,2 -7.7,3.4 -1.2,0.4 -2.3,0.5 -1.1,0.1 -2.4,0.4 -0.4,0.1 -0.9,0 -0.4,0 -0.8,0.1 l -1.1,0 q -0.6,0.2 -1.2,0.1 -0.6,0 -1.1,-0.1 -0.8,-0.1 -1.4,0 -0.6,0.1 -1.3,-0.1 -0.5,-0.2 -1.1,-0.2 -0.6,0 -1,-0.2 -1.1,-0.2 -2.2,-0.5 -1,-0.2 -1.8,-0.7 -1,-0.4 -1.9,-0.7 -0.9,-0.4 -1.6,-0.9 -2.8,-2 -4.8,-4.6 -1.9,-2.7 -2.8,-6.2 -0.3,-1.1 -0.4,-2.2 0,-1.2 -0.3,-2.4 0,-0.4 0,-0.7 0.1,-0.4 0.1,-0.8 -0.1,-1.2 0,-2.6 0.2,-1.4 0.4,-2.8 0.1,-0.5 0.1,-1.1 0.1,-0.6 0.3,-1.1 l 0.3,-1.2 0.8,-2.4 q 0.7,-1.7 1.3,-3.3 0.6,-1.6 1.5,-3 6.4,-10.4 17.6,-14.7 1.5,-0.6 3,-0.8 1.5,-0.3 3.2,-0.7 0.8,-0.1 1.5,-0.1 0.7,0 1.5,-0.1 5.1,-0.1 8.5,1.2 3.4,1.2 5.9,3.2 0.8,0.6 1.5,1.4 0.8,0.7 1.3,1.5 0.2,0.5 0.7,0.8 0.6,1.1 1,2.3 0.5,1.1 1.1,2.3 0.3,0.9 0.4,1.9 0.2,0.9 0.4,2 0.2,1.3 0.2,2.7 0.1,1.4 0.2,2.8 0,0.8 -0.3,1.8 -0.2,0.9 -0.1,1.7 l -0.2,1.1 z m -13.9,-5.9 q 0.9,-1 0.6,-2.4 -0.2,-1.5 -0.3,-2.2 -0.9,-2.7 -2.9,-4.1 -2,-1.5 -6.1,-1.6 -0.3,0.2 -0.7,0.1 -0.4,-0.1 -0.7,0 -0.6,0.2 -1.2,0.3 -0.6,0 -1.1,0.2 -4.7,1.4 -7.6,5.5 -0.3,0.4 -0.7,1.1 -0.4,0.6 -0.6,1.3 -0.2,0.6 -0.2,1.2 0,0.6 0.5,1 0.7,0.5 2.1,0.5 1.4,0 2.7,0 l 11.1,0 q 1.4,0 2.9,0 1.6,-0.1 2.2,-0.9 z" + style="" + id="path4323"/> + <path + d="m 302.16328,21.116647 q 6,-0.2 9.6,1.7 3.7,1.9 5.2,5.6 0.5,1.1 0.6,2.4 0.2,1.2 0.3,2.5 0.1,0.8 0,1.5 -0.1,0.7 0,1.4 -0.2,0.6 -0.1,0.8 -0.1,1.4 -0.4,2.9 -0.3,1.5 -0.6,2.9 l -1.7,8.9 -3.3,16.2 q -0.4,1.9 -0.8,3.7 -0.4,1.7 -1.9,2.2 -0.6,0.2 -1.4,0.2 -0.8,0 -1.6,0 l -5.4,0 q -1.2,0 -2.1,-0.1 -0.9,-0.2 -1.3,-0.9 -0.3,-0.6 -0.2,-1.5 0.2,-1 0.4,-2.1 l 1.4,-7 3,-14.9 q 0.7,-3.7 1,-6.8 0.4,-3.2 -0.7,-5.4 -1,-2 -3.5,-2.8 -0.5,-0.2 -1.1,-0.2 -0.5,0 -1,-0.2 -0.5,-0.1 -1.3,0 -0.7,0 -1.1,0.1 -0.5,0.1 -0.8,0.1 -0.3,0 -0.6,0.1 -2.4,0.6 -4,1.6 -3.7,2.3 -5.2,6.7 -1.4,4.4 -2.5,9.9 l -2.5,12.5 -1.2,6.1 q -0.2,0.9 -0.4,1.8 -0.2,0.9 -0.6,1.5 -0.7,1.1 -1.9,1.3 -1.1,0.2 -2.7,0.2 l -5,0 q -1.1,0 -2.2,-0.1 -1.1,-0.1 -1.4,-0.7 -0.6,-0.9 -0.2,-2.6 0.4,-1.7 0.7,-3.2 l 2.7,-13.6 4.4,-22 1.1,-5.1 q 0.2,-1.1 0.4,-2 0.2,-0.9 0.9,-1.5 0.2,-0.3 0.7,-0.4 0.5,-0.2 1,-0.3 l 0.5,0 q 0.5,-0.1 1,-0.1 0.6,0 1.1,0 l 4.2,0 q 0.8,0 1.5,0.1 0.8,0 1.4,0.2 0.6,0.3 0.7,0.9 0.2,0.6 0.2,1.4 0,0.4 -0.1,0.7 -0.1,0.3 0,0.6 0.1,0.5 0.2,0.6 0.2,0.1 0.5,0.3 1,0.1 1.9,-0.7 0.9,-0.9 1.8,-1.4 3.1,-2 6.6,-3.2 1,-0.3 1.9,-0.4 1,-0.1 2.2,-0.3 0.3,-0.1 0.9,0 0.6,0 0.8,-0.1 z" + style="" + id="path4325"/> + </g> + <g + style="font-style:italic;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:'Alte Haas Grotesk';-inkscape-font-specification:'Sans Italic';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none" + id="text9112"> + <path + d="m 326.92482,21.038048 q 0.1,0.08 0.1,0.34 0,0.26 -0.1,0.48 l -0.02,0.16 q -0.08,0.18 -0.18,0.3 -0.08,0.1 -0.26,0.16 -0.18,0.04 -0.5,0.04 -0.32,-0.02 -0.54,-0.02 l -0.3,0 q -0.1,0.04 -0.18,0.02 -0.08,-0.02 -0.16,0.02 -0.22,0.08 -0.38,0.38 -0.06,0.1 -0.08,0.24 -0.02,0.14 -0.04,0.28 l -0.96,4.72 q -0.02,0.1 -0.02,0.18 0,0.08 -0.04,0.16 l -0.04,0.16 q -0.02,0.06 -0.04,0.12 0,0.06 -0.06,0.1 -0.08,0.16 -0.26,0.22 -0.1,0.04 -0.24,0.04 -0.12,0 -0.28,0 -0.28,0 -0.62,0 -0.34,0 -0.46,-0.16 -0.06,-0.12 -0.04,-0.28 0.04,-0.16 0.08,-0.36 l 0.94,-4.72 q 0.02,-0.1 0.04,-0.2 0.04,-0.1 0.02,-0.18 l 0.04,-0.28 q 0.02,-0.32 -0.2,-0.4 -0.18,-0.1 -0.54,-0.08 -0.34,0.02 -0.6,0.02 -0.1,0 -0.2,0.02 -0.08,0 -0.14,-0.02 -0.08,-0.04 -0.14,-0.02 -0.06,0 -0.12,-0.02 -0.2,-0.1 -0.18,-0.32 0.02,-0.22 0.08,-0.52 0.02,-0.12 0.04,-0.22 0.04,-0.1 0.1,-0.2 0.06,-0.1 0.16,-0.14 0.1,-0.06 0.2,-0.1 0.06,-0.02 0.08,0 0.04,0 0.1,-0.02 l 5.34,0 q 0.18,0 0.34,0.02 0.16,0 0.26,0.08 z m 10.64,0.04 q 0.08,0.14 0.04,0.32 -0.02,0.18 -0.06,0.4 l -1.3,6.5 q -0.04,0.22 -0.1,0.4 -0.04,0.16 -0.14,0.28 -0.14,0.16 -0.44,0.16 -0.28,0 -0.56,0 -0.12,0 -0.26,0.02 -0.12,0 -0.2,-0.04 -0.18,-0.06 -0.22,-0.18 -0.02,-0.12 -0.02,-0.3 l 0.06,-0.34 q 0,-0.06 0.02,-0.14 0.02,-0.1 0.04,-0.18 l 0.52,-2.54 q 0.04,-0.24 0.08,-0.48 0.06,-0.24 0.06,-0.44 -0.02,-0.1 -0.02,-0.16 0,-0.08 -0.06,-0.12 -0.02,-0.02 -0.06,-0.02 -0.06,0.04 -0.14,0.08 -0.2,0.24 -0.36,0.54 -0.16,0.3 -0.34,0.58 -0.36,0.62 -0.7,1.26 -0.34,0.62 -0.7,1.22 -0.16,0.28 -0.34,0.64 -0.18,0.34 -0.42,0.5 -0.12,0.08 -0.28,0.1 -0.16,0 -0.34,0 l -0.3,0 q -0.1,-0.04 -0.18,-0.06 -0.08,-0.04 -0.14,-0.1 -0.06,-0.06 -0.08,-0.16 -0.02,-0.1 -0.04,-0.2 -0.06,-0.18 -0.08,-0.36 -0.02,-0.2 -0.06,-0.4 -0.12,-0.58 -0.2,-1.18 -0.08,-0.62 -0.2,-1.2 -0.06,-0.34 -0.12,-0.68 -0.04,-0.34 -0.22,-0.58 -0.04,0 -0.06,0.02 -0.02,0 -0.04,0 -0.1,0.08 -0.14,0.18 -0.06,0.1 -0.08,0.2 0,0.08 -0.04,0.18 l -0.06,0.34 q -0.04,0.08 -0.06,0.16 -0.02,0.08 -0.02,0.14 l -0.48,2.32 q -0.04,0.26 -0.12,0.64 -0.06,0.36 -0.18,0.52 -0.06,0.04 -0.12,0.1 -0.04,0.04 -0.1,0.06 -0.1,0.04 -0.24,0.06 -0.12,0 -0.28,0 -0.26,0 -0.52,0 -0.26,0 -0.4,-0.12 -0.1,-0.08 -0.1,-0.26 0.02,-0.18 0.06,-0.4 l 1.32,-6.6 q 0.04,-0.18 0.08,-0.34 0.06,-0.18 0.14,-0.28 0.1,-0.14 0.32,-0.18 0.06,-0.02 0.08,0 0.04,0 0.1,-0.02 l 1.32,0 q 0.22,0 0.42,0 0.2,0 0.3,0.1 0.16,0.12 0.18,0.38 0.04,0.26 0.1,0.48 0.1,0.56 0.2,1.14 0.1,0.56 0.2,1.14 0.08,0.3 0.12,0.62 0.06,0.32 0.12,0.62 0.04,0.12 0.06,0.26 0.04,0.12 0.16,0.16 0.1,0.04 0.18,-0.04 0.1,-0.08 0.14,-0.14 0.2,-0.22 0.32,-0.46 0.14,-0.26 0.28,-0.5 0.42,-0.66 0.78,-1.34 0.38,-0.7 0.8,-1.36 0.16,-0.28 0.32,-0.58 0.18,-0.32 0.48,-0.44 0.14,-0.04 0.28,-0.04 0.16,0 0.32,0 l 0.88,0 q 0.12,0 0.24,0 0.12,-0.02 0.22,0 l 0.1,0 q 0.08,0.04 0.16,0.06 0.1,0.02 0.12,0.08 z" + style="" + id="path4328"/> + </g> + <g + transform="matrix(0.13272567,0.01947468,-0.01947468,0.13272567,170.19741,12.570146)" + id="g4701"> + <linearGradient + x1="-7708.7969" + y1="-803.36011" + x2="-7633.1528" + y2="-714.90741" + id="SVGID_1_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"> + <stop + id="stop4704" + style="stop-color:#f69923;stop-opacity:1" + offset="0"/> + <stop + id="stop4706" + style="stop-color:#f79a23;stop-opacity:1" + offset="0.3123"/> + <stop + id="stop4708" + style="stop-color:#e97826;stop-opacity:1" + offset="0.83829999"/> + </linearGradient> + <path + d="m 267.1,19.6 c -8.4,5 -22.4,19 -39,39.3 l 15.3,28.9 c 10.7,-15.4 21.7,-29.2 32.7,-41 0.8,-0.9 1.3,-1.4 1.3,-1.4 -0.4,0.5 -0.9,0.9 -1.3,1.4 -3.6,3.9 -14.4,16.5 -30.7,41.6 15.7,-0.8 39.8,-4 59.5,-7.4 5.9,-32.8 -5.7,-47.8 -5.7,-47.8 0,0 -14.8,-23.9 -32.1,-13.6 z" + id="path4710" + style="fill:url(#linearGradient5344)"/> + <path + d="m 241.1,184.4 c 0.1,0 0.2,0 0.3,-0.1 l -2.2,0.2 c -0.1,0.1 -0.3,0.1 -0.4,0.2 0.8,-0.1 1.6,-0.2 2.3,-0.3 z" + id="path4712" + style="fill:none"/> + <path + d="m 225.5,236.1 c -1.2,0.3 -2.5,0.5 -3.8,0.7 1.3,-0.2 2.6,-0.4 3.8,-0.7 z" + id="path4714" + style="fill:none"/> + <path + d="m 119.3,352.2 c 0.2,-0.4 0.3,-0.9 0.5,-1.3 3.4,-8.9 6.7,-17.5 10,-26 3.7,-9.4 7.4,-18.6 11,-27.5 3.8,-9.3 7.6,-18.4 11.3,-27.1 3.9,-9.2 7.7,-18 11.5,-26.5 3.1,-6.9 6.1,-13.6 9.1,-20.1 1,-2.2 2,-4.3 3,-6.4 2,-4.2 3.9,-8.3 5.8,-12.3 1.8,-3.7 3.5,-7.3 5.2,-10.9 0.6,-1.2 1.2,-2.4 1.7,-3.5 0.1,-0.2 0.2,-0.4 0.3,-0.6 l -1.9,0.2 -1.5,-2.9 c -0.1,0.3 -0.3,0.6 -0.4,0.9 -2.7,5.3 -5.4,10.7 -8,16.2 -1.5,3.1 -3,6.3 -4.6,9.5 -4.2,8.8 -8.3,17.6 -12.3,26.6 -4.1,9 -8.1,18.1 -12,27.1 -3.9,8.9 -7.6,17.8 -11.3,26.7 -3.7,8.9 -7.3,17.7 -10.8,26.5 -3.7,9.2 -7.3,18.3 -10.7,27.3 -0.8,2 -1.6,4.1 -2.3,6.1 -2.8,7.3 -5.5,14.4 -8.1,21.5 l 2.4,4.7 2.1,-0.2 c 0.1,-0.2 0.2,-0.4 0.2,-0.6 3.1,-9.5 6.5,-18.6 9.8,-27.4 z" + id="path4716" + style="fill:none"/> + <path + d="m 220.7,236.9 0,0 c 0,0 0,0 0,0 0,0 0,0 0,0 z" + id="path4718" + style="fill:none"/> + <path + d="m 215.6,262.2 c -2,0.4 -4,0.7 -6,1 0,0 0,0 0,0 1,-0.1 2.1,-0.3 3.1,-0.5 1,-0.1 2,-0.3 2.9,-0.5 z" + id="path4720" + style="fill:#be202e"/> + <path + d="m 215.6,262.2 c -2,0.4 -4,0.7 -6,1 0,0 0,0 0,0 1,-0.1 2.1,-0.3 3.1,-0.5 1,-0.1 2,-0.3 2.9,-0.5 z" + id="path4722" + style="opacity:0.35;fill:#be202e"/> + <path + d="m 220.8,236.9 c 0,0 0,0 0,0 -0.1,0 -0.1,0 0,0 0.3,0 0.6,-0.1 0.9,-0.1 1.3,-0.2 2.6,-0.4 3.8,-0.7 -1.5,0.3 -3.1,0.5 -4.7,0.8 l 0,0 0,0 z" + id="path4724" + style="fill:#be202e"/> + <path + d="m 220.8,236.9 c 0,0 0,0 0,0 -0.1,0 -0.1,0 0,0 0.3,0 0.6,-0.1 0.9,-0.1 1.3,-0.2 2.6,-0.4 3.8,-0.7 -1.5,0.3 -3.1,0.5 -4.7,0.8 l 0,0 0,0 z" + id="path4726" + style="opacity:0.35;fill:#be202e"/> + <linearGradient + x1="-8268.6387" + y1="-813.12323" + x2="-7728.9585" + y2="-813.12323" + id="SVGID_2_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"> + <stop + id="stop4729" + style="stop-color:#9e2064;stop-opacity:1" + offset="0.3233"/> + <stop + id="stop4731" + style="stop-color:#c92037;stop-opacity:1" + offset="0.63020003"/> + <stop + id="stop4733" + style="stop-color:#cd2335;stop-opacity:1" + offset="0.75139999"/> + <stop + id="stop4735" + style="stop-color:#e97826;stop-opacity:1" + offset="1"/> + </linearGradient> + <path + d="m 198.2,162.4 c 4.7,-8.7 9.4,-17.2 14.1,-25.5 4.9,-8.6 9.9,-16.9 15,-25 0.3,-0.5 0.6,-1 0.9,-1.4 5,-7.9 10,-15.5 15.1,-22.8 L 228,58.9 c -1.1,1.4 -2.3,2.8 -3.5,4.3 -4.4,5.5 -9,11.4 -13.7,17.7 -5.3,7.1 -10.7,14.6 -16.3,22.5 -5.1,7.3 -10.3,15 -15.5,22.9 -4.4,6.8 -8.8,13.7 -13.2,20.8 -0.2,0.3 -0.3,0.5 -0.5,0.8 l 19.9,39.3 c 4.4,-8.3 8.7,-16.6 13,-24.8 z" + id="path4737" + style="fill:url(#linearGradient5346)"/> + <linearGradient + x1="-8203.4922" + y1="-758.99402" + x2="-7881.895" + y2="-758.99402" + id="SVGID_3_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"> + <stop + id="stop4740" + style="stop-color:#282662;stop-opacity:1" + offset="0"/> + <stop + id="stop4742" + style="stop-color:#662e8d;stop-opacity:1" + offset="0.0954839"/> + <stop + id="stop4744" + style="stop-color:#9f2064;stop-opacity:1" + offset="0.78820002"/> + <stop + id="stop4746" + style="stop-color:#cd2032;stop-opacity:1" + offset="0.94870001"/> + </linearGradient> + <path + d="m 107.5,384.1 c -2.6,7.2 -5.3,14.6 -7.9,22.2 0,0.1 -0.1,0.2 -0.1,0.3 -0.4,1.1 -0.8,2.1 -1.1,3.2 -1.8,5.1 -3.3,9.7 -6.9,20.1 5.9,2.7 10.6,9.7 15,17.7 -0.5,-8.3 -3.9,-16.1 -10.4,-22.1 28.9,1.3 53.9,-6 66.7,-27.2 1.1,-1.9 2.2,-3.9 3.2,-6 -5.9,7.4 -13.1,10.6 -26.8,9.8 0,0 -0.1,0 -0.1,0 0,0 0.1,0 0.1,0 20.1,-9 30.2,-17.7 39.1,-32 2.1,-3.4 4.2,-7.1 6.3,-11.2 -17.6,18.1 -38,23.2 -59.5,19.3 L 109,380 c -0.5,1.4 -1,2.7 -1.5,4.1 z" + id="path4748" + style="fill:url(#linearGradient5348)"/> + <linearGradient + x1="-8238.3281" + y1="-818.15222" + x2="-7698.647" + y2="-818.15222" + id="SVGID_4_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"> + <stop + id="stop4751" + style="stop-color:#9e2064;stop-opacity:1" + offset="0.3233"/> + <stop + id="stop4753" + style="stop-color:#c92037;stop-opacity:1" + offset="0.63020003"/> + <stop + id="stop4755" + style="stop-color:#cd2335;stop-opacity:1" + offset="0.75139999"/> + <stop + id="stop4757" + style="stop-color:#e97826;stop-opacity:1" + offset="1"/> + </linearGradient> + <path + d="m 115,348 c 3.5,-9 7.1,-18.1 10.7,-27.3 3.5,-8.8 7.1,-17.6 10.8,-26.5 3.7,-8.9 7.5,-17.8 11.3,-26.7 3.9,-9.1 7.9,-18.1 12,-27.1 4,-8.9 8.2,-17.8 12.3,-26.6 1.5,-3.2 3,-6.3 4.6,-9.5 2.6,-5.4 5.3,-10.8 8,-16.2 0.1,-0.3 0.3,-0.6 0.4,-0.9 L 165.4,148 c -0.3,0.5 -0.6,1.1 -1,1.6 -4.6,7.6 -9.3,15.3 -13.8,23.2 -4.6,8 -9.1,16.1 -13.5,24.4 -3.7,7 -7.3,14 -10.9,21.1 -0.7,1.4 -1.4,2.9 -2.1,4.3 -4.3,8.9 -8.3,17.6 -11.8,25.9 -4,9.4 -7.5,18.4 -10.6,26.9 -2,5.6 -3.9,11 -5.6,16.2 -1.4,4.4 -2.7,8.9 -4,13.3 -3,10.4 -5.5,20.8 -7.6,31.2 l 20,39.5 c 2.6,-7.1 5.4,-14.2 8.1,-21.5 0.8,-2 1.6,-4 2.4,-6.1 z" + id="path4759" + style="fill:url(#linearGradient5350)"/> + <linearGradient + x1="-8198.9678" + y1="-810.85059" + x2="-7915.3501" + y2="-810.85059" + id="SVGID_5_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"> + <stop + id="stop4762" + style="stop-color:#282662;stop-opacity:1" + offset="0"/> + <stop + id="stop4764" + style="stop-color:#662e8d;stop-opacity:1" + offset="0.0954839"/> + <stop + id="stop4766" + style="stop-color:#9f2064;stop-opacity:1" + offset="0.78820002"/> + <stop + id="stop4768" + style="stop-color:#cd2032;stop-opacity:1" + offset="0.94870001"/> + </linearGradient> + <path + d="m 84.2,337.5 c -2.5,12.6 -4.3,25.2 -5.2,37.8 0,0.4 -0.1,0.9 -0.1,1.3 -6.2,-10 -23,-19.8 -22.9,-19.7 12,17.4 21.1,34.6 22.4,51.5 -6.4,1.3 -15.2,-0.6 -25.3,-4.3 10.6,9.7 18.5,12.4 21.6,13.1 -9.7,0.6 -19.8,7.3 -30,15 14.9,-6.1 27,-8.5 35.6,-6.5 -13.7,38.7 -27.4,81.5 -41.1,126.9 4.2,-1.2 6.7,-4.1 8.1,-7.9 2.4,-8.2 18.7,-62.2 44.1,-133.1 0.7,-2 1.5,-4 2.2,-6.1 0.2,-0.6 0.4,-1.1 0.6,-1.7 2.7,-7.4 5.5,-15 8.4,-22.8 0.7,-1.8 1.3,-3.5 2,-5.3 0,0 0,-0.1 0,-0.1 l -20,-39.5 c -0.2,0.5 -0.3,0.9 -0.4,1.4 z" + id="path4770" + style="fill:url(#linearGradient5352)"/> + <linearGradient + x1="-8238.3281" + y1="-762.29712" + x2="-7698.647" + y2="-762.29712" + id="SVGID_6_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"> + <stop + id="stop4773" + style="stop-color:#9e2064;stop-opacity:1" + offset="0.3233"/> + <stop + id="stop4775" + style="stop-color:#c92037;stop-opacity:1" + offset="0.63020003"/> + <stop + id="stop4777" + style="stop-color:#cd2335;stop-opacity:1" + offset="0.75139999"/> + <stop + id="stop4779" + style="stop-color:#e97826;stop-opacity:1" + offset="1"/> + </linearGradient> + <path + d="m 188.4,190.6 c -0.6,1.2 -1.1,2.3 -1.7,3.5 -1.7,3.6 -3.5,7.2 -5.2,10.9 -1.9,4 -3.8,8.1 -5.8,12.3 -1,2.1 -2,4.2 -3,6.4 -3,6.5 -6,13.2 -9.1,20.1 -3.8,8.5 -7.6,17.3 -11.5,26.5 -3.7,8.7 -7.5,17.8 -11.3,27.1 -3.6,8.9 -7.3,18 -11,27.5 -3.3,8.4 -6.6,17.1 -10,26 -0.2,0.4 -0.3,0.9 -0.5,1.3 -3.3,8.8 -6.7,17.9 -10.1,27.2 -0.1,0.2 -0.2,0.4 -0.2,0.6 l 16.1,-1.8 c -0.3,-0.1 -0.6,-0.1 -1,-0.2 19.3,-2.4 44.9,-16.8 61.4,-34.6 7.6,-8.2 14.5,-17.8 20.9,-29.1 4.8,-8.4 9.2,-17.7 13.5,-28.1 3.7,-9 7.3,-18.8 10.7,-29.4 -4.4,2.3 -9.5,4 -15.1,5.2 -1,0.2 -2,0.4 -3,0.6 -1,0.2 -2,0.3 -3.1,0.5 l 0,0 0,0 c 0,0 0,0 0,0 18,-6.9 29.3,-20.2 37.5,-36.6 -4.7,3.2 -12.4,7.4 -21.6,9.5 -1.2,0.3 -2.5,0.5 -3.8,0.7 -0.3,0 -0.6,0.1 -1,0.1 l 0,0 0,0 c 0,0 0,0 0,0 0,0 0,0 0,0 l 0,0 c 6.2,-2.6 11.5,-5.5 16.1,-9 1,-0.7 1.9,-1.5 2.8,-2.3 1.4,-1.2 2.7,-2.5 4,-3.8 0.8,-0.9 1.6,-1.7 2.4,-2.6 1.8,-2.1 3.5,-4.4 5,-6.9 0.5,-0.8 1,-1.5 1.4,-2.3 0.6,-1.2 1.2,-2.3 1.7,-3.4 2.5,-5 4.5,-9.5 6.1,-13.5 0.8,-2 1.5,-3.8 2.1,-5.5 0.2,-0.7 0.5,-1.3 0.7,-2 0.6,-1.9 1.2,-3.6 1.6,-5.1 0.6,-2.2 1,-4 1.2,-5.3 l 0,0 0,0 c -0.6,0.5 -1.3,1 -2.1,1.4 -5.4,3.2 -14.7,6.2 -22.2,7.6 l 14.8,-1.6 -14.8,1.6 c -0.1,0 -0.2,0 -0.3,0.1 -0.7,0.1 -1.5,0.2 -2.3,0.4 0.1,-0.1 0.3,-0.1 0.4,-0.2 l -50.6,5.5 c 0.1,0.4 0,0.6 -0.1,0.7 z" + id="path4781" + style="fill:url(#linearGradient5354)"/> + <linearGradient + x1="-8271.8057" + y1="-765.07068" + x2="-7732.125" + y2="-765.07068" + id="SVGID_7_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"> + <stop + id="stop4784" + style="stop-color:#9e2064;stop-opacity:1" + offset="0.3233"/> + <stop + id="stop4786" + style="stop-color:#c92037;stop-opacity:1" + offset="0.63020003"/> + <stop + id="stop4788" + style="stop-color:#cd2335;stop-opacity:1" + offset="0.75139999"/> + <stop + id="stop4790" + style="stop-color:#e97826;stop-opacity:1" + offset="1"/> + </linearGradient> + <path + d="m 245.4,88.4 c -4.5,6.9 -9.4,14.8 -14.7,23.6 -0.3,0.5 -0.6,0.9 -0.8,1.4 -4.6,7.7 -9.4,16.1 -14.5,25.4 -4.4,8 -9,16.5 -13.8,25.8 -4.2,8 -8.4,16.5 -12.9,25.5 l 50.6,-5.5 c 14.7,-6.8 21.3,-12.9 27.7,-21.8 1.7,-2.4 3.4,-5 5.1,-7.7 5.2,-8.1 10.3,-17 14.8,-25.9 4.4,-8.6 8.3,-17.1 11.2,-24.7 1.9,-4.9 3.4,-9.4 4.5,-13.4 0.9,-3.5 1.6,-6.8 2.2,-10 -19.6,3.3 -43.7,6.5 -59.4,7.3 z" + id="path4792" + style="fill:url(#linearGradient5356)"/> + <path + d="m 212.7,262.8 c -1,0.2 -2,0.3 -3.1,0.5 l 0,0 c 1,-0.2 2,-0.4 3.1,-0.5 z" + id="path4794" + style="fill:#be202e"/> + <path + d="m 212.7,262.8 c -1,0.2 -2,0.3 -3.1,0.5 l 0,0 c 1,-0.2 2,-0.4 3.1,-0.5 z" + id="path4796" + style="opacity:0.35;fill:#be202e"/> + <linearGradient + x1="-8238.3281" + y1="-745.68481" + x2="-7698.647" + y2="-745.68481" + id="SVGID_8_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"> + <stop + id="stop4799" + style="stop-color:#9e2064;stop-opacity:1" + offset="0.3233"/> + <stop + id="stop4801" + style="stop-color:#c92037;stop-opacity:1" + offset="0.63020003"/> + <stop + id="stop4803" + style="stop-color:#cd2335;stop-opacity:1" + offset="0.75139999"/> + <stop + id="stop4805" + style="stop-color:#e97826;stop-opacity:1" + offset="1"/> + </linearGradient> + <path + d="m 212.7,262.8 c -1,0.2 -2,0.3 -3.1,0.5 l 0,0 c 1,-0.2 2,-0.4 3.1,-0.5 z" + id="path4807" + style="fill:url(#linearGradient5358)"/> + <path + d="m 220.7,236.9 c 0.3,0 0.6,-0.1 1,-0.1 -0.3,0 -0.6,0.1 -1,0.1 l 0,0 z" + id="path4809" + style="fill:#be202e"/> + <path + d="m 220.7,236.9 c 0.3,0 0.6,-0.1 1,-0.1 -0.3,0 -0.6,0.1 -1,0.1 l 0,0 z" + id="path4811" + style="opacity:0.35;fill:#be202e"/> + <linearGradient + x1="-8238.3281" + y1="-747.58557" + x2="-7698.647" + y2="-747.58557" + id="SVGID_9_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"> + <stop + id="stop4814" + style="stop-color:#9e2064;stop-opacity:1" + offset="0.3233"/> + <stop + id="stop4816" + style="stop-color:#c92037;stop-opacity:1" + offset="0.63020003"/> + <stop + id="stop4818" + style="stop-color:#cd2335;stop-opacity:1" + offset="0.75139999"/> + <stop + id="stop4820" + style="stop-color:#e97826;stop-opacity:1" + offset="1"/> + </linearGradient> + <path + d="m 220.7,236.9 c 0.3,0 0.6,-0.1 1,-0.1 -0.3,0 -0.6,0.1 -1,0.1 l 0,0 z" + id="path4822" + style="fill:url(#linearGradient5360)"/> + <path + d="m 220.8,236.9 c 0,0 0,0 0,0 l 0,0 0,0 0,0 c 0,0 0,0 0,0 z" + id="path4824" + style="fill:#be202e"/> + <path + d="m 220.8,236.9 c 0,0 0,0 0,0 l 0,0 0,0 0,0 c 0,0 0,0 0,0 z" + id="path4826" + style="opacity:0.35;fill:#be202e"/> + <linearGradient + x1="-7935.1431" + y1="-747.9668" + x2="-7815.856" + y2="-747.9668" + id="SVGID_10_" + gradientUnits="userSpaceOnUse" + gradientTransform="matrix(0.4226,-0.9063,0.9063,0.4226,4226.9761,-6584.5938)"> + <stop + id="stop4829" + style="stop-color:#9e2064;stop-opacity:1" + offset="0.3233"/> + <stop + id="stop4831" + style="stop-color:#c92037;stop-opacity:1" + offset="0.63020003"/> + <stop + id="stop4833" + style="stop-color:#cd2335;stop-opacity:1" + offset="0.75139999"/> + <stop + id="stop4835" + style="stop-color:#e97826;stop-opacity:1" + offset="1"/> + </linearGradient> + <path + d="m 220.8,236.9 c 0,0 0,0 0,0 l 0,0 0,0 0,0 c 0,0 0,0 0,0 z" + id="path4837" + style="fill:url(#linearGradient5362)"/> + </g> + </g> + <g + transform="translate(385.61463,-191.53704)" + id="g4845"/> + <g + transform="translate(385.61463,-191.53704)" + id="g4847"/> + <g + transform="translate(385.61463,-191.53704)" + id="g4849"/> + <g + transform="translate(385.61463,-191.53704)" + id="g4851"/> + <g + transform="translate(385.61463,-191.53704)" + id="g4853"/> + <g + transform="translate(385.61463,-191.53704)" + id="g4855"/> +</svg> diff --git a/content/support-care-landingpage/component-logos/eclipse-temurin.svg b/content/support-care-landingpage/component-logos/eclipse-temurin.svg new file mode 100644 index 00000000..26cf42bc --- /dev/null +++ b/content/support-care-landingpage/component-logos/eclipse-temurin.svg @@ -0,0 +1,35 @@ +<?xml version="1.0" encoding="UTF-8"?> +<svg id="Ebene_1" data-name="Ebene 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 290.15 62.01"> + <defs> + <style> + .cls-1 { + fill: #e72867; + } + + .cls-2 { + fill: #a81255; + } + + .cls-3 { + fill: #1c1537; + } + + .cls-4 { + fill: #4e1948; + } + </style> + </defs> + <g> + <path class="cls-3" d="m87.47,40.01c-.56-.54-.84-1.26-.84-2.16v-15.54h-4.65c-.97,0-1.69-.2-2.16-.61-.47-.41-.71-1.03-.71-1.86s.24-1.45.71-1.85c.47-.4,1.19-.59,2.16-.59h15.45c.97,0,1.69.2,2.16.59.47.4.71,1.01.71,1.85s-.24,1.46-.71,1.86c-.47.41-1.19.61-2.16.61h-4.65v15.54c0,.9-.28,1.62-.84,2.16-.56.54-1.3.81-2.23.81s-1.67-.27-2.23-.81Z"/> + <path class="cls-3" d="m113.15,39.93c-.48-.48-.73-1.18-.73-2.08v-17.66c0-.9.24-1.6.73-2.08s1.18-.73,2.08-.73h11.42c.95,0,1.66.2,2.15.59.48.4.73.97.73,1.72,0,1.58-.96,2.38-2.87,2.38h-8.32v4.42h7.66c1.91,0,2.87.78,2.87,2.34,0,.75-.24,1.32-.73,1.72s-1.2.59-2.15.59h-7.66v4.82h8.32c1.91,0,2.87.79,2.87,2.38,0,.75-.24,1.32-.73,1.72-.48.4-1.2.59-2.15.59h-11.42c-.9,0-1.6-.24-2.08-.73Z"/> + <path class="cls-3" d="m165.35,18.05c.53.55.79,1.26.79,2.15v17.95c0,.84-.24,1.5-.73,1.98-.48.48-1.12.73-1.91.73s-1.4-.24-1.9-.73c-.49-.48-.74-1.14-.74-1.98v-9.7l-3.76,6.93c-.37.7-.77,1.2-1.19,1.5-.42.3-.91.45-1.48.45s-1.07-.15-1.48-.45c-.42-.3-.81-.8-1.19-1.5l-3.73-6.73v9.51c0,.81-.25,1.47-.74,1.96-.5.49-1.14.74-1.93.74s-1.4-.24-1.9-.73c-.49-.48-.74-1.14-.74-1.98v-17.95c0-.88.27-1.6.81-2.15.54-.55,1.23-.83,2.06-.83.59,0,1.13.17,1.62.51.48.34.89.83,1.22,1.47l6.07,11.42,6.04-11.42c.68-1.32,1.61-1.98,2.77-1.98.84,0,1.52.28,2.05.83Z"/> + <path class="cls-3" d="m183.08,38.38c-1.75-1.72-2.62-4.22-2.62-7.52v-10.66c0-.9.27-1.62.81-2.16.54-.54,1.26-.81,2.16-.81s1.62.27,2.16.81.81,1.26.81,2.16v10.89c0,1.67.37,2.96,1.12,3.86.75.9,1.83,1.35,3.23,1.35s2.49-.45,3.23-1.35c.75-.9,1.12-2.19,1.12-3.86v-10.89c0-.9.27-1.62.81-2.16.54-.54,1.26-.81,2.16-.81s1.63.27,2.18.81c.55.54.83,1.26.83,2.16v10.66c0,3.28-.89,5.78-2.66,7.51-1.77,1.73-4.33,2.59-7.67,2.59s-5.92-.86-7.67-2.57Z"/> + <path class="cls-3" d="m235.55,38.48c0,.7-.29,1.29-.87,1.76-.58.47-1.26.71-2.03.71-.53,0-1.02-.12-1.48-.36-.46-.24-.86-.6-1.19-1.09l-4.29-6.27c-.31-.44-.63-.76-.97-.97-.34-.21-.74-.31-1.2-.31h-2.15v5.91c0,.92-.26,1.66-.79,2.19-.53.54-1.25.81-2.18.81s-1.66-.27-2.2-.81-.81-1.27-.81-2.19v-17.66c0-.9.24-1.6.73-2.08s1.18-.73,2.08-.73h8.28c2.82,0,4.93.61,6.35,1.83,1.42,1.22,2.13,2.99,2.13,5.3,0,1.76-.48,3.25-1.45,4.47-.97,1.22-2.33,2.04-4.09,2.46.73.11,1.36.35,1.9.73.54.37,1.07.94,1.6,1.68l2.05,2.94c.4.59.59,1.16.59,1.68Zm-7.15-11.72c.58-.42.87-1.1.87-2.05s-.29-1.67-.87-2.1c-.58-.43-1.55-.64-2.89-.64h-4.22v5.41h4.22c1.34,0,2.3-.21,2.89-.63Z"/> + <path class="cls-3" d="m249.64,40.04c-.54-.54-.81-1.27-.81-2.19v-17.66c0-.9.27-1.62.81-2.16.54-.54,1.27-.81,2.2-.81s1.69.27,2.24.81c.55.54.83,1.26.83,2.16v17.66c0,.92-.28,1.66-.83,2.19-.55.54-1.3.81-2.24.81s-1.66-.27-2.2-.81Z"/> + <path class="cls-3" d="m289.35,18.05c.54.55.81,1.26.81,2.15v17.66c0,.9-.26,1.63-.79,2.18-.53.55-1.21.83-2.05.83-.99,0-1.74-.33-2.24-.99l-10.03-12.51v10.5c0,.9-.25,1.63-.76,2.18-.51.55-1.19.83-2.05.83s-1.52-.28-2.05-.83c-.53-.55-.79-1.28-.79-2.18v-17.66c0-.88.26-1.6.79-2.15s1.21-.83,2.05-.83c.95,0,1.68.33,2.21.99l10.03,12.48v-10.5c0-.9.26-1.62.78-2.16.52-.54,1.19-.81,2.03-.81s1.52.28,2.06.83Z"/> + </g> + <path class="cls-3" d="m39.09,41.96H10.04C4.51,41.96.02,46.99.02,52.33s4.49,9.67,10.02,9.67h29.05c5.54,0,10.02-4.33,10.02-9.67s-4.49-10.37-10.02-10.37Z"/> + <path class="cls-4" d="m1.92,46.42c.11-.19,26.71-40.84,27.06-41.41,1.78-2.91,4.9-5,8.46-5,5.54,0,10.02,5.03,10.02,10.37,0,2.04-.66,3.94-1.78,5.5-.11.18-26.93,41.24-27.06,41.41-1.75,2.82-4.94,4.72-8.6,4.72-5.54,0-10.02-4.33-10.02-9.67,0-2.12.72-4.19,1.92-5.92Z"/> + <path class="cls-2" d="m37.44,0H11.7S11.68,0,11.68,0C6.14,0,1.65,5.03,1.65,10.37s4.49,9.67,10.02,9.67c0,0,.01,0,.02,0h0s25.74,0,25.74,0c5.54,0,10.02-4.33,10.02-9.67S42.98,0,37.44,0Z"/> + <path class="cls-1" d="m47.2,46.42c-.11-.19-26.71-40.84-27.06-41.41C18.36,2.09,15.24,0,11.68,0,6.14,0,1.65,5.03,1.65,10.37c0,2.04.66,3.94,1.78,5.5.11.18,26.93,41.24,27.06,41.41,1.75,2.82,4.94,4.72,8.6,4.72,5.54,0,10.02-4.33,10.02-9.67,0-2.12-.72-4.19-1.92-5.92Z"/> +</svg> \ No newline at end of file diff --git a/content/support-care-landingpage/component-logos/junit.svg b/content/support-care-landingpage/component-logos/junit.svg new file mode 100644 index 00000000..c72cdbe8 --- /dev/null +++ b/content/support-care-landingpage/component-logos/junit.svg @@ -0,0 +1,34 @@ +<?xml version="1.0" encoding="UTF-8"?> +<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1000 283.4"> + <defs> + <style> + .cls-1 { + fill: #d84445; + } + + .cls-2 { + fill: #292629; + } + + .cls-3 { + fill: #299d5b; + } + </style> + </defs> + <g> + <path class="cls-2" d="M419.62,167.74c0,15.53-2.69,26.14-8.07,31.81-5.38,5.67-15.83,8.51-31.36,8.51-6.18,0-11.65-.2-16.43-.6-4.78-.4-9.26-1.09-13.44-2.09v32.86c4.18,1.2,9.11,2.09,14.79,2.69,5.68.6,12.1.9,19.27.9,25.29,0,43.46-5.62,54.52-16.88,11.05-11.25,16.58-29.62,16.58-55.11V51.84h-35.84v115.9Z"/> + <path class="cls-2" d="M607.8,162.37c0,17.32-2.99,29.27-8.96,35.84-5.97,6.57-16.93,9.86-32.86,9.86s-26.58-3.24-32.56-9.71c-5.97-6.47-8.96-18.47-8.96-35.99V51.84h-35.84v110.52c0,27.88,6.17,48.09,18.52,60.64,12.34,12.55,31.96,18.82,58.84,18.82s45.8-6.52,58.55-19.57c12.74-13.04,19.12-33.01,19.12-59.89V51.84h-35.85v110.52Z"/> + <path class="cls-2" d="M758.35,88.58c-10.95,0-20.46,1.45-28.53,4.33-8.06,2.89-15.58,7.42-22.55,13.59h-.9l-1.49-14.94h-29.87v147.56h34.65v-109.33c5.38-3.38,11.15-5.92,17.32-7.62,6.17-1.69,12.55-2.54,19.12-2.54,9.16,0,16.08,1.84,20.76,5.53,4.68,3.69,7.02,9.11,7.02,16.28v97.68h34.65v-102.16c0-15.93-4.28-27.98-12.85-36.14-8.56-8.16-21.01-12.25-37.34-12.25Z"/> + <rect class="cls-2" x="839.3" y="40.49" width="36.74" height="30.17"/> + <rect class="cls-2" x="840.49" y="91.57" width="34.65" height="147.56"/> + <path class="cls-2" d="M988.95,208.82c-4.58.5-8.56.75-11.95.75-9.76,0-16.53-1.59-20.31-4.78-3.79-3.18-5.68-9.16-5.68-17.92v-66.31h47.2v-28.97h-47.2v-35.25h-28.97l-4.78,35.25h-20.61v28.97h19.71v67.51c0,19.32,4.08,33.11,12.25,41.37,8.16,8.27,21.7,12.4,40.62,12.4,4.97,0,10.5-.55,16.58-1.64,6.07-1.09,10.8-2.34,14.19-3.73v-29.57c-2.79.8-6.47,1.45-11.05,1.94Z"/> + </g> + <g> + <path class="cls-1" d="M197.75,196.87l-56.05,56.05L30.48,141.7l38.27-38.27-20.61-20.61L7.57,123.39c-10.1,10.1-10.1,26.52,0,36.62l115.82,115.82c5.05,5.05,11.68,7.57,18.31,7.57s13.26-2.53,18.31-7.57l58.35-58.35-20.61-20.61Z"/> + <g> + <path class="cls-3" d="M203.1,50.66L160.01,7.57c-10.09-10.09-26.52-10.09-36.62,0l-57.6,57.6,20.61,20.61,55.31-55.31,40.79,40.8,20.61-20.61Z"/> + <path class="cls-3" d="M252.25,99.82l-20.61,20.61,21.27,21.27-37.53,37.52,20.61,20.61,39.82-39.82c4.89-4.89,7.58-11.39,7.58-18.31s-2.69-13.42-7.58-18.31l-23.57-23.57Z"/> + </g> + </g> + <path class="cls-2" d="M141.7,175.91c-3.73,0-7.46-1.42-10.3-4.27l-39.28-39.28,20.61-20.61,28.98,28.98,99.97-99.97,20.61,20.61-110.28,110.28c-2.85,2.85-6.57,4.27-10.3,4.27Z"/> +</svg> \ No newline at end of file diff --git a/content/support-care-landingpage/foundation-logos/afs.svg b/content/support-care-landingpage/foundation-logos/afs.svg new file mode 100644 index 00000000..f1084dfb --- /dev/null +++ b/content/support-care-landingpage/foundation-logos/afs.svg @@ -0,0 +1,43 @@ +<?xml version="1.0" encoding="UTF-8"?> +<svg id="Layer_1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1000 525"> + <defs> + <style> + .cls-1 { + fill: #7c297d; + } + + .cls-2 { + fill: #f79a23; + } + + .cls-3 { + fill: #dd552c; + } + + .cls-4 { + fill: #d22128; + } + </style> + </defs> + <g> + <g> + <path class="cls-1" d="M458.8041825,181.7454822h49.0451573l87.4128103,220.0939304h-53.4548455l-14.7775045-38.0445002h-87.4060779l-15.0939249,38.0445002h-53.1384251l87.4128103-220.0939304ZM514.4537735,324.4914631l-31.1236462-80.4919562-30.8139581,80.4919562h61.9376043Z"/> + <path class="cls-1" d="M622.7166664,331.7220052h48.7354693c.3164204,21.0655178,16.0364536,33.3318564,40.2459781,33.3318564,20.7490974,0,33.9579648-8.4894912,33.9579648-23.2669957,0-15.4103452-14.1513961-24.5259448-45.2750423-31.4467989-51.5697879-10.6909691-76.0957328-32.0661749-76.0957328-68.2256176,0-39.9295577,31.7564869-64.7719229,82.3837461-64.7719229,52.189164,0,85.5210204,28.2960599,85.5210204,72.6285734h-48.1093609c0-19.8065687-13.8349757-31.7564869-36.7855511-31.7564869-21.0655178,0-33.9579648,8.8059116-33.9579648,23.2669957,0,13.5252877,11.6334979,22.0147789,45.2750423,29.8714294,54.7137946,12.892447,77.6643699,33.6415444,77.6643699,68.542038,0,41.5049272-32.0729073,66.3472924-84.2620713,66.3472924-55.339903,0-89.2978678-28.9289006-89.2978678-74.5203633Z"/> + <path class="cls-1" d="M852.9091193,181.7454822h137.7169167v45.2750423h-87.7224983v55.0234826h79.8591155v44.0228255h-79.8591155v75.7725801h-49.9944184v-220.0939304Z"/> + </g> + <g> + <path class="cls-3" d="M141.1077177,209.8881008c13.1869872-32.608129,27.9005344-65.1523006,43.6878912-93.9970469-23.5665852-17.5041056-46.1956909-55.2490163-55.4930639-71.9721694-3.3392448,3.7936783-5.5070609,8.1629723-6.4899838,11.7176522-8.7587851,31.6252061,22.4204029,69.8144518-2.6929393,55.86166-20.9241385-11.6267655-68.040478-37.0885068-86.0124818-11.7816095,20.1280383,25.862316,72.7733189,90.9304622,107.0005776,110.1715137Z"/> + <path class="cls-2" d="M184.7956089,115.8910539c15.2975784-27.9493439,31.5999598-52.4281623,48.5015202-70.0635487,0,0-16.8578001,24.4013964-40.9360438,73.180626,14.5822664,4.0158458,56.1124399,12.2562401,113.9601427-2.686207,1.4222086-10.5125619-5.645074-22.0753701-40.8636711-25.9464703-22.9926525-2.5246306,27.5975787-54.9023003-9.0516423-79.6739759-1.1832102-.8011494-2.3462234-1.508046-3.4856733-2.1408868-1.2286536-.4409688-2.5263137-.8449097-3.9114944-1.2050903-42.8025874-11.1689658-48.7354693,61.409115-65.8154369,45.8068978-27.6009449-25.2126444-45.0225792-19.3218396-53.890765-9.2435142,9.297373,16.7231532,31.9264787,54.4680639,55.4930639,71.9721694Z"/> + <path class="cls-4" d="M106.6818547,303.8380213c9.6626029-28.9457315,21.2860022-61.4663399,34.425863-93.9499204-34.2272587-19.2410514-86.8725393-84.3091977-107.0005776-110.1715137-3.5933909,5.0559936-6.0490149,12.1081284-6.8669953,21.7522173-4.3894911,51.802054,49.0518897,90.152876,38.3979485,97.1578844-14.0924881,9.2670774-42.1411341-22.2605096-53.19565-2.2284073,16.0229889,20.5841549,48.6614135,57.7770131,94.2394114,87.4397396Z"/> + <path class="cls-3" d="M254.7564893,192.1180675c-27.0589909-9.6508213,28.2758628-35.5333343,46.2445004-62.9912168,2.2990969-3.5109196,4.6756159-8.0485224,5.3202382-12.8049265-57.8477027,14.942447-99.3778763,6.7020527-113.9601427,2.686207-12.4649429,25.2564046-26.8587035,57.0835812-41.8701571,95.4579665,15.6341958,6.6852219,79.4703224,31.3794754,169.6366631,31.50739,15.1595653-39.4852227-39.6905594-44.6994265-65.3711019-53.8554202Z"/> + <path class="cls-4" d="M117.1371916,309.0488589c15.9001236,4.9550083,68.5841152,19.7560761,124.5366618,17.5276688,7.5166669-20.3518889-20.585838-22.3379316-22.8748364-38.6605101-1.7722907-12.6298854,73.9565291,10.6135471,98.3225807-35.3111668,1.2320197-2.3226602,2.1930625-4.5140395,3.0059935-6.6313631-90.1663407-.1279146-154.0024672-24.8221682-169.6366631-31.50739-10.9703615,28.0435968-22.2554604,59.5173251-33.3537365,94.5827612Z"/> + <path class="cls-1" d="M117.1371916,309.0488589c-7.1447046,22.5701977-14.1934733,46.6821031-21.0352222,72.1640414-2.4270116,9.0348114-4.8254106,18.2379315-7.190148,27.6430221,53.1064464,17.531035,102.0085414.0403941,103.6663821-21.6377674.0134647-.1716749-.018514-.2995895-.0084154-.464532,1.2639984-22.9606739-33.150083-10.2331694-32.3354689-24.0378496.8179803-13.9056654,60.0811593-.0807882,78.4082944-29.8949926,1.4053777-2.2856322,2.3209771-4.3154353,3.0312398-6.244253-55.9525467,2.2284073-108.6365383-12.5726604-124.5366618-17.5276688Z"/> + <path class="cls-1" d="M12.4424433,216.3982816c-.7742201,1.4036946-1.4727012,3.0261906-2.068514,4.9651069-10.2920775,33.4496725,62.4846076,78.3847312,52.5830064,88.180298-8.9254108,8.8261086-20.5572255-11.3440069-34.9004936-3.0127259-1.5720033.9155994-3.1675699,2.0701971-4.8052136,3.749918-16.2215932,16.6188018-.2541461,64.4958967,45.7698699,90.0518908-10.7397786,36.0618236-21.4324308,76.351562-31.8995493,118.4859638,3.7970444-1.3296388,8.3413795-2.6626438,9.4724141-6.244253,1.6982349-6.9814452,12.1939658-49.4625629,29.2352225-107.0948305,0,0,3.1103449-11.8051727,8.8042285-31.254927,5.2646964-17.9854685,12.7460184-42.5147795,22.0484407-70.3867014-45.577998-29.6627266-78.2164225-66.8555847-94.2394114-87.4397396Z"/> + </g> + </g> + <g> + <polygon class="cls-1" points="404.1671788 144.7351535 413.43089 144.7351535 413.43089 82.5349876 436.7786739 82.5349876 436.7786739 73.4732468 380.8193949 73.4732468 380.8193949 82.5349876 404.1671788 82.5349876 404.1671788 144.7351535"/> + <polygon class="cls-1" points="464.8525663 112.9584696 501.321697 112.9584696 501.321697 144.7351535 510.6796611 144.7351535 510.6796611 73.4732468 501.321697 73.4732468 501.321697 103.8899964 464.8525663 103.8899964 464.8525663 73.4732468 455.5955874 73.4732468 455.5955874 144.7351535 464.8525663 144.7351535 464.8525663 112.9584696"/> + <polygon class="cls-1" points="581.40298 135.9629037 546.2331925 135.9629037 546.2331925 112.8574844 577.8213707 112.8574844 577.8213707 104.0852345 546.2331925 104.0852345 546.2331925 82.1512438 580.3392689 82.1512438 580.3392689 73.4732468 536.9762136 73.4732468 536.9762136 144.7351535 581.40298 144.7351535 581.40298 135.9629037"/> + </g> +</svg> \ No newline at end of file diff --git a/content/support-care-landingpage/foundation-logos/eclipse.png b/content/support-care-landingpage/foundation-logos/eclipse.png new file mode 100644 index 00000000..37e6996d Binary files /dev/null and b/content/support-care-landingpage/foundation-logos/eclipse.png differ diff --git a/content/support-care-landingpage/foundation-logos/lf.svg b/content/support-care-landingpage/foundation-logos/lf.svg new file mode 100644 index 00000000..e8df47f8 --- /dev/null +++ b/content/support-care-landingpage/foundation-logos/lf.svg @@ -0,0 +1,49 @@ +<?xml version="1.0" encoding="utf-8"?> +<!-- Generator: Adobe Illustrator 26.2.1, SVG Export Plug-In . SVG Version: 6.00 Build 0) --> +<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" + viewBox="0 0 1000 328.9" style="enable-background:new 0 0 1000 328.9;" xml:space="preserve"> +<style type="text/css"> + .st0{fill:#003778;} + .st1{fill:#003764;} + .st2{fill:#0094FF;} +</style> +<g> + <g> + <path class="st0" d="M384.2,1.2h57.7v5.9h-25.4V74h-6.9V7.2h-25.4L384.2,1.2L384.2,1.2z"/> + <path class="st0" d="M448.7,1.2h6.9v31.6h43.2V1.2h6.9V74h-6.9V38.8h-43.2V74h-6.9V1.2z"/> + <path class="st0" d="M520.5,1.2h50.3v5.9h-43.3v26.3H568v5.9h-40.6V68h43.8v6h-50.8L520.5,1.2L520.5,1.2z"/> + </g> + <g> + <path class="st0" d="M384.2,254.6h46.2v5.9h-39.2v26.3H426v5.9h-34.9v34.7h-6.9V254.6z"/> + <path class="st0" d="M469.4,253.1c22.8,0,34.2,17.9,34.2,37.9s-11.4,37.9-34.2,37.9c-22.9,0-34.4-17.9-34.4-37.9 + S446.4,253.1,469.4,253.1z M469.4,323c19.2,0,27.3-16.1,27.3-32s-8.2-32-27.3-32c-19.3,0-27.4,16.1-27.4,32S450.1,323,469.4,323z" + /> + <path class="st0" d="M513.7,254.6h6.9v45.1c0,16.8,7.8,23.3,21.3,23.3c13.6,0,21.4-6.5,21.4-23.3v-45.1h6.9v46.6 + c0,15-8.1,27.7-28.3,27.7c-20.1,0-28.2-12.7-28.2-27.7L513.7,254.6L513.7,254.6z"/> + <path class="st0" d="M584.2,254.6h7.7l42.4,61.6h0.2v-61.6h6.9v72.8h-7.7l-42.4-61.6h-0.2v61.6h-6.9V254.6z"/> + <path class="st0" d="M656.1,254.6h25.2c22,0.5,33.4,12.3,33.4,36.4s-11.4,35.9-33.4,36.4h-25.2V254.6z M663,321.5h14.8 + c20.9,0,30-8.7,30-30.5s-9.1-30.5-30-30.5H663V321.5z"/> + <path class="st0" d="M747.2,254.6h7.7l28.5,72.8H776l-8.9-22.6H734l-8.8,22.6h-7.4L747.2,254.6z M736.2,298.9h28.6l-14.1-37.3 + L736.2,298.9z"/> + <path class="st0" d="M775.3,254.6H833v5.9h-25.4v66.9h-6.9v-66.9h-25.4L775.3,254.6L775.3,254.6z"/> + <path class="st0" d="M840.4,254.6h6.9v72.8h-6.9V254.6z"/> + <path class="st0" d="M893,253.1c22.8,0,34.2,17.9,34.2,37.9s-11.4,37.9-34.2,37.9c-22.9,0-34.4-17.9-34.4-37.9 + S870,253.1,893,253.1z M893,323c19.2,0,27.3-16.1,27.3-32s-8.2-32-27.3-32c-19.3,0-27.4,16.1-27.4,32S873.7,323,893,323z"/> + <path class="st1" d="M937.9,254.6h7.7l42.4,61.6h0.2v-61.6h6.9v72.8h-7.7L945,265.8h-0.2v61.6h-6.9V254.6z"/> + </g> + <g> + <path class="st0" d="M384.2,95.7h40.1v96.8h57.6v33.4h-97.8L384.2,95.7L384.2,95.7z"/> + <path class="st0" d="M508.2,95.7h40.1v130.2h-40.1L508.2,95.7L508.2,95.7z"/> + <path class="st0" d="M578.2,95.7h41l37.9,69.7h0.4V95.7h37.9v130.2h-39l-39.9-71.1h-0.4v71.1h-37.9V95.7z"/> + <path class="st0" d="M843.7,175.6c0,36.3-19.1,53.4-59.3,53.4c-40.1,0-59.5-17.1-59.5-53.4V95.7H765v70.9 + c0,13.1-0.2,29.9,19.5,29.9c19,0,19-16.8,19-29.9V95.7h40.1v79.9H843.7z"/> + <path class="st0" d="M907.5,156.6l-42.9-60.9h47.1l19.7,35.4l19.3-35.4h44.5L953.5,157l46.5,68.9h-48.3l-22.2-38.8l-23,38.8h-46 + L907.5,156.6z"/> + </g> + <g> + <polygon class="st2" points="65.6,261.9 65.6,131 0,131 0,327.4 196.5,327.4 196.5,261.9 "/> + <polygon class="st0" points="327.3,0 0,0 0,98.2 65.5,98.2 65.5,65.8 261.9,65.8 261.9,261.9 229.2,261.9 229.2,327.4 + 327.3,327.4 "/> + </g> +</g> +</svg> diff --git a/content/support-care-landingpage/index.de.md b/content/support-care-landingpage/index.de.md index b5f5bc96..3714f5b5 100644 --- a/content/support-care-landingpage/index.de.md +++ b/content/support-care-landingpage/index.de.md @@ -1,161 +1,308 @@ --- -title: "Support & Care" -description: "Erhalten Sie umfassenden Open Source Support ✔ Updates ✔ Webinare ✔ direkter Support ✔ Wartungsservice für eine sichere und effiziente Infrastruktur." -layout: "single" +title: "Support & Care — Professionelle Betreuung für geschäftskritische Java-Komponenten" +description: "Support & Care by Open Elements: Professionelle Wartung, Sicherheitsupdates und Long Term Support für Apache Maven, JUnit, Log4j, Apache Commons und Eclipse Temurin. CRA-konform. Direkt von den Maintainern." +layout: "article" url: "/de/about-support-care" aliases: ['/de/javaland-2024/support-care'] newsletterPopup: true +showTitle: false --- -Support & Care ist ein Programm zur nachhaltigen Weiterentwicklung, Stabilisierung und **Support von Open Source Software (OSS)**. -Hierbei arbeitet Open Elements sowohl mit der Industrie als auch mit der Open Source Community zusammen, um die Qualität, -Unabhängigkeit und Entwicklung von kritischen Open Source Projekten und Komponenten sicherzustellen. - -{{< centered-image src="/illustrations/support-care-logos/support-care-logo.svg" alt="Support & Care Logo" width="80%" >}} - -## Warum Open Source für unser heutiges Leben so wichtig ist - -Open Source gewährleistet die Qualität, Sicherheit und Fortschrittlichkeit von Software, fördert die Gemeinschaft und -bietet wirtschaftliche und soziale Vorteile. [Diese Vorzüge bietet Open Source](https://opensource.com/resources/what-open-source) -sowohl für Einzelpersonen, Unternehmen als auch für die gesamte Gesellschaft. -Es ist daher im Interesse aller, OSS-Projekte finanziell zu unterstützen. -Aufgrund der Fülle der Vorteile wollen wir uns hier auf 4 wichtige Teilaspekte konzentrieren: - - -- **Wissensteilung und Bildung:** Open Source Projekte sind oft nicht nur Softwarelösungen, sondern auch Bildungsressourcen. - Interessierte können den Code studieren, daraus lernen und sich weiterbilden. - Damit fördert Open Source den Wissensaustausch und ermöglicht es vielen, technische Fähigkeiten zu erwerben und zu vertiefen. -- **Vertrauen durch Transparenz:** Da der Quellcode von OSS öffentlich zugänglich ist, kann jede Person ihn überprüfen. - Dies schafft ein hohes Maß an Vertrauen, da eventuelle Mängel oder versteckte Funktionen sichtbar sind. -- **Unabhängigkeit von einzelnen Anbietern:** OSS verringert die Abhängigkeit von einzelnen Softwareanbietern und deren - Geschäftsmodellen. - Besonders in kritischen Infrastrukturen ist das wichtig, um sicherzustellen, dass Anwendungen und Systeme auch in - Zukunft betrieben werden können. -- **Soziale Gerechtigkeit:** Open Source Software ist oft für jeden zugänglich, unabhängig von finanziellen Mitteln. - OSS-Projekte ermöglichen es Menschen aus allen sozialen und wirtschaftlichen Hintergründen, - Zugang zu Technologie und Bildung zu haben. - -{{< centered-image src="os-benefits-de.png" showCaption="true" alt="Ergebnis zur Umfrage bzgl. Vorteilen von Open Source bei mittelständischen Unternehmen" width="80%" >}} - -### Bedeutung von Open Source Support - -Um die langfristige Nachhaltigkeit von Open Source Projekten zu gewährleisten, ist es entscheidend, diese finanziell -zu unterstützen. -Viele Entwickler und Maintainer arbeiten freiwillig an diesen Projekten, oft ohne finanzielle Kompensation. -Durch einen Open Source Support können diese Projekte kontinuierlich weiterentwickelt und verbessert werden. -Zudem ermöglicht Open Source Support es den Entwicklern, sich stärker auf die Qualität und Sicherheit der Software -zu konzentrieren und schneller auf Sicherheitslücken oder Fehler zu reagieren. -Die Unterstützung schafft auch Anreize für neue Entwickler, sich zu beteiligen und innovative Lösungen zu entwickeln. -Kurz gesagt, finanzielle Unterstützung trägt dazu bei, die Open Source Gemeinschaft lebendig und produktiv zu halten, -was letztlich allen zugutekommt. - -{{< centered-image src="tree.png" alt="Illustration bzgl. Zusammenarbeit" width="80%" >}} - -Die [aktive Beteiligung an Open-Source-Projekten](https://hbswk.hbs.edu/item/the-hidden-benefit-of-giving-back-to-open-source-software) -ermöglicht es den Unternehmen, wertvolle Einblicke und technologische Fortschritte zu gewinnen, was den langfristigen -Erfolg und die Wettbewerbsfähigkeit fördert, während gleichzeitig die Open-Source-Community gestärkt wird. - -## Wie Support & Care Open Source Software fördert - -Mit **Support & Care** hat Open Elements gezielt ein Programm zur **fairen und leichtgewichtigen Förderung** -von Open Source gestartet. -Support & Care hilft hierbei sowohl den Open Source Projekten als auch den Personen hinter diesen Projekten. -Wir konzentrieren uns in unserem Support auf Projekte in der Programmiersprache Java. -Diese Spezialisierung ist sinnvoll, weil sie es uns ermöglicht, unsere tiefgreifende Expertise in einer -bestimmten Programmiersprache anzuwenden. -Dadurch können wir effizientere und qualitativ hochwertigere Unterstützung für die spezifischen Anforderungen und -Herausforderungen bieten, die in kritischen Java-basierten Open-Source-Projekten auftreten. - -Mit kritischer OSS sind hierbei Projekte gemeint, die in einer Vielzahl von kritischen System und Anwendungen -in Branchen wie Banken, Gesundheit, Politik als Abhängigkeiten enthalten sind. -Ein Beispiel hierfür ist die Java Distribution Eclipse Temurin, welche mit über 500.000 Downloads die meistgenutzte -Java Laufzeitumgebung ist, oder Apache Maven, dessen Hauptkomponenten im letzten Jahr an die 2 Milliarden mal -heruntergeladen wurden. -Für beide Projekte bietet Open Elements mit Support & Care eine Lösung an, um im professionellen Umfeld die -Produkte bedenkenlos einsetzen zu können. - -Zur Förderung von OSS arbeitet Open Elements aktiv an den Projekten mit. -So ist Open Elements beispielsweise Mitglied der Arbeitsgruppe hinter Eclipse Temurin – unser Geschäftsführer -Hendrik Ebbers war sogar Gründungsmitglied – und hat den Leiter der Entwicklung von Maven -(Chair des Project Management Committee) unter Vertrag. - -{{< centered-image src="roundtable.png" alt="Illustration bzgl. Aufgabenteilung" width="80%" >}} - -Unsere [Open Source Strategie](https://www.linuxfoundation.org/resources/open-source-guides/setting-an-open-source-strategy) -zielt darauf ab, durch finanzielle Förderung und aktive Mitarbeit an den Projekten deren Ausrichtung zu verbessern und -eine Unterfinanzierung bzw. schlechte Wartung sowie Sicherheit dieser kritischen OSS zu unterbinden. -Durch die gezielte Anwendung dieser Strategie können wir die im Support & Care Programm aufgenommen Projekte wegweisend -verbessern und sicherstellen, dass Entwickler weiterhin in der Lage sind, ihre wichtige Arbeit ohne finanzielle -Rückschläge fortzuführen. -Denn auch wenn Open Source ein wachsender Markt ist: Ohne finanzielle Rücklagen könnten dessen Entwickler gezwungen sein, -ihre Arbeit an den Projekten zu reduzieren oder ganz einzustellen. - -## Warum Open Elements der richtige Partner zur Förderung von OSS ist - -Das Ziel von Support & Care ist die ganzheitliche Förderung und Unterstützung von OSS anstelle “nur” finanzieller -Spenden oder Mitarbeit zu liefern. -Unsere jahrelange Erfahrung in der Open-Source-Entwicklung hat uns die entscheidende Bedeutung dieses Supports -aufgezeigt. -Aus diesem Grund wurde Open Elements als ein Unternehmen gegründet, das OSS sowohl aus der technischen als auch aus -wirtschaftlichen und organisatorischen Perspektiven betrachtet und fördert. - -Durch die Mitarbeit von Open Elements in Gremien wie der Eclipse Adoptium Working Group haben wir Erfahrung mit -großen bzw. kritischen Open Source Projekten und kennen deren Probleme und Herausforderungen. -Diese Kenntnisse werden mit der Mitgliedschaft von unserem Geschäftsführer im Aufsichtsrat der Eclipse Foundation -unterstrichen. -Aufgrund unserer Firmenstruktur sind wir aber so dynamisch, dass wir auch mit kleinen Open Source Projekten einfach -zusammenarbeiten können und diese z. B. über Github Sponsorship unterstützen, Newcomern helfen oder aktiv Beiträge -zum Quelltext der Projekte liefern. - -Durch all diese Punkte ist Open Elements ein perfektes Bindeglied zwischen Open Source und Wirtschaft. - -## Wie Support & Care ihrem Unternehmen helfen kann - -Die Bereitstellung von Support Modellen für Open Source Software ist mittlerweile ein beliebtes Geschäftsmodell. -Anders als viele Firmen bietet Support & Care aber nicht einfach nur Support für eigene Open Source Produkte an. -Wir suchen explizit OSS, die verstärkt im Enterprise Bereich eingesetzt wird und dort oft als sicherheitskritisch -eingestuft ist. -Zusammen mit den Entwicklern hinter diesen Open Source Projekten schafft das Support & Care Programm ein Bindeglied, -um sowohl die Projekte zu unterstützen als auch explizit auf die Wünsche und Bedürfnisse von Support & Care Kunden -einzugehen. - -Dabei handelt es sich nicht nur um die transparente Bearbeitung von technischen Tickets durch die jeweiligen Experten -der Projekte, sondern auch um die Aufbereitung und Transformation von Wissen. -Support & Care Kunden erhalten Benachrichtigungen über wichtige Sicherheitsupdates, Fixes und Releases und werden zu -regelmäßig stattfindenden Workshops und Infoveranstaltungen eingeladen. So können die Nutzer der OSS ihre eigenen -Bedürfnisse und Interessen auf kurzem Weg in die Projekte einbringen. -Durch diese Maßnahmen fördert Open Elements aktiv das Prinzip der Gemeinschaftsbildung für die jeweiligen Projekte: -Gemeinschaften, bestehend aus Entwicklern, Nutzern und anderen Beteiligten, können gemeinsam die -Innovationen vorantreiben. - -{{< centered-image src="networking.png" alt="Illustration bzgl. Aufgabenteilung" width="80%" >}} - -### Welche Leistungen umfasst der Open Source Support? - -Der Open Source Support & Care-Service bietet umfassende Leistungen zur Sicherstellung der Performance und Sicherheit -Ihrer Anwendungen. -Unsere Services gehen über klassisches Troubleshooting hinaus und fördern die nachhaltige Verbesserung Ihrer -Infrastruktur. - -- **Updates zu Open Source Projekten:** Sie erhalten regelmäßige Berichte und detaillierte Informationen zu Major Releases, - Bugfix Releases und neuen Projekten, einschließlich Sicherheitsupdates und Critical Patch Updates (CPU). -- **Webinare & Meetings:** Quartalsweise Webinare und 1-on-1 Calls bieten Ihnen aufbereitete Informationen und die - Möglichkeit, Fragen zu stellen und Bedürfnisse direkt in die Projekte einzubringen. -- **Direkter Support:** Kunden haben jederzeit Zugang zu mehrsprachigem Support mit garantierten Reaktionszeiten und der - Möglichkeit für Video-Calls zur schnellen Problemlösung. -- **Support-Bereiche:** Unser Service deckt verschiedene Open Source Projekte ab, beispielsweise im Rahmen unseres - [Temurin Support & Care Angebots]({{< relref "support-care-temurin" >}}) und unseres - [Maven Support & Care Angebots]({{< relref "support-care-maven" >}}). - Wir übernehmen die Ticketerstellung, -pflege und -überwachung, um technische Probleme effizient zu lösen. -- **Wartungsservice:** Unser Service umfasst die Wartung kundenspezifischer Docker-Container, die alle notwendigen - Komponenten für Ihre Anwendung enthalten und regelmäßig aktualisiert werden. - Die Container werden in einer Docker-Registry bereitgestellt und automatisch getestet. - -Je nach Bedarf lässt sich der Supportvertrag individuell anpassen. - -[Kontaktieren Sie uns]({{< relref "contact" >}}) für eine individuelle Beratung und erfahren Sie mehr darüber, -wie unser Open Source Support & Care-Service Ihre IT-Infrastruktur verbessern kann. - -{{< centered-button link="/contact" >}}Beratungstermin vereinbaren{{</ centered-button >}} - - +{{< centered-image src="support-and-care-logo.svg" width="80%" alt="Support & Care Logo">}} +<div style="text-align: center; margin-bottom: 1.5rem;"> + <p style="font-size: 1.2rem; font-weight: 400; color: #5CBA9E; max-width: 900px; margin: 0 auto 1rem auto; line-height: 1.5;">Professionelle Wartung, Sicherheitsupdates und Long Term Support für die geschäftskritischsten Open-Source-Komponenten im Java-Ökosystem — direkt von den Maintainern.</p> + <div style="display: flex; flex-wrap: wrap; justify-content: center; align-items: center; gap: 1.25rem; margin: 0 auto 1.25rem auto;"> + <img src="component-logos/eclipse-temurin.svg" alt="Eclipse Temurin" style="height: 28px; width: auto; opacity: 0.7;"> + <img src="component-logos/apache-maven.svg" alt="Apache Maven" style="height: 28px; width: auto; opacity: 0.7;"> + <img src="component-logos/junit.svg" alt="JUnit" style="height: 28px; width: auto; opacity: 0.7;"> + <img src="component-logos/apache-log4j.png" alt="Apache Log4j" style="height: 28px; width: auto; opacity: 0.7;"> + <img src="component-logos/apache-commons.svg" alt="Apache Commons" style="height: 28px; width: auto; opacity: 0.7;"> + </div> + <p style="font-size: 1rem; margin: 0 auto 1.5rem auto; line-height: 1.6; color: #020144;">Moderne Software besteht zu uber 70 % aus Open-Source-Komponenten. Ab 2027 macht der Cyber Resilience Act (CRA) Hersteller fur 100 % ihrer Software verantwortlich — einschliesslich aller OSS-Abhangigkeiten. Support & Care sichert die Basis Ihrer Java-Anwendungen: von der Laufzeitumgebung uber Build-Tools bis zur Teststrategie.</p> + <div style="display: flex; flex-wrap: wrap; justify-content: center; gap: 1rem; margin-bottom: 1.5rem;"> + <a href="/contact" class="inline-flex shrink-0 items-center justify-center gap-3 px-6 py-3.5 text-lg font-bold text-white text-center bg-sky rounded-full transition-all duration-150 ease-in-out hover:bg-sky-200 hover:shadow-8 active:shadow-none" style="color: white !important; text-decoration: none !important;">Kontakt aufnehmen</a> + <a href="#unsere-leistungen" class="inline-flex shrink-0 items-center justify-center gap-3 px-6 py-3.5 text-lg font-bold text-white text-center bg-sky rounded-full transition-all duration-150 ease-in-out hover:bg-sky-200 hover:shadow-8 active:shadow-none" style="color: white !important; text-decoration: none !important;">Leistungen entdecken</a> + </div> +</div> + +<hr style="border: none; border-top: 2px solid #e5e7eb; width: 40%; margin: 2.5rem auto;"> + +## Das Problem: Unsichtbare Abhängigkeiten + +Ein einfaches Java-Projekt mit Spring Boot bringt uber 70 transitive Abhangigkeiten mit — die meisten davon Open Source. +Ihr individueller Code ist nur die Spitze des Eisbergs. +Darunter liegen Laufzeitumgebungen, Build-Tools, Logging-Frameworks, Test-Bibliotheken und Utility-Libraries, die den eigentlichen Betrieb Ihrer Anwendung tragen. + +<div style="background-color: #DFF1FD; border-left: 4px solid #5DB9F5; border-radius: 0.5rem; padding: 1.25rem 1.5rem; margin: 1.5rem 0; font-size: 1.1rem; font-weight: 600; color: #020144;"> + 70 % von Software basiert auf Open Source und liegt somit ausserhalb Ihrer direkten Kontrolle. +</div> + +Diese Basiskomponenten werden häufig von einzelnen Entwicklern in ihrer Freizeit gepflegt. +Gleichzeitig tragen sie den Grossteil der technischen Risiken: +Sicherheitslucken, transitive Abhangigkeiten, fehlende Dokumentation und Compliance-Verantwortung. + +**Was das fur Sie bedeutet:** +- Schwachstellen in Basiskomponenten bleiben oft unbemerkt, bis es zu spat ist +- Framework-Support allein schutzt nicht vor Lucken in der Basis — das hat <a href="https://www.bsi.bund.de/DE/Themen/Verbraucherinnen-und-Verbraucher/Cyber-Sicherheitslage/Schwachstelle-log4Shell-Java-Bibliothek/log4j_node.html" target="_blank" rel="noopener">Log4Shell</a> eindeutig gezeigt +- Der CRA macht Sie ab 2027 fur die gesamte Software-Lieferkette haftbar + +## Die betreuten Komponenten + +Support & Care betreut gezielt fünf geschäftskritischste Open-Source-Basiskomponenten des Java-Okosystems. +Gemeinsam bilden sie die technische Vertrauenskette für fast jede Java-Anwendung. + +<div style="display: flex; flex-wrap: wrap; justify-content: center; gap: 2rem; margin: 2rem 0;"> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="component-logos/eclipse-temurin.svg" alt="Eclipse Temurin" style="height: 48px; margin: 0 auto 1rem auto; display: block;"> + <strong>Eclipse Temurin — Java-Runtime</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">Fuhrende herstellerunabhangige OpenJDK-Distribution weltweit<br>Uber 500.000 Downloads pro Tag<br>TCK-zertifiziert, AQAvit-verifiziert, Community-getragen</p> + </div> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="component-logos/apache-maven.svg" alt="Apache Maven" style="height: 48px; margin: 0 auto 1rem auto; display: block;"> + <strong>Apache Maven — Build & Dependency Management</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">Uber 75 % aller Java-Projekte setzen auf Maven<br>Ca. 2 Milliarden Downloads jahrlich</p> + </div> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="component-logos/junit.svg" alt="JUnit" style="height: 48px; margin: 0 auto 1rem auto; display: block;"> + <strong>JUnit — Testframework</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">Uber 1 Milliarde Downloads pro Monat<br>Ca. 85 % Marktanteil im Java-Okosystem</p> + </div> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="component-logos/apache-log4j.png" alt="Apache Log4j" style="height: 48px; margin: 0 auto 1rem auto; display: block;"> + <strong>Apache Log4j — Logging</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">Ca. 76 % aller Java-Anwendungen nutzen Log4j<br>Geschäftskritisch fur Protokollierung, Monitoring und Fehleranalyse</p> + </div> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="component-logos/apache-commons.svg" alt="Apache Commons" style="height: 48px; margin: 0 auto 1rem auto; display: block;"> + <strong>Apache Commons — Standard-Libraries</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">Ca. 49 % der Java-Entwickler setzen Apache Commons aktiv ein<br>Modulare Sammlung: Lang, IO, Collections und weitere</p> + </div> +</div> + +<div style="background-color: #DFF1FD; border-left: 4px solid #5DB9F5; border-radius: 0.5rem; padding: 1.25rem 1.5rem; margin: 1.5rem 0; font-size: 1.1rem; font-weight: 600; color: #020144;"> + Kurz gesagt: Die essentielle Basis der technischen Vertrauenskette Ihrer Java-Anwendungen. +</div> + +## Wo Support & Care ansetzt + +Java-Anwendungen lassen sich in drei Schichten gliedern: + +{{< centered-image src="pyramid.png" width="60%" alt="Die 3 Schichten einer Java-Anwendung">}} + +1. **Anwendungsspezifischer Code** + Ihr individueller Geschäfts- und Fachlogik-Code. Diese Ebene ist hochst wertvoll, aber relativ klein im Umfang — sie baut auf Frameworks und Basistechnologien auf. + +2. **Frameworks & Anwendungsplattformen** + Spring Boot, Quarkus, Jakarta EE und andere. Fur diese Ebene gibt es vielfach kommerziellen Support der jeweiligen Anbieter. + +3. **Basiskomponenten** — **Hier setzt Support & Care an.** + Laufzeitumgebung, Build- und Dependency-Management, Standardbibliotheken, Logging- und Test-Frameworks. Diese Komponenten kommen in praktisch jedem Java-Projekt vor — doch professionellen Support gibt es dafur bisher kaum. + + +<div style="background-color: #DFF1FD; border-left: 4px solid #5DB9F5; border-radius: 0.5rem; padding: 1.25rem 1.5rem; margin: 1.5rem 0; font-size: 1.1rem; font-weight: 600; color: #020144;"> + Framework-Support allein reicht nicht. Die <a href="https://www.bsi.bund.de/DE/Themen/Verbraucherinnen-und-Verbraucher/Cyber-Sicherheitslage/Schwachstelle-log4Shell-Java-Bibliothek/log4j_node.html" target="_blank" rel="noopener">Log4Shell-Schwachstelle</a> hat gezeigt: Eine kritische Sicherheitslucke in einer Basiskomponente kann Millionen von Anwendungen treffen — trotz aktueller Framework-Updates. Support & Care schliesst genau diese Lucke. +</div> + +## Unsere Leistungen + +Alle Leistungen werden direkt von den Maintainern und Committern der betreuten Projekte erbracht — nicht von einem nachgelagerten Support-Team. + +<div style="display: flex; flex-wrap: wrap; justify-content: center; gap: 2rem; margin: 2rem 0;"> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="services-pictograms/long-term-support.svg" alt="Long Term Support" style="height: 96px; margin: 0 auto 1rem auto; display: block;"> + <strong>Long Term Support (LTS)</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">Weiterfuhrung fur die wichtigsten Versionen zur besseren Planung und Organisation Ihrer Updates. Sie mussen keine unsicheren oder nicht gewarteten Versionen einsetzen.</p> + </div> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="services-pictograms/security.svg" alt="Sicherheitsupdates" style="height: 96px; margin: 0 auto 1rem auto; display: block;"> + <strong>Sicherheitsupdates & Bugfixes</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">Fruhzeitige Informationen und Benachrichtigungen zu Schwachstellen und Patches. Schnelle Reaktionszeiten durch direkten Zugang zu den Entwicklern.</p> + </div> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="services-pictograms/documentation.svg" alt="Dokumentation" style="height: 96px; margin: 0 auto 1rem auto; display: block;"> + <strong>Dokumentation & Transparenz</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">Unterstutzung bei SBOM-Strategien und technischer Dokumentation — auf Deutsch oder Englisch. Transparente Nachvollziehbarkeit aller Anderungen.</p> + </div> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="services-pictograms/workshops.svg" alt="Workshops" style="height: 96px; margin: 0 auto 1rem auto; display: block;"> + <strong>Workshops & Beratung</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">Direkter Austausch mit den Maintainern und Committern der Projekte — auf Deutsch oder Englisch. Individuelle Beratung zu Migration, Best Practices und Architekturentscheidungen.</p> + </div> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="services-pictograms/workshops.svg" alt="Webinare" style="height: 96px; margin: 0 auto 1rem auto; display: block;"> + <strong>Regelmässige Webinare & Statusupdates</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">Quartalsweise Webinare zu aktuellen Sicherheitsrisiken, wichtigen Versionsanderungen, Best-Practice-Empfehlungen und konkreten Auswirkungen auf Ihre OSS-Lieferkette.</p> + </div> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="services-pictograms/custom-containers.svg" alt="Kundenspezifische Builds" style="height: 96px; margin: 0 auto 1rem auto; display: block;"> + <strong>Kundenspezifische Builds & Tooling</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">Massgeschneiderte Umsetzungen direkt durch die Maintainer — von speziellen Build-Konfigurationen bis zu individualisierten Tooling-Losungen.</p> + </div> +</div> + +### Vorbereitet auf den Cyber Resilience Act + +Ab 2027 sind Hersteller im Rahmen des Cyber Resilience Act (CRA) fur 100 % ihrer Software verantwortlich — einschliesslich aller Open-Source-Abhangigkeiten. +Das betrifft Patchzeiten, Schwachstellenmanagement, Dokumentation und langfristige Wartbarkeit. +Open Elements agiert als Open-Source-Steward und gestaltet die regulatorischen Rahmenbedingungen aktiv mit. +Als Grundungsmitglied der **Open Regulatory Compliance Working Group (ORC WG)** der Eclipse Foundation arbeiten wir gemeinsam mit fuhrenden Open-Source-Foundations, grossen Technologieunternehmen und Vertretern der EU an konkreten Spezifikationen und Praxisleitfaden zur CRA-Umsetzung. + +**Support & Care hilft Ihnen konkret bei:** +- Deutliche Reduzierung von Patchzeiten +- Systematische Schwachstellenuberwachung +- Planbare Verfugbarkeit von Updates +- Sicherstellung von Dokumentation und Transparenz (inkl. SBOM) +- Langfristige Wartbarkeitsgarantie +- Perspektivisch: CRA-konforme Attestierungen fur betreute Projekte + +<div style="background-color: #DFF1FD; border-left: 4px solid #5DB9F5; border-radius: 0.5rem; padding: 1.25rem 1.5rem; margin: 1.5rem 0; font-size: 1.1rem; font-weight: 600; color: #020144;"> + Open Elements ist Grundungsmitglied der ORC WG und arbeitet direkt an den Best Practices, die definieren, wie CRA-Compliance fur Open-Source-Software umgesetzt wird. Diese Expertise fliesst unmittelbar in Support & Care ein. +</div> + +### Gehärtete Container für Staat und Verwaltung + +Auch das ist Support & Care: Gehärtete Container fur die deutsche Verwaltung + +Open Elements gehort zu einer exklusiven Gruppe von Organisationen, die gehärtete Container-Images fur **container.gov.de** bereitstellen durfen — neben dem Zentrum fur Digitale Souveranitat (ZenDiS) und dem Auswartigen Amt. +Für Support & Care Kunden bedeutet das: Die gehärteten Eclipse-Temurin-Images für alle aktuellen Java-LTS-Versionen (Java 11, 17, 21, 25+) sind Teil des Leistungsumfangs. +Verifiziert, signiert und kontinuierlich gegen aktuelle Schwachstellendatenbanken abgeglichen. + +**Was gehärtete Container auszeichnet:** +- Verifizierte Herkunft und Qualitätssicherung +- Aktuelle Abhängigkeiten ohne bekannte Schwachstellen +- Software Bill of Materials (SBOM) fur volle Transparenz +- Kryptographische Signierung gegen Manipulation +- Minimierte Angriffsflache durch systematisches Hardening + +{{< centered-image src="oe-delivers-container.png" width="60%" showCaption="true" alt="Open Elements liefert in Zukunft offizielle gehärtete Container-Images für die deutsche öffentliche Verwaltung">}} + +## Mehr als nur Support: Unser Modell + +Support & Care funktioniert anders als klassischer Vendor-Support. +Sie tragen gemeinsam mit uns die laufenden Pflege- und Verbesserungsaufwande fur die betreuten Open-Source-Komponenten — offen, nachvollziehbar und messbar. + +Hier folgt Support & Care drei wichtigen Prinzipien: + +- **1. Gelder fliessen direkt an die Maintainer**: Statt oberflachliche Support-Schichten daruber zu legen, investieren wir in die Vitalitat des jeweiligen Projekt-Kerns. Die Menschen, die den Code tatsachlich pflegen, Sicherheitsupdates bereitstellen und neue Features entwickeln, werden direkt bezahlt. +- **2. Ihre Prioritaten in den Roadmaps**: Kundenanforderungen werden aktiv in die Entwicklungs-Roadmaps der betreuten Projekte integriert. So spiegeln Weiterentwicklungen direkt reale Unternehmensbedurfnisse wider. +- **3. Proaktive Kommunikation**: Sie werden nicht nur bei Problemen informiert, sondern kontinuierlich uber relevante Entwicklungen auf dem Laufenden gehalten: + - Sicherheitswarnungen und neue Patches + - Geplante API- oder Major-Version-Anderungen + - Empfehlungen zu Versionsupdates und Abhangigkeitsbereinigungen + - Trends und Risiken im OSS-Okosystem + +<div style="background-color: #DFF1FD; border-left: 4px solid #5DB9F5; border-radius: 0.5rem; padding: 1.25rem 1.5rem; margin: 1.5rem 0; font-size: 1.1rem; font-weight: 600; color: #020144;"> + Nicht genutzte Support-Stunden verfallen nicht — sie fliessen direkt in die Weiterentwicklung der Open-Source-Komponenten. Jede Subscription starkt die Projekte, auf die Sie sich verlassen. +</div> + +Hierbei liefern wir flexible Leistungsmodelle für nachhaltige Sicherheit. +Wählen Sie das Modell, das zu Ihren Anforderungen in Verfügbarkeit, Compliance und SLA passt. + +{{< support-care-subscription-packages >}} + +## Warum Open Elements + +Wir sind die Maintainer — nicht nur Berater: +Unsere Mitarbeiter sind keine externen Consultants, die Projekte erst kennenlernen müssen. +Sie sind die Menschen, die diese Projekte pflegen, weiterentwickeln und in den Foundations mitgestalten. + +<div style="display: flex; flex-wrap: wrap; justify-content: center; gap: 2rem; margin: 2rem 0;"> + <a href="/de/about-hendrik/" style="text-align: center; width: 180px; text-decoration: none; color: inherit;"> + <img src="/team/hendrik.jpg" alt="Hendrik Ebbers" style="width: 120px; height: 120px; border-radius: 50%; object-fit: cover; margin: 0 auto 0.75rem auto; display: block; border: 3px solid #5DB9F5;"> + <strong style="display: block; font-size: 0.95rem;">Hendrik Ebbers</strong> + <span style="font-size: 0.8rem; color: #5CBA9E;">Founder & Eclipse Board Member</span> + </a> + <a href="/de/employees/sandra" style="text-align: center; width: 180px; text-decoration: none; color: inherit;"> + <img src="/team/sandra.jpg" alt="Sandra Parsick" style="width: 120px; height: 120px; border-radius: 50%; object-fit: cover; margin: 0 auto 0.75rem auto; display: block; border: 3px solid #5DB9F5;"> + <strong style="display: block; font-size: 0.95rem;">Sandra Parsick</strong> + <span style="font-size: 0.8rem; color: #5CBA9E;">Java Champion & OSS Maintainer</span> + </a> + <a href="/de/employees/sebastian" style="text-align: center; width: 180px; text-decoration: none; color: inherit;"> + <img src="/team/sebastian.jpg" alt="Sebastian Tiemann" style="width: 120px; height: 120px; border-radius: 50%; object-fit: cover; margin: 0 auto 0.75rem auto; display: block; border: 3px solid #5DB9F5;"> + <strong style="display: block; font-size: 0.95rem;">Sebastian Tiemann</strong> + <span style="font-size: 0.8rem; color: #5CBA9E;">OSS Engineer & Maintainer Log4j</span> + </a> +</div> + +Open Elements ist ein bekanntes und aktives Mitglied der Open Source Community und arbeitet nicht nur auf technischer Basis sondern auch auf Leitender Ebene in vielen Open Source Foundation mit: + +<div style="display: flex; flex-wrap: wrap; justify-content: center; gap: 2rem; margin: 2rem 0;"> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="foundation-logos/eclipse.png" alt="Eclipse Foundation" style="height: 64px; margin: 0 auto 1rem auto; display: block;"> + <strong>Eclipse Foundation</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">Wir sind im Board der Eclipse Foundation vertreten und aktives Mitglied in Arbeitsgruppen wie Eclipse Adoptium, Eclipse JakartaEE oder ORC WG.</p> + </div> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="foundation-logos/lf.svg" alt="Linux Foundation" style="height: 64px; margin: 0 auto 1rem auto; display: block;"> + <strong>Linux Foundation</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">TODO</p> + </div> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="foundation-logos/afs.svg" alt="Apache Software Foundation" style="height: 64px; margin: 0 auto 1rem auto; display: block;"> + <strong>Apache Software Foundation</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">TODO</p> + </div> +</div> + +<div style="background-color: #DFF1FD; border-left: 4px solid #5DB9F5; border-radius: 0.5rem; padding: 1.25rem 1.5rem; margin: 1.5rem 0; font-size: 1.1rem; font-weight: 600; color: #020144;"> + Open Source — aber richtig. Unsere Einnahmen aus Support & Care fliessen direkt in die betreuten Open-Source-Projekte. +</div> + +## 12. Haufig gestellte Fragen + +<div style="display: flex; flex-direction: column; gap: 1rem; margin: 2rem 0;"> + + <details style="border: 1px solid #e5e7eb; border-radius: 0.75rem; padding: 1.25rem 1.5rem; cursor: pointer;"> + <summary style="font-weight: 700; font-size: 1.05rem; color: #020144;">Ist Support & Care nur fur Apache Maven?</summary> + <p style="margin-top: 0.75rem; line-height: 1.6;">Nein. Support & Care deckt fünf geschäftskritische Java-Basiskomponenten ab: Eclipse Temurin, Apache Maven, JUnit, Apache Log4j und Apache Commons. Das Programm startete 2024 mit Maven und wurde seitdem kontinuierlich erweitert.</p> + </details> + + <details style="border: 1px solid #e5e7eb; border-radius: 0.75rem; padding: 1.25rem 1.5rem; cursor: pointer;"> + <summary style="font-weight: 700; font-size: 1.05rem; color: #020144;">Wer leistet den Support?</summary> + <p style="margin-top: 0.75rem; line-height: 1.6;">Committer und Maintainer der jeweiligen Open-Source-Projekte — die Personen, die den Code tatsachlich schreiben und pflegen. Kein nachgelagertes Support-Team, sondern direkter Zugang zu den Experten.</p> + </details> + + <details style="border: 1px solid #e5e7eb; border-radius: 0.75rem; padding: 1.25rem 1.5rem; cursor: pointer;"> + <summary style="font-weight: 700; font-size: 1.05rem; color: #020144;">Was passiert mit meiner Subscription-Gebühr?</summary> + <p style="margin-top: 0.75rem; line-height: 1.6;">Die Einnahmen fliessen transparent und nachvollziehbar in die betreuten Open-Source-Projekte: Bezahlung der Maintainer, Sicherheitsupdates, Bugfixes, Dokumentation und Infrastruktur.</p> + </details> + + <details style="border: 1px solid #e5e7eb; border-radius: 0.75rem; padding: 1.25rem 1.5rem; cursor: pointer;"> + <summary style="font-weight: 700; font-size: 1.05rem; color: #020144;">Muss ich alle fünf Komponenten abonnieren?</summary> + <p style="margin-top: 0.75rem; line-height: 1.6;">Sprechen Sie uns an — wir schneiden das Angebot auf Ihre konkreten Anforderungen zu.</p> + </details> + + <details style="border: 1px solid #e5e7eb; border-radius: 0.75rem; padding: 1.25rem 1.5rem; cursor: pointer;"> + <summary style="font-weight: 700; font-size: 1.05rem; color: #020144;">Hilft Support & Care bei der CRA-Compliance?</summary> + <p style="margin-top: 0.75rem; line-height: 1.6;">Ja. Support & Care adressiert zentrale CRA-Anforderungen: Schwachstellenüberwachung, Patchzeiten, Dokumentation, SBOM und langfristige Wartbarkeit. Perspektivisch unterstutzen wir auch bei CRA-konformen Attestierungen.</p> + </details> + + <details style="border: 1px solid #e5e7eb; border-radius: 0.75rem; padding: 1.25rem 1.5rem; cursor: pointer;"> + <summary style="font-weight: 700; font-size: 1.05rem; color: #020144;">In welchen Sprachen wird Support geleistet?</summary> + <p style="margin-top: 0.75rem; line-height: 1.6;">Deutsch und Englisch — sowohl für Helpdesk-Anfragen als auch für Workshops, Beratung und Dokumentation.</p> + </details> + + <details style="border: 1px solid #e5e7eb; border-radius: 0.75rem; padding: 1.25rem 1.5rem; cursor: pointer;"> + <summary style="font-weight: 700; font-size: 1.05rem; color: #020144;">Was ist der Unterschied zu Framework-Support (z.B. bei Spring Boot)?</summary> + <p style="margin-top: 0.75rem; line-height: 1.6;">Framework-Support deckt die mittlere Schicht Ihres Software-Stacks ab. Support & Care betreut die Basisschicht darunter: Laufzeit, Build-Tools, Logging, Testing und Utility-Libraries. Beides ergänzt sich — <a href="https://www.bsi.bund.de/DE/Themen/Verbraucherinnen-und-Verbraucher/Cyber-Sicherheitslage/Schwachstelle-log4Shell-Java-Bibliothek/log4j_node.html" target="_blank" rel="noopener">Log4Shell</a> hat gezeigt, dass Framework-Support allein nicht ausreicht.</p> + </details> + +</div> + +## Sichern Sie die Basis Ihrer Java-Anwendungen + +Lassen Sie uns gemeinsam besprechen, wie Support & Care Ihre Software-Lieferkette absichert. +Ob Privatwirtschaft oder offentliche Verwaltung — wir finden das passende Modell für Sie. + +<div style="display: flex; justify-content: center; margin: 1.5rem auto;"> + <a href="/contact" class="inline-flex shrink-0 items-center justify-center gap-3 px-6 py-3.5 text-lg font-bold text-white text-center bg-sky rounded-full transition-all duration-150 ease-in-out hover:bg-sky-200 hover:shadow-8 active:shadow-none" style="color: white !important; text-decoration: none !important;">Kontakt aufnehmen</a> +</div> + +<hr style="border: none; border-top: 1px solid #e5e7eb; margin: 3rem 0 1.5rem 0;"> +<div style="font-size: 0.75rem; color: #6b7280; line-height: 1.8;"> + <sup>1</sup> Nicht genutzte Support-Stunden verfallen monatlich und fliessen in die Weiterentwicklung der betreuten Projekte.<br> + <sup>2</sup> Werktage ohne Feiertage in NRW.<br> + <sup>3</sup> Helpdesk DSGVO-konform und EU-gehostet.<br> + <sup>4</sup> Expert:innen sind Committer und Maintainer der betreuten OSS-Projekte.<br> + <sup>5</sup> Webinare und Calls per Videokonferenz. +</div> \ No newline at end of file diff --git a/content/support-care-landingpage/index.md b/content/support-care-landingpage/index.md index 3761fb45..e904fd4e 100644 --- a/content/support-care-landingpage/index.md +++ b/content/support-care-landingpage/index.md @@ -1,151 +1,308 @@ --- -title: "Support & Care" -description: "TODO" -layout: "single" +title: "Support & Care — Professional Maintenance for Business-Critical Java Components" +description: "Support & Care by Open Elements: Professional maintenance, security updates and long term support for Apache Maven, JUnit, Log4j, Apache Commons and Eclipse Temurin. CRA-compliant. Directly from the maintainers." +layout: "article" url: "/about-support-care" aliases: ['/javaland-2024/support-care'] newsletterPopup: true +showTitle: false --- -Support & Care is a program for the sustainable further development, stabilization and **support of open source software (OSS)**. -Open Elements works with both the industry and the open source community to ensure the quality, -independence and development of critical open source projects and components. - -{{< centered-image src="/illustrations/support-care-logos/support-care-logo.svg" alt="Support & Care Logo" width="80%" >}} - -## Why open source is so important for our lives today - -Open source ensures the quality, security and progressiveness of software, fosters community and provides economic and social benefits. -[Open source offers these benefits](https://opensource.com/resources/what-open-source) to individuals, companies and society as a whole. -It is therefore in everyone's interest to support OSS projects financially. -Due to the wealth of benefits, we want to focus on 4 important aspects here: - - -- **Knowledge sharing and education:** open source projects are often not only software solutions, - but also educational resources. Interested parties can study the code, learn from it and further their education. - In this way, open source promotes knowledge sharing and enables many people to acquire and deepen their technical skills. -- **Trust through transparency:** As the source code of OSS is publicly accessible, anyone can check it. - This creates a high level of trust, as any defects or hidden functions are visible. -- **Independence from individual providers:** OSS reduces dependence on individual software providers and - their business models. - This is particularly important in critical infrastructures to ensure that applications and systems can continue to - be operated in the future. -- **Social justice:** Open source software is often accessible to everyone, regardless of financial means. - OSS projects enable people from all social and economic backgrounds to have access to technology and education. - -{{< centered-image src="os-benefits.png" showCaption="true" alt="Results of the survey on the benefits of open source for SMEs" width="80%" >}} - -### Importance of open source support - -In order to ensure the long-term sustainability of open source projects, it is crucial to support them financially. -Many developers and maintainers work on these projects voluntarily, often without financial compensation. -Through open source support, these projects can be continuously developed and improved. -In addition, open source support allows developers to focus more on the quality and security of the software and -respond more quickly to security vulnerabilities or bugs. -Support also incentivizes new developers to get involved and develop innovative solutions. -In short, financial support helps keep the open source community vibrant and productive, which ultimately benefits everyone. - -{{< centered-image src="tree.png" alt="Illustration regarding cooperation" width="80%" >}} - -[Active participation in open source projects](https://hbswk.hbs.edu/item/the-hidden-benefit-of-giving-back-to-open-source-software) -allows companies to gain valuable insights and technological advancements, which promotes long-term success and -competitiveness while strengthening the open source community. - -## How Support & Care promotes open source software - -With **Support & Care**, Open Elements has launched a program to promote open source in a -**fair and lightweight** way. -Support & Care helps both the open source projects and the people behind these projects. -We focus our support on projects in the Java programming language. -This specialization makes sense because it allows us to apply our in-depth expertise in a specific programming language. -This allows us to provide more efficient and higher quality support for the specific requirements -and challenges that arise in critical Java-based open source projects. - -Critical OSS refers to projects that are included as dependencies in a variety of critical systems and applications in -industries such as banking, healthcare and politics. -One example of this is the Java distribution Eclipse Temurin, which is the most widely used Java runtime -environment with over 500,000 downloads, or Apache Maven, whose main components were downloaded around -2 billion times last year. - -With Support & Care, Open Elements offers a solution for both projects so that the products can be -used without hesitation in a professional environment. -For example, Open Elements is a member of the working group behind Eclipse Temurin - our CEO Hendrik Ebbers -was even a founding member - and has the head of Maven development (Chair of the Project Management Committee) -under contract. - - -{{< centered-image src="roundtable.png" alt="Illustration regarding division of tasks" width="80%" >}} - -Our open source strategy aims to improve the direction of the projects through financial support and active -collaboration and to prevent underfunding, poor maintenance and security of this critical OSS. -By applying this strategy in a targeted manner, we can make groundbreaking improvements to the projects -included in the Support & Care program and ensure that developers are able to continue their important -work without financial setbacks. -Because even though open source is a growing market, without financial reserves its developers may be -forced to reduce or stop their work on the projects. - -## Why Open Elements is the right partner to support OSS - -The goal of Support & Care is to provide holistic promotion and support of OSS instead of “just” providing financial -donations or collaboration. -Our years of experience in open source development have shown us the crucial importance of this support. -For this reason, Open Elements was founded as a company that views and promotes OSS from technical as well -as business and organizational perspectives. - -Through Open Elements' involvement in committees such as the Eclipse Adoptium Working Group, -we have experience with large or critical open source projects and are familiar with their problems and -challenges. -This knowledge is underlined by the membership of our managing director on the supervisory board of the -Eclipse Foundation. -However, due to our company structure, we are so dynamic that we can also easily work with small open source -projects and support them e.g. via Github sponsorship, help newcomers or actively contribute to the source -code of the projects. - -All these points make Open Elements a perfect link between open source and business. - -## How Support & Care can help your company - -Theprovision of support models for open source software has become a popular business model. -Unlike many companies, however, Support & Care does not simply offer support for its own open source products. -We are explicitly looking for OSS that is increasingly used in the enterprise sector, where it is often classified as -security-critical. -Together with the developers behind these open source projects, the Support & Care program creates a link -to both support the projects and explicitly respond to the wishes and needs of Support & Care customers. - -This involves not only the transparent processing of technical tickets by the respective project experts, -but also the preparation and transformation of knowledge. -Support & Care customers receive notifications about important security updates, fixes and releases and -are invited to regular workshops and information events. -This allows OSS users to contribute their own needs and interests to the projects in the shortest possible time. -Through these measures, Open Elements actively promotes the principle of community building for the respective projects: -Communities consisting of developers, users and other stakeholders can work together to drive innovation forward. - -{{< centered-image src="networking.png" alt="Illustration regarding division of tasks" width="80%" >}} - -### What services does Open Source Support include? - -The Open Source Support & Care service offers comprehensive services to ensure the performance and security of your applications. -Our services go beyond classic troubleshooting and promote the sustainable improvement of your infrastructure. -The support contract can be customized according to your needs, socontact us for an individual consultation and find out -more about how our Open Source Support & Care service can improve your IT infrastructure. - -- **Updates on open source projects:** Receive regular reports and detailed information on major releases, - bug fix releases and new projects, including security updates and Critical Patch Updates (CPU). -- **Webinars & Meetings:** Quarterly webinars and 1-on-1 calls provide you with prepared information and the - opportunity to ask questions and contribute needs directly to the projects. -- **Direct support:** Customers have access to multilingual support at all times with guaranteed response times - and the option of video calls for quick problem resolution. -- **Support areas:** Our service covers various open source projects, for example as part of our - [Temurin Support & Care]({{< relref "support-care-temurin" >}}) offering and our - [Maven Support & Care]({{< relref "support-care-maven" >}}) offering. - We take care of ticket creation, maintenance and monitoring in order to solve technical problems efficiently. -- **Maintenance service:** Our service includes the maintenance of customer-specific Docker containers, - which contain all the necessary components for your application and are updated regularly. - The containers are deployed in a Docker registry and tested automatically. - -The support contract can be customized according to your needs. - -[Contact us]({{< relref "contact" >}}) for an individual consultation and find out more, -how our Open Source Support & Care service can improve your IT infrastructure. - -{{< centered-button link="/contact" >}}Schedule a consultation{{</ centered-button >}} +{{< centered-image src="support-and-care-logo.svg" width="80%" alt="Support & Care Logo">}} +<div style="text-align: center; margin-bottom: 1.5rem;"> + <p style="font-size: 1.2rem; font-weight: 400; color: #5CBA9E; max-width: 900px; margin: 0 auto 1rem auto; line-height: 1.5;">Professional maintenance, security updates and long term support for the most business-critical open source components in the Java ecosystem — directly from the maintainers.</p> + <div style="display: flex; flex-wrap: wrap; justify-content: center; align-items: center; gap: 1.25rem; margin: 0 auto 1.25rem auto;"> + <img src="component-logos/eclipse-temurin.svg" alt="Eclipse Temurin" style="height: 28px; width: auto; opacity: 0.7;"> + <img src="component-logos/apache-maven.svg" alt="Apache Maven" style="height: 28px; width: auto; opacity: 0.7;"> + <img src="component-logos/junit.svg" alt="JUnit" style="height: 28px; width: auto; opacity: 0.7;"> + <img src="component-logos/apache-log4j.png" alt="Apache Log4j" style="height: 28px; width: auto; opacity: 0.7;"> + <img src="component-logos/apache-commons.svg" alt="Apache Commons" style="height: 28px; width: auto; opacity: 0.7;"> + </div> + <p style="font-size: 1rem; margin: 0 auto 1.5rem auto; line-height: 1.6; color: #020144;">Modern software consists of over 70% open source components. From 2027, the Cyber Resilience Act (CRA) will hold manufacturers responsible for 100% of their software — including all OSS dependencies. Support & Care secures the foundation of your Java applications: from the runtime environment to build tools and testing strategy.</p> + <div style="display: flex; flex-wrap: wrap; justify-content: center; gap: 1rem; margin-bottom: 1.5rem;"> + <a href="/contact" class="inline-flex shrink-0 items-center justify-center gap-3 px-6 py-3.5 text-lg font-bold text-white text-center bg-sky rounded-full transition-all duration-150 ease-in-out hover:bg-sky-200 hover:shadow-8 active:shadow-none" style="color: white !important; text-decoration: none !important;">Get in touch</a> + <a href="#our-services" class="inline-flex shrink-0 items-center justify-center gap-3 px-6 py-3.5 text-lg font-bold text-white text-center bg-sky rounded-full transition-all duration-150 ease-in-out hover:bg-sky-200 hover:shadow-8 active:shadow-none" style="color: white !important; text-decoration: none !important;">Discover our services</a> + </div> +</div> + +<hr style="border: none; border-top: 2px solid #e5e7eb; width: 40%; margin: 2.5rem auto;"> + +## The Problem: Invisible Dependencies + +A simple Java project with Spring Boot brings over 70 transitive dependencies — most of them open source. +Your individual code is just the tip of the iceberg. +Underneath lie runtime environments, build tools, logging frameworks, test libraries and utility libraries that actually carry the operation of your application. + +<div style="background-color: #DFF1FD; border-left: 4px solid #5DB9F5; border-radius: 0.5rem; padding: 1.25rem 1.5rem; margin: 1.5rem 0; font-size: 1.1rem; font-weight: 600; color: #020144;"> + 70% of software is based on open source and is therefore outside your direct control. +</div> + +These foundational components are often maintained by individual developers in their spare time. +At the same time, they carry the majority of technical risks: +security vulnerabilities, transitive dependencies, missing documentation and compliance responsibility. + +**What this means for you:** +- Vulnerabilities in foundational components often go unnoticed until it is too late +- Framework support alone does not protect against gaps in the foundation — <a href="https://www.bsi.bund.de/DE/Themen/Verbraucherinnen-und-Verbraucher/Cyber-Sicherheitslage/Schwachstelle-log4Shell-Java-Bibliothek/log4j_node.html" target="_blank" rel="noopener">Log4Shell</a> clearly demonstrated this +- The CRA will hold you liable for the entire software supply chain from 2027 + +## Supported Components + +Support & Care specifically covers the five most business-critical open source foundational components of the Java ecosystem. +Together, they form the technical chain of trust for virtually every Java application. + +<div style="display: flex; flex-wrap: wrap; justify-content: center; gap: 2rem; margin: 2rem 0;"> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="component-logos/eclipse-temurin.svg" alt="Eclipse Temurin" style="height: 48px; margin: 0 auto 1rem auto; display: block;"> + <strong>Eclipse Temurin — Java Runtime</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">Leading vendor-independent OpenJDK distribution worldwide<br>Over 500,000 downloads per day<br>TCK-certified, AQAvit-verified, community-driven</p> + </div> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="component-logos/apache-maven.svg" alt="Apache Maven" style="height: 48px; margin: 0 auto 1rem auto; display: block;"> + <strong>Apache Maven — Build & Dependency Management</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">Over 75% of all Java projects use Maven<br>Approx. 2 billion downloads annually</p> + </div> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="component-logos/junit.svg" alt="JUnit" style="height: 48px; margin: 0 auto 1rem auto; display: block;"> + <strong>JUnit — Test Framework</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">Over 1 billion downloads per month<br>Approx. 85% market share in the Java ecosystem</p> + </div> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="component-logos/apache-log4j.png" alt="Apache Log4j" style="height: 48px; margin: 0 auto 1rem auto; display: block;"> + <strong>Apache Log4j — Logging</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">Approx. 76% of all Java applications use Log4j<br>Business-critical for logging, monitoring and error analysis</p> + </div> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="component-logos/apache-commons.svg" alt="Apache Commons" style="height: 48px; margin: 0 auto 1rem auto; display: block;"> + <strong>Apache Commons — Standard Libraries</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">Approx. 49% of Java developers actively use Apache Commons<br>Modular collection: Lang, IO, Collections and more</p> + </div> +</div> + +<div style="background-color: #DFF1FD; border-left: 4px solid #5DB9F5; border-radius: 0.5rem; padding: 1.25rem 1.5rem; margin: 1.5rem 0; font-size: 1.1rem; font-weight: 600; color: #020144;"> + In short: The essential foundation of the technical chain of trust for your Java applications. +</div> + +## Where Support & Care Steps In + +Java applications can be divided into three layers: + +{{< centered-image src="pyramid.png" width="60%" alt="The 3 layers of a Java application">}} + +1. **Application-Specific Code** + Your individual business and domain logic code. This layer is highly valuable but relatively small in scope — it builds on frameworks and foundational technologies. + +2. **Frameworks & Application Platforms** + Spring Boot, Quarkus, Jakarta EE and others. Commercial support from the respective vendors is widely available for this layer. + +3. **Foundational Components** — **This is where Support & Care steps in.** + Runtime environment, build and dependency management, standard libraries, logging and test frameworks. These components are used in virtually every Java project — yet professional support has been largely unavailable until now. + + +<div style="background-color: #DFF1FD; border-left: 4px solid #5DB9F5; border-radius: 0.5rem; padding: 1.25rem 1.5rem; margin: 1.5rem 0; font-size: 1.1rem; font-weight: 600; color: #020144;"> + Framework support alone is not enough. The <a href="https://www.bsi.bund.de/DE/Themen/Verbraucherinnen-und-Verbraucher/Cyber-Sicherheitslage/Schwachstelle-log4Shell-Java-Bibliothek/log4j_node.html" target="_blank" rel="noopener">Log4Shell vulnerability</a> demonstrated: A critical security flaw in a foundational component can affect millions of applications — despite up-to-date framework updates. Support & Care closes exactly this gap. +</div> + +## Our Services + +All services are delivered directly by the maintainers and committers of the supported projects — not by a downstream support team. + +<div style="display: flex; flex-wrap: wrap; justify-content: center; gap: 2rem; margin: 2rem 0;"> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="services-pictograms/long-term-support.svg" alt="Long Term Support" style="height: 96px; margin: 0 auto 1rem auto; display: block;"> + <strong>Long Term Support (LTS)</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">Continued support for the most important versions to help you better plan and organize your updates. You never have to rely on insecure or unmaintained versions.</p> + </div> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="services-pictograms/security.svg" alt="Security Updates" style="height: 96px; margin: 0 auto 1rem auto; display: block;"> + <strong>Security Updates & Bugfixes</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">Early information and notifications about vulnerabilities and patches. Fast response times through direct access to the developers.</p> + </div> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="services-pictograms/documentation.svg" alt="Documentation" style="height: 96px; margin: 0 auto 1rem auto; display: block;"> + <strong>Documentation & Transparency</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">Support with SBOM strategies and technical documentation — in German or English. Transparent traceability of all changes.</p> + </div> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="services-pictograms/workshops.svg" alt="Workshops" style="height: 96px; margin: 0 auto 1rem auto; display: block;"> + <strong>Workshops & Consulting</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">Direct exchange with the maintainers and committers of the projects — in German or English. Individual consulting on migration, best practices and architectural decisions.</p> + </div> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="services-pictograms/workshops.svg" alt="Webinars" style="height: 96px; margin: 0 auto 1rem auto; display: block;"> + <strong>Regular Webinars & Status Updates</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">Quarterly webinars on current security risks, important version changes, best practice recommendations and concrete impacts on your OSS supply chain.</p> + </div> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="services-pictograms/custom-containers.svg" alt="Custom Builds" style="height: 96px; margin: 0 auto 1rem auto; display: block;"> + <strong>Custom Builds & Tooling</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">Tailored implementations directly by the maintainers — from special build configurations to individualized tooling solutions.</p> + </div> +</div> + +### Prepared for the Cyber Resilience Act + +From 2027, manufacturers will be responsible for 100% of their software under the Cyber Resilience Act (CRA) — including all open source dependencies. +This covers patch times, vulnerability management, documentation and long-term maintainability. +Open Elements acts as an open source steward and actively shapes the regulatory framework. +As a founding member of the **Open Regulatory Compliance Working Group (ORC WG)** of the Eclipse Foundation, we work together with leading open source foundations, major technology companies and EU representatives on concrete specifications and practical guidelines for CRA implementation. + +**Support & Care specifically helps you with:** +- Significant reduction of patch times +- Systematic vulnerability monitoring +- Predictable availability of updates +- Ensuring documentation and transparency (incl. SBOM) +- Long-term maintainability guarantee +- Prospectively: CRA-compliant attestations for supported projects + +<div style="background-color: #DFF1FD; border-left: 4px solid #5DB9F5; border-radius: 0.5rem; padding: 1.25rem 1.5rem; margin: 1.5rem 0; font-size: 1.1rem; font-weight: 600; color: #020144;"> + Open Elements is a founding member of the ORC WG and works directly on the best practices that define how CRA compliance for open source software is implemented. This expertise flows directly into Support & Care. +</div> + +### Hardened Containers for Government and Public Administration + +This is also Support & Care: Hardened containers for the German public administration. + +Open Elements belongs to an exclusive group of organizations authorized to provide hardened container images for **container.gov.de** — alongside the Center for Digital Sovereignty (ZenDiS) and the German Federal Foreign Office. +For Support & Care customers, this means: The hardened Eclipse Temurin images for all current Java LTS versions (Java 11, 17, 21, 25+) are included in the service scope. +Verified, signed and continuously checked against current vulnerability databases. + +**What distinguishes hardened containers:** +- Verified origin and quality assurance +- Up-to-date dependencies without known vulnerabilities +- Software Bill of Materials (SBOM) for full transparency +- Cryptographic signing against tampering +- Minimized attack surface through systematic hardening + +{{< centered-image src="oe-delivers-container.png" width="60%" showCaption="true" alt="Open Elements delivers official hardened container images for the German public administration">}} + +## More Than Just Support: Our Model + +Support & Care works differently from traditional vendor support. +Together with us, you share the ongoing maintenance and improvement efforts for the supported open source components — openly, transparently and measurably. + +Support & Care follows three important principles: + +- **1. Funds flow directly to the maintainers**: Instead of layering superficial support on top, we invest in the vitality of each project's core. The people who actually maintain the code, provide security updates and develop new features are paid directly. +- **2. Your priorities in the roadmaps**: Customer requirements are actively integrated into the development roadmaps of the supported projects. This way, enhancements directly reflect real business needs. +- **3. Proactive communication**: You are not only informed when problems arise, but continuously kept up to date on relevant developments: + - Security warnings and new patches + - Planned API or major version changes + - Recommendations for version updates and dependency cleanup + - Trends and risks in the OSS ecosystem + +<div style="background-color: #DFF1FD; border-left: 4px solid #5DB9F5; border-radius: 0.5rem; padding: 1.25rem 1.5rem; margin: 1.5rem 0; font-size: 1.1rem; font-weight: 600; color: #020144;"> + Unused support hours do not expire — they flow directly into the further development of the open source components. Every subscription strengthens the projects you rely on. +</div> + +We deliver flexible service models for sustainable security. +Choose the model that fits your requirements in availability, compliance and SLA. + +{{< support-care-subscription-packages >}} + +## Why Open Elements + +We are the maintainers — not just consultants: +Our team members are not external consultants who first need to get to know the projects. +They are the people who maintain, develop and co-shape these projects within the foundations. + +<div style="display: flex; flex-wrap: wrap; justify-content: center; gap: 2rem; margin: 2rem 0;"> + <a href="/about-hendrik/" style="text-align: center; width: 180px; text-decoration: none; color: inherit;"> + <img src="/team/hendrik.jpg" alt="Hendrik Ebbers" style="width: 120px; height: 120px; border-radius: 50%; object-fit: cover; margin: 0 auto 0.75rem auto; display: block; border: 3px solid #5DB9F5;"> + <strong style="display: block; font-size: 0.95rem;">Hendrik Ebbers</strong> + <span style="font-size: 0.8rem; color: #5CBA9E;">Founder & Eclipse Board Member</span> + </a> + <a href="/employees/sandra" style="text-align: center; width: 180px; text-decoration: none; color: inherit;"> + <img src="/team/sandra.jpg" alt="Sandra Parsick" style="width: 120px; height: 120px; border-radius: 50%; object-fit: cover; margin: 0 auto 0.75rem auto; display: block; border: 3px solid #5DB9F5;"> + <strong style="display: block; font-size: 0.95rem;">Sandra Parsick</strong> + <span style="font-size: 0.8rem; color: #5CBA9E;">Java Champion & OSS Maintainer</span> + </a> + <a href="/employees/sebastian" style="text-align: center; width: 180px; text-decoration: none; color: inherit;"> + <img src="/team/sebastian.jpg" alt="Sebastian Tiemann" style="width: 120px; height: 120px; border-radius: 50%; object-fit: cover; margin: 0 auto 0.75rem auto; display: block; border: 3px solid #5DB9F5;"> + <strong style="display: block; font-size: 0.95rem;">Sebastian Tiemann</strong> + <span style="font-size: 0.8rem; color: #5CBA9E;">OSS Engineer & Maintainer Log4j</span> + </a> +</div> + +Open Elements is a well-known and active member of the open source community, contributing not only on a technical level but also in leadership roles across many open source foundations: + +<div style="display: flex; flex-wrap: wrap; justify-content: center; gap: 2rem; margin: 2rem 0;"> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="foundation-logos/eclipse.png" alt="Eclipse Foundation" style="height: 64px; margin: 0 auto 1rem auto; display: block;"> + <strong>Eclipse Foundation</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">We hold a seat on the Eclipse Foundation Board and are active members of working groups such as Eclipse Adoptium, Eclipse JakartaEE and the ORC WG.</p> + </div> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="foundation-logos/lf.svg" alt="Linux Foundation" style="height: 64px; margin: 0 auto 1rem auto; display: block;"> + <strong>Linux Foundation</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">TODO</p> + </div> + <div style="text-align: center; padding: 1.5rem; border: 1px solid #e5e7eb; border-radius: 1rem; width: 320px; flex-shrink: 0;"> + <img src="foundation-logos/afs.svg" alt="Apache Software Foundation" style="height: 64px; margin: 0 auto 1rem auto; display: block;"> + <strong>Apache Software Foundation</strong> + <p style="margin-top: 0.75rem; font-size: 0.9rem; line-height: 1.6;">TODO</p> + </div> +</div> + +<div style="background-color: #DFF1FD; border-left: 4px solid #5DB9F5; border-radius: 0.5rem; padding: 1.25rem 1.5rem; margin: 1.5rem 0; font-size: 1.1rem; font-weight: 600; color: #020144;"> + Open source — done right. Our revenue from Support & Care flows directly into the supported open source projects. +</div> + +## Frequently Asked Questions + +<div style="display: flex; flex-direction: column; gap: 1rem; margin: 2rem 0;"> + + <details style="border: 1px solid #e5e7eb; border-radius: 0.75rem; padding: 1.25rem 1.5rem; cursor: pointer;"> + <summary style="font-weight: 700; font-size: 1.05rem; color: #020144;">Is Support & Care only for Apache Maven?</summary> + <p style="margin-top: 0.75rem; line-height: 1.6;">No. Support & Care covers five business-critical Java foundational components: Eclipse Temurin, Apache Maven, JUnit, Apache Log4j and Apache Commons. The program started in 2024 with Maven and has been continuously expanded since then.</p> + </details> + + <details style="border: 1px solid #e5e7eb; border-radius: 0.75rem; padding: 1.25rem 1.5rem; cursor: pointer;"> + <summary style="font-weight: 700; font-size: 1.05rem; color: #020144;">Who provides the support?</summary> + <p style="margin-top: 0.75rem; line-height: 1.6;">Committers and maintainers of the respective open source projects — the people who actually write and maintain the code. No downstream support team, but direct access to the experts.</p> + </details> + + <details style="border: 1px solid #e5e7eb; border-radius: 0.75rem; padding: 1.25rem 1.5rem; cursor: pointer;"> + <summary style="font-weight: 700; font-size: 1.05rem; color: #020144;">What happens with my subscription fee?</summary> + <p style="margin-top: 0.75rem; line-height: 1.6;">The revenue flows transparently and traceably into the supported open source projects: payment of maintainers, security updates, bugfixes, documentation and infrastructure.</p> + </details> + + <details style="border: 1px solid #e5e7eb; border-radius: 0.75rem; padding: 1.25rem 1.5rem; cursor: pointer;"> + <summary style="font-weight: 700; font-size: 1.05rem; color: #020144;">Do I have to subscribe to all five components?</summary> + <p style="margin-top: 0.75rem; line-height: 1.6;">Get in touch — we tailor the offering to your specific requirements.</p> + </details> + + <details style="border: 1px solid #e5e7eb; border-radius: 0.75rem; padding: 1.25rem 1.5rem; cursor: pointer;"> + <summary style="font-weight: 700; font-size: 1.05rem; color: #020144;">Does Support & Care help with CRA compliance?</summary> + <p style="margin-top: 0.75rem; line-height: 1.6;">Yes. Support & Care addresses key CRA requirements: vulnerability monitoring, patch times, documentation, SBOM and long-term maintainability. Prospectively, we also support CRA-compliant attestations.</p> + </details> + + <details style="border: 1px solid #e5e7eb; border-radius: 0.75rem; padding: 1.25rem 1.5rem; cursor: pointer;"> + <summary style="font-weight: 700; font-size: 1.05rem; color: #020144;">In which languages is support provided?</summary> + <p style="margin-top: 0.75rem; line-height: 1.6;">German and English — for helpdesk requests as well as workshops, consulting and documentation.</p> + </details> + + <details style="border: 1px solid #e5e7eb; border-radius: 0.75rem; padding: 1.25rem 1.5rem; cursor: pointer;"> + <summary style="font-weight: 700; font-size: 1.05rem; color: #020144;">What is the difference to framework support (e.g. Spring Boot)?</summary> + <p style="margin-top: 0.75rem; line-height: 1.6;">Framework support covers the middle layer of your software stack. Support & Care covers the foundational layer underneath: runtime, build tools, logging, testing and utility libraries. Both complement each other — <a href="https://www.bsi.bund.de/DE/Themen/Verbraucherinnen-und-Verbraucher/Cyber-Sicherheitslage/Schwachstelle-log4Shell-Java-Bibliothek/log4j_node.html" target="_blank" rel="noopener">Log4Shell</a> showed that framework support alone is not enough.</p> + </details> + +</div> + +## Secure the Foundation of Your Java Applications + +Let us discuss together how Support & Care can protect your software supply chain. +Whether private sector or public administration — we will find the right model for you. + +<div style="display: flex; justify-content: center; margin: 1.5rem auto;"> + <a href="/contact" class="inline-flex shrink-0 items-center justify-center gap-3 px-6 py-3.5 text-lg font-bold text-white text-center bg-sky rounded-full transition-all duration-150 ease-in-out hover:bg-sky-200 hover:shadow-8 active:shadow-none" style="color: white !important; text-decoration: none !important;">Get in touch</a> +</div> + +<hr style="border: none; border-top: 1px solid #e5e7eb; margin: 3rem 0 1.5rem 0;"> +<div style="font-size: 0.75rem; color: #6b7280; line-height: 1.8;"> + <sup>1</sup> Unused support hours expire monthly and flow into the further development of the supported projects.<br> + <sup>2</sup> Business days excluding public holidays in NRW.<br> + <sup>3</sup> Helpdesk GDPR-compliant and EU-hosted.<br> + <sup>4</sup> Experts are committers and maintainers of the supported OSS projects.<br> + <sup>5</sup> Webinars and calls via video conference. +</div> diff --git a/content/support-care-landingpage/oe-delivers-container.png b/content/support-care-landingpage/oe-delivers-container.png new file mode 100644 index 00000000..2872524c Binary files /dev/null and b/content/support-care-landingpage/oe-delivers-container.png differ diff --git a/content/support-care-landingpage/pyramid.png b/content/support-care-landingpage/pyramid.png new file mode 100644 index 00000000..c3aa3c77 Binary files /dev/null and b/content/support-care-landingpage/pyramid.png differ diff --git a/content/support-care-landingpage/services-pictograms/custom-containers.svg b/content/support-care-landingpage/services-pictograms/custom-containers.svg new file mode 100644 index 00000000..954177ac --- /dev/null +++ b/content/support-care-landingpage/services-pictograms/custom-containers.svg @@ -0,0 +1,59 @@ +<?xml version="1.0" encoding="UTF-8"?> +<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" xmlns:serif="http://www.serif.com/" version="1.1" viewBox="0 0 1366 768"> + <defs> + <style> + .cls-1 { + fill-rule: evenodd; + } + + .cls-1, .cls-2, .cls-3, .cls-4 { + stroke-width: 0px; + } + + .cls-1, .cls-2, .cls-4 { + fill: #5cba9e; + } + + .cls-5 { + stroke: #5cba9e; + stroke-linecap: round; + stroke-opacity: .5; + } + + .cls-5, .cls-3, .cls-6 { + fill: none; + } + + .cls-5, .cls-6 { + stroke-linejoin: round; + stroke-width: 11.9px; + } + + .cls-2 { + fill-opacity: .5; + } + + .cls-6 { + stroke: #020144; + } + </style> + </defs> + <rect id="_01_Docker" data-name=" 01 Docker" class="cls-3" x="299" width="768" height="768" serif:id="01_Docker"/> + <g id="_01_Docker1" data-name=" 01 Docker1" serif:id="01_Docker"> + <rect class="cls-6" x="641" y="218.8" width="66.6" height="66.6"/> + <rect class="cls-6" x="641" y="120.6" width="66.6" height="66.6"/> + <rect class="cls-4" x="463.4" y="336.6" width="47.4" height="47.4"/> + <rect class="cls-4" x="561.5" y="336.6" width="47.4" height="47.4"/> + <rect class="cls-4" x="758.7" y="336.6" width="47.4" height="47.4"/> + <path class="cls-1" d="M741.3,588.4h0c-34.9,7.2-76.6,6.3-125.8-7.9,0,0-112.1-35.2-93.4-161.7h345.7s-36.9-48.4,5.3-87.9c0,0,39.6,17.7,39.6,51.9,0,0,33.4-12.1,63.5,9.8,0,0-21.1,57.3-72.4,46.7,0,0-3.9,11.8-12.8,28.9,0,0-58.1,91.7-149.7,120.1Z"/> + <path class="cls-6" d="M755.7,623.4c-55.1,24.7-126.9,33.7-219.1,7,0,0-147.1-46.2-122.5-212.1h453.5s-48.5-63.5,6.9-115.3c0,0,51.9,23.2,51.9,68.1,0,0,43.9-15.9,83.2,12.9,0,0-27.7,75.2-95,61.3,0,0-3.8,11.5-12.3,29.1-55.8,105.3-146.7,149-146.7,149Z"/> + <rect class="cls-6" x="444.2" y="317.4" width="66.6" height="66.6"/> + <rect class="cls-6" x="542.6" y="317.4" width="66.6" height="66.6"/> + <rect class="cls-6" x="542.6" y="218.8" width="66.6" height="66.6"/> + <rect class="cls-6" x="641" y="317.4" width="66.6" height="66.6"/> + <rect class="cls-6" x="739.5" y="317.4" width="66.6" height="66.6"/> + <circle class="cls-5" cx="442.5" cy="234.6" r="37.7"/> + <circle class="cls-2" cx="386.9" cy="290.2" r="17.9"/> + <circle class="cls-4" cx="843.7" cy="238.1" r="24.3"/> + </g> +</svg> \ No newline at end of file diff --git a/content/support-care-landingpage/services-pictograms/documentation.svg b/content/support-care-landingpage/services-pictograms/documentation.svg new file mode 100644 index 00000000..1443bca5 --- /dev/null +++ b/content/support-care-landingpage/services-pictograms/documentation.svg @@ -0,0 +1,87 @@ +<?xml version="1.0" encoding="UTF-8"?> +<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" xmlns:serif="http://www.serif.com/" version="1.1" viewBox="0 0 1366 768"> + <defs> + <style> + .cls-1, .cls-2 { + fill: #5cba9e; + } + + .cls-1, .cls-2, .cls-3, .cls-4, .cls-5, .cls-6 { + stroke-width: 0px; + } + + .cls-1, .cls-7, .cls-4, .cls-5 { + fill-rule: evenodd; + } + + .cls-8, .cls-9 { + stroke: #5cba9e; + } + + .cls-8, .cls-9, .cls-3, .cls-10 { + fill: none; + } + + .cls-8, .cls-9, .cls-7, .cls-10 { + stroke-linecap: round; + stroke-linejoin: round; + stroke-width: 11.9px; + } + + .cls-9 { + stroke-opacity: .5; + } + + .cls-2 { + fill-opacity: .5; + } + + .cls-7, .cls-5, .cls-6 { + fill: #020144; + } + + .cls-7, .cls-10 { + stroke: #020144; + } + + .cls-4 { + fill: #b6e2da; + } + </style> + </defs> + <rect id="_03_High-quality-support-and-improved-documentation" data-name=" 03 High-quality-support-and-improved-documentation" class="cls-3" x="299" width="768" height="768" serif:id="03_High-quality support and improved documentation"/> + <g id="_03_High-quality-support-and-improved-documentation1" data-name=" 03 High-quality-support-and-improved-documentation1" serif:id="03_High-quality support and improved documentation"> + <g id="Layer3"> + <g> + <rect class="cls-10" x="478.1" y="157.3" width="345.6" height="453.3" transform="translate(-77.2 181.5) rotate(-15)"/> + <path class="cls-7" d="M549.7,157.4c6.2-12.1,18.1-22.1,33.4-26.2,15.3-4.1,30.6-1.5,42.1,6l46.8-12.6,13.9,51.7-169.2,45.3-13.9-51.7,46.8-12.6h0Z"/> + <path class="cls-10" d="M500.1,270.6l146.7-39.3"/> + <path class="cls-10" d="M507.3,297.4l73.4-19.7"/> + <path class="cls-10" d="M536.1,404.8l86.4-23.1"/> + <path class="cls-10" d="M514.5,324.3l125.4-33.6"/> + <path class="cls-10" d="M543.3,431.6l58.1-15.6"/> + <path class="cls-10" d="M619.6,411.2l58.1-15.6"/> + <path class="cls-10" d="M521.7,351.1l43.2-11.6"/> + <path class="cls-10" d="M583.2,334.6l135-36.2"/> + <path class="cls-10" d="M550.7,460.3l133-35.6"/> + <path class="cls-10" d="M528.9,378l160.2-42.9"/> + <path class="cls-10" d="M557.2,486.5l25.6-6.9"/> + </g> + <path class="cls-4" d="M952.8,306.4c.4-1.5.2-3-.6-4.3-.8-1.3-2-2.3-3.5-2.7-19.5-5.2-85.6-22.9-105.1-28.2-1.5-.4-3-.2-4.3.6-1.3.8-2.3,2-2.7,3.5-5.2,19.5-22.9,85.6-28.2,105.1-.4,1.5-.2,3,.6,4.3.8,1.3,2,2.3,3.5,2.7,19.5,5.2,85.6,22.9,105.1,28.2,1.5.4,3,.2,4.3-.6,1.3-.8,2.3-2,2.7-3.5,5.2-19.5,22.9-85.6,28.2-105.1Z"/> + <g> + <path class="cls-5" d="M847.7,310.9l-11.9,44.3,33.6,9,2.2-8.2-23.9-6.4,2.9-10.9,21.5,5.8,2-7.6-21.5-5.8,2.5-9.5,23.4,6.3,2.2-8.2-33.1-8.9h0Z"/> + <path class="cls-5" d="M887.9,321.6l-11.9,44.3,9.1,2.4,7.9-29.7h.1s10.5,34.6,10.5,34.6l9.7,2.6,11.9-44.3-9.1-2.4-8,29.7h-.1s-10.5-34.7-10.5-34.7l-9.7-2.6h0Z"/> + </g> + <path class="cls-1" d="M868.4,182.4c0-1.5-.6-3-1.7-4-1.1-1.1-2.5-1.7-4-1.7h-108.9c-1.5,0-3,.6-4,1.7-1.1,1.1-1.7,2.5-1.7,4v108.9c0,1.5.6,3,1.7,4,1.1,1.1,2.5,1.7,4,1.7h108.9c1.5,0,3-.6,4-1.7,1.1-1.1,1.7-2.5,1.7-4v-108.9h0Z"/> + <g> + <path class="cls-6" d="M777.1,251.3v-28.9h7.2c2.5,0,4.6.4,6.3,1.1,1.7.7,3.1,1.7,4.1,3.1,1,1.3,1.8,2.9,2.2,4.8.4,1.9.7,3.9.7,6.3s-.3,4.7-1,6.4c-.6,1.8-1.5,3.2-2.6,4.3-1.1,1.1-2.3,1.9-3.7,2.3s-2.8.7-4.2.7h-9ZM767.1,213.9v45.9h19.8c3.5,0,6.6-.6,9.2-1.8,2.6-1.2,4.8-2.8,6.5-4.8,1.7-2.1,3-4.5,3.9-7.3s1.3-5.9,1.3-9.2-.5-7.1-1.6-10-2.5-5.2-4.4-7.1c-1.9-1.9-4.1-3.3-6.6-4.2-2.5-.9-5.3-1.4-8.3-1.4h-19.8Z"/> + <path class="cls-6" d="M814.6,213.9v45.9h34.8v-8.5h-24.7v-11.2h22.2v-7.8h-22.2v-9.8h24.2v-8.5h-34.3Z"/> + </g> + </g> + <circle class="cls-8" cx="867.4" cy="494.1" r="24.3"/> + <circle class="cls-8" cx="453.9" cy="332.8" r="24.3"/> + <ellipse class="cls-9" cx="918.8" cy="201.3" rx="18.2" ry="18.4"/> + <ellipse class="cls-2" cx="438.4" cy="394.2" rx="12.9" ry="13.1"/> + <ellipse class="cls-2" cx="857.6" cy="611.9" rx="19.8" ry="20"/> + </g> +</svg> \ No newline at end of file diff --git a/content/support-care-landingpage/services-pictograms/long-term-support.svg b/content/support-care-landingpage/services-pictograms/long-term-support.svg new file mode 100755 index 00000000..f1e89fb9 --- /dev/null +++ b/content/support-care-landingpage/services-pictograms/long-term-support.svg @@ -0,0 +1 @@ +<?xml version="1.0" encoding="UTF-8" standalone="no"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"><svg width="100%" height="100%" viewBox="0 0 1081 1080" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:1.5;"><rect id="_02_Stability_Reliability" serif:id="02_Stability_Reliability" x="0.262" y="0" width="1080" height="1080" style="fill:none;"/><g id="_02_Stability_Reliability1" serif:id="02_Stability_Reliability"><g id="Layer6"></g><g id="Layer5"></g><g id="Layer2"></g><g id="java-duke" serif:id="java duke"></g><circle cx="240.228" cy="775.983" r="158.685" style="fill:#b6e2da;"/><circle cx="384.949" cy="673.739" r="66.494" style="fill:#5cba9e;"/><circle cx="824.079" cy="327.832" r="174.902" style="fill:none;stroke:#020144;stroke-width:16.67px;"/><circle cx="824.079" cy="327.832" r="145.609" style="fill:#5cba9e;fill-opacity:0.5;"/><path d="M207.479,377.101l420.166,0" style="fill:none;stroke:#020144;stroke-width:16.67px;"/><path d="M629.695,299.37l-422.216,0l-0,297.476m214.338,165.676l454.761,-0l-0,-245.362" style="fill:none;stroke:#020144;stroke-width:16.67px;"/><path d="M898.791,318.489l-12.452,-0l-0,-12.452l12.452,-0c3.415,-0 6.226,2.81 6.226,6.226c-0,3.415 -2.811,6.226 -6.226,6.226Zm-149.424,-12.452c-3.416,-0 -6.226,2.81 -6.226,6.226c-0,3.415 2.81,6.226 6.226,6.226l12.452,-0l-0,-12.452l-12.452,-0Zm136.972,43.582c-0,2.101 -0.109,4.179 -0.312,6.226l12.764,-0c3.415,-0 6.226,2.81 6.226,6.226c-0,3.415 -2.811,6.226 -6.226,6.226l-15.316,-0c-8.131,25.873 -32.276,43.594 -59.396,43.594c-27.121,-0 -51.265,-17.721 -59.396,-43.594l-15.316,-0c-3.416,-0 -6.226,-2.811 -6.226,-6.226c-0,-3.416 2.81,-6.226 6.226,-6.226l12.763,-0c-0.202,-2.047 -0.311,-4.125 -0.311,-6.226l-0,-6.226l-12.452,-0c-3.416,-0 -6.226,-2.811 -6.226,-6.226c-0,-3.416 2.81,-6.226 6.226,-6.226l12.452,-0l-0,-12.452l124.52,-0l-0,12.452l12.452,-0c3.415,-0 6.226,2.81 6.226,6.226c-0,3.415 -2.811,6.226 -6.226,6.226l-12.452,-0l-0,6.226Zm-56.034,-12.452c-0,-3.416 -2.811,-6.226 -6.226,-6.226c-3.416,-0 -6.226,2.81 -6.226,6.226l-0,49.808c-0,3.415 2.81,6.226 6.226,6.226c3.415,-0 6.226,-2.811 6.226,-6.226l-0,-49.808Zm-51.489,-67.591c-9.441,9.971 -15.311,22.799 -16.686,36.461l123.897,-0c-1.374,-13.662 -7.245,-26.49 -16.685,-36.461l15.176,-15.168c1.167,-1.168 1.824,-2.754 1.824,-4.405c0,-3.417 -2.812,-6.23 -6.229,-6.23c-1.652,0 -3.237,0.657 -4.405,1.825l-15.791,15.798c-21.425,-15.155 -50.252,-15.155 -71.677,0l-15.79,-15.798c-1.168,-1.168 -2.754,-1.825 -4.405,-1.825c-3.418,0 -6.23,2.813 -6.23,6.23c0,1.651 0.657,3.237 1.825,4.405l15.176,15.168Z" style="fill:#020144;fill-rule:nonzero;"/><g><path d="M284.035,713.871l-9.927,7.193c-1.039,0.768 -2.415,0.919 -3.596,0.395l-12.912,-5.322c-1.154,-0.469 -1.986,-1.505 -2.194,-2.734l-2.373,-13.559c-0.284,-1.751 -1.823,-3.044 -3.597,-3.021l-17.479,-0c-1.698,-0.045 -3.207,1.117 -3.597,2.769l-3.345,13.38c-0.262,1.02 -0.959,1.875 -1.906,2.337l-11.869,5.971c-1.162,0.555 -2.537,0.445 -3.596,-0.288l-10.79,-7.661c-1.45,-1.05 -3.475,-0.864 -4.711,0.432l-13.128,13.451c-1.21,1.202 -1.406,3.108 -0.467,4.532l6.725,10.358c0.618,0.95 0.751,2.137 0.36,3.201l-4.676,12.911c-0.394,1.11 -1.309,1.957 -2.445,2.266l-13.847,3.813c-1.61,0.432 -2.719,1.93 -2.661,3.596l-0,17.048c-0.035,1.729 1.182,3.251 2.877,3.596l14.026,2.878c1.144,0.223 2.11,0.988 2.59,2.05l5.107,11.329c0.482,1.065 0.414,2.302 -0.18,3.309l-7.66,13.055c-0.864,1.441 -0.609,3.305 0.611,4.46l12.3,11.725c1.254,1.222 3.228,1.36 4.64,0.323l10.358,-7.516c1.046,-0.757 2.421,-0.894 3.596,-0.36l13.452,6.006c1.117,0.482 1.917,1.498 2.122,2.698l2.373,13.631c0.284,1.751 1.823,3.044 3.597,3.021l17.587,-0c1.797,0.017 3.345,-1.314 3.597,-3.093l2.086,-14.387c0.175,-1.218 0.963,-2.265 2.086,-2.769l12.875,-5.826c1.169,-0.545 2.544,-0.421 3.597,0.323l11.293,7.625c1.47,1.002 3.473,0.771 4.676,-0.539l12.408,-13.308c1.184,-1.243 1.32,-3.169 0.323,-4.567l-7.48,-10.79c-0.745,-1.053 -0.869,-2.428 -0.324,-3.597l5.323,-12.336c0.454,-1.08 1.408,-1.873 2.553,-2.122l13.164,-2.769c1.695,-0.346 2.912,-1.867 2.877,-3.597l0,-16.472c0.035,-1.729 -1.182,-3.251 -2.877,-3.597l-13.379,-2.805c-1.197,-0.248 -2.187,-1.09 -2.626,-2.23l-5.215,-13.127c-0.443,-1.121 -0.294,-2.393 0.396,-3.381l7.732,-11.293c1,-1.446 0.8,-3.423 -0.467,-4.64l-13.344,-11.689c-1.263,-1.211 -3.236,-1.334 -4.639,-0.287Z" style="fill:none;fill-rule:nonzero;stroke:#020144;stroke-width:16.67px;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;"/><circle cx="240.229" cy="775.983" r="35.75" style="fill:none;stroke:#020144;stroke-width:16.67px;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;"/></g><path d="M409.717,694.482c0.534,0.534 0.834,1.258 0.834,2.013c-0,0.754 -0.3,1.479 -0.834,2.012c-0.384,0.381 -9.543,9.366 -24.768,9.366c-8.306,-0 -16.402,-3.236 -23.566,-9.391l-5.71,5.714c-0.534,0.534 -1.258,0.834 -2.013,0.834c-1.56,0 -2.844,-1.284 -2.844,-2.844c-0,-0.001 -0,-17.069 -0,-17.069c-0,-1.56 1.284,-2.844 2.844,-2.844c0,-0 17.068,-0 17.069,-0c1.56,-0 2.844,1.284 2.844,2.844c0,0.755 -0.3,1.479 -0.834,2.013l-7.317,7.317c4.622,3.879 11.289,7.737 19.527,7.737c12.896,-0 20.668,-7.623 20.743,-7.702c0.533,-0.533 1.258,-0.834 2.012,-0.834c0.755,0 1.479,0.301 2.013,0.834Zm7.609,-51.814c-1.061,-0.44 -2.289,-0.197 -3.101,0.615l-5.71,5.713c-7.164,-6.154 -15.26,-9.39 -23.566,-9.39c-15.225,0 -24.384,8.985 -24.768,9.366c-0.534,0.533 -0.834,1.258 -0.834,2.012c0,1.561 1.285,2.846 2.846,2.846c0.755,0 1.479,-0.3 2.013,-0.834c0.075,-0.078 7.847,-7.701 20.743,-7.701c8.238,0 14.905,3.858 19.527,7.737l-7.317,7.317c-0.534,0.534 -0.835,1.258 -0.835,2.013c0,1.56 1.284,2.844 2.845,2.844c0,0 17.069,0 17.069,0c1.56,0 2.844,-1.284 2.844,-2.844l-0,-17.067c-0,-1.148 -0.696,-2.188 -1.756,-2.627Z" style="fill:#020144;fill-rule:nonzero;"/><rect x="274.802" y="432.993" width="255.26" height="97.954" style="fill:#5cba9e;"/><path d="M530.062,567.539l285.742,-0" style="fill:none;stroke:#020144;stroke-width:16.67px;"/><path d="M530.062,608.97l230.598,0" style="fill:none;stroke:#020144;stroke-width:16.67px;"/><path d="M530.062,650.402l200.119,-0" style="fill:none;stroke:#020144;stroke-width:16.67px;"/><path d="M530.062,691.833l115.299,0" style="fill:none;stroke:#020144;stroke-width:16.67px;"/><circle cx="884.396" cy="684.617" r="34.215" style="fill:#5cba9e;"/><circle cx="495.756" cy="862.162" r="53.032" style="fill:none;stroke:#5cba9e;stroke-opacity:0.5;stroke-width:16.67px;"/><circle cx="685.536" cy="211.826" r="66.494" style="fill:#5cba9e;"/><path d="M719.669,201.322c0,0.008 0,0.016 0,0.024c0,12.962 -10.666,23.628 -23.628,23.628c-3.269,0 -6.503,-0.679 -9.497,-1.993l-17.084,19.762c-0.04,0.046 -0.085,0.096 -0.128,0.138c-1.969,1.969 -4.642,3.076 -7.427,3.076c-5.761,0 -10.502,-4.741 -10.502,-10.502c-0,-2.784 1.107,-5.458 3.076,-7.426c0.046,-0.043 0.092,-0.089 0.141,-0.128l19.762,-17.081c-1.306,-2.988 -1.98,-6.213 -1.98,-9.474c0,-12.974 10.677,-23.651 23.651,-23.651c1.937,0 3.866,0.238 5.744,0.708c1.164,0.292 1.987,1.347 1.987,2.547c0,0.66 -0.249,1.297 -0.697,1.782l-12.296,13.34l1.857,8.647l8.644,1.854l13.34,-12.313c0.485,-0.448 1.121,-0.697 1.782,-0.697c1.2,-0 2.255,0.823 2.546,1.987c0.471,1.888 0.71,3.827 0.709,5.772Z" style="fill:#020144;fill-rule:nonzero;"/></g></svg> \ No newline at end of file diff --git a/content/support-care-landingpage/services-pictograms/security.svg b/content/support-care-landingpage/services-pictograms/security.svg new file mode 100755 index 00000000..3d0eb765 --- /dev/null +++ b/content/support-care-landingpage/services-pictograms/security.svg @@ -0,0 +1 @@ +<?xml version="1.0" encoding="UTF-8" standalone="no"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"><svg width="100%" height="100%" viewBox="0 0 4500 4500" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:1.5;"><rect id="_01_Security_Support" serif:id="01_Security_Support" x="0" y="0" width="4500" height="4500" style="fill:none;"/><g id="_01_Security_Support1" serif:id="01_Security_Support"><path d="M1074.47,3576.02l2595.85,-0" style="fill:none;stroke:#020144;stroke-width:69.46px;"/><path d="M1345.79,3164.84l2053.22,-0" style="fill:none;stroke:#020144;stroke-width:69.46px;"/><path d="M1241.13,2849.92l2262.52,-0" style="fill:none;stroke:#020144;stroke-width:69.46px;"/><path d="M1314.07,3301.07l2116.66,-0" style="fill:none;stroke:#020144;stroke-width:69.46px;"/><path d="M3503.65,1604.57l0,1428.65l-2262.52,-0l0,-1428.65l2262.52,-0" style="fill:none;stroke:#020144;stroke-width:69.46px;"/><path d="M3503.65,3033.22l-2262.52,-0l-166.666,408.612l2595.85,0l-166.667,-408.612Z" style="fill:none;stroke:#020144;stroke-width:69.46px;"/><path d="M2725.73,2517.42l-706.667,-0c-5.295,-0 -9.654,-4.358 -9.654,-9.654c0,-1.75 0.475,-3.471 1.379,-4.975l353.271,-621.696c1.667,-3.042 4.871,-4.938 8.338,-4.938c3.466,0 6.671,1.896 8.337,4.938l353.271,621.696c0.904,1.504 1.383,3.225 1.383,4.975c0,5.296 -4.358,9.654 -9.658,9.654Z" style="fill:none;fill-rule:nonzero;stroke:#020144;stroke-width:69.46px;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;"/><path d="M2372.39,2412.98l-0,9.8" style="fill:none;fill-rule:nonzero;stroke:#020144;stroke-width:69.46px;stroke-linejoin:miter;stroke-miterlimit:4;"/><path d="M2372.39,2080.18l-0,254.971" style="fill:none;fill-rule:nonzero;stroke:#020144;stroke-width:69.46px;stroke-linejoin:miter;stroke-miterlimit:4;"/><rect x="1434.63" y="1784.65" width="633.446" height="408.142" style="fill:#5cba9e;"/><rect x="2861.47" y="1918.52" width="438.308" height="682.41" style="fill:#5cba9e;"/><rect x="1434.63" y="2396.86" width="438.308" height="224.379" style="fill:#5cba9e;"/><circle cx="1259.87" cy="1144.94" r="220.967" style="fill:none;stroke:#5cba9e;stroke-opacity:0.5;stroke-width:69.46px;"/><circle cx="934.29" cy="1470.52" r="104.608" style="fill:#5cba9e;fill-opacity:0.5;"/></g></svg> \ No newline at end of file diff --git a/content/support-care-landingpage/services-pictograms/workshops.svg b/content/support-care-landingpage/services-pictograms/workshops.svg new file mode 100644 index 00000000..1d48cc04 --- /dev/null +++ b/content/support-care-landingpage/services-pictograms/workshops.svg @@ -0,0 +1 @@ +<?xml version="1.0" encoding="UTF-8" standalone="no"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"><svg width="100%" height="100%" viewBox="0 0 4505 4500" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:1.5;"><rect id="_02_Knowledge-transfer---training" serif:id="02_Knowledge transfer & training" x="1.092" y="0" width="4500" height="4500" style="fill:none;"/><g id="_02_Knowledge-transfer---training1" serif:id="02_Knowledge transfer & training"><g id="Layer6"><path d="M1159.42,1488.81l-0,352.05l491.608,0" style="fill:none;stroke:#5cba9e;stroke-opacity:0.5;stroke-width:69.46px;"/><path d="M974.329,2761.7l0,-285.646l548.038,0" style="fill:none;stroke:#5cba9e;stroke-opacity:0.5;stroke-width:69.46px;"/><path d="M2295.16,3123.8l-0,425.792l789.454,-0" style="fill:none;stroke:#5cba9e;stroke-opacity:0.5;stroke-width:69.46px;stroke-linecap:round;"/><path d="M1897.23,3349.68l363.329,0" style="fill:none;stroke:#5cba9e;stroke-opacity:0.5;stroke-width:69.46px;"/><path d="M3606.05,2404.07l-521.437,-0" style="fill:none;stroke:#5cba9e;stroke-opacity:0.5;stroke-width:69.46px;stroke-linecap:round;"/><path d="M2295.16,1287.08l-0,257.809" style="fill:none;stroke:#5cba9e;stroke-opacity:0.5;stroke-width:69.46px;stroke-linecap:round;"/><path d="M3067.22,2125.98l337.708,0l0,-366.637" style="fill:none;stroke:#5cba9e;stroke-opacity:0.5;stroke-width:69.46px;stroke-linecap:round;"/></g><g id="Layer5"><circle cx="2295.16" cy="2334.35" r="789.458" style="fill:none;stroke:#020144;stroke-width:69.46px;stroke-linecap:round;"/><circle cx="1159.42" cy="997.2" r="491.608" style="fill:#5cba9e;"/><circle cx="2303.01" cy="2334.35" r="465.65" style="fill:#5cba9e;fill-opacity:0.5;"/><circle cx="974.329" cy="3189.07" r="427.367" style="fill:#5cba9e;"/><circle cx="3267.75" cy="3559.11" r="183.135" style="fill:none;stroke:#5cba9e;stroke-width:66.67px;stroke-miterlimit:2;"/><circle cx="3748.62" cy="2404.07" r="142.563" style="fill:none;stroke:#5cba9e;stroke-width:69.46px;stroke-linecap:round;"/><circle cx="1754.66" cy="3349.68" r="142.563" style="fill:none;stroke:#5cba9e;stroke-width:69.46px;stroke-linecap:round;"/><circle cx="2295.16" cy="1144.52" r="142.563" style="fill:none;stroke:#5cba9e;stroke-width:69.46px;stroke-linecap:round;"/><circle cx="807.083" cy="1910.2" r="142.563" style="fill:#5cba9e;"/></g><g id="Layer2"><circle cx="3404.32" cy="1359.08" r="77.263" style="fill:none;stroke:#020144;stroke-width:52.08px;stroke-linecap:round;stroke-miterlimit:4;"/><path d="M3560.65,1650.79c-0.075,-85.734 -70.6,-156.255 -156.329,-156.33c-85.763,0 -156.334,70.571 -156.334,156.33l312.663,-0Z" style="fill:none;fill-rule:nonzero;stroke:#020144;stroke-width:52.08px;stroke-linecap:round;stroke-miterlimit:4;"/><circle cx="3634.16" cy="1359.08" r="77.263" style="fill:none;stroke:#020144;stroke-width:52.08px;stroke-linecap:round;stroke-miterlimit:4;"/><path d="M3612.11,1650.79l178.388,-0c-0,-85.759 -70.571,-156.33 -156.334,-156.33c-25.587,-0.012 -50.791,6.275 -73.379,18.309" style="fill:none;fill-rule:nonzero;stroke:#020144;stroke-width:52.08px;stroke-linecap:round;stroke-miterlimit:4;"/><circle cx="3177.52" cy="1359.08" r="77.263" style="fill:none;stroke:#020144;stroke-width:52.08px;stroke-linecap:round;stroke-miterlimit:4;"/><path d="M3199.58,1650.79l-178.387,-0c-0,-85.759 70.57,-156.33 156.329,-156.33c25.591,-0.012 50.796,6.275 73.383,18.309" style="fill:none;fill-rule:nonzero;stroke:#020144;stroke-width:52.08px;stroke-linecap:round;stroke-miterlimit:4;"/></g><g id="java-duke" serif:id="java duke"><path d="M972.729,2942.7c-12.691,23.729 -25.396,47.479 -36.946,71.787c-35.866,75.5 -79.57,165.484 -106.154,248.13c-16.387,50.958 -26.975,86.483 -22.637,138.866c2.008,24.267 25.358,33.925 46.2,33.963c46.329,0.087 72.85,-47.888 121.562,-47.888c48.709,0 75.229,47.975 121.559,47.888c20.845,-0.038 44.191,-9.696 46.2,-33.963c4.337,-52.383 -6.25,-87.908 -22.638,-138.866c-26.579,-82.646 -70.287,-172.63 -106.154,-248.13c-11.55,-24.308 -28.296,-48.058 -40.992,-71.787Z" style="fill:none;fill-rule:nonzero;stroke:#020144;stroke-width:34.71px;stroke-linecap:square;stroke-miterlimit:10;"/><path d="M1081.98,3162.78l51.613,26.288l-20.221,56.617l-31.392,-82.905Z" style="fill:#020144;fill-rule:nonzero;"/><path d="M866.679,3162.78l-51.612,26.288l20.221,56.617l31.391,-82.905Z" style="fill:#020144;fill-rule:nonzero;"/><ellipse cx="973.888" cy="3169.97" rx="58.546" ry="45.608" style="fill:#5cba9e;stroke:#020144;stroke-width:34.71px;stroke-linecap:round;stroke-miterlimit:10;"/><path d="M1072.58,3145.02l-44.133,-0c-0,-0 -25.179,-23.079 -54.558,-20.659c-29.38,2.421 -43.309,12.584 -50.592,20.659c-7.279,8.079 -48.104,-0 -48.104,-0l98.696,-202.325l98.691,202.325Z" style="fill:#020144;fill-rule:nonzero;"/><path d="M1121.46,3209.29c-0,-0 50.491,18.208 52.575,36.396c2.079,18.187 -24.267,44.487 -24.267,44.487" style="fill:none;fill-rule:nonzero;stroke:#020144;stroke-width:34.71px;stroke-linecap:round;stroke-miterlimit:10;"/><path d="M827.2,3209.29c0,-0 -50.496,18.208 -52.575,36.396c-2.083,18.187 24.263,44.487 24.263,44.487" style="fill:none;fill-rule:nonzero;stroke:#020144;stroke-width:34.71px;stroke-linecap:round;stroke-miterlimit:10;"/><path d="M1157.86,3278.04c0,-0 24.355,17.254 12.134,40.441c-12.221,23.188 8.916,6.392 8.087,20.221c-0.825,13.829 -28.183,24.729 -34.591,12.134c-6.409,-12.6 -22.026,-72.796 -22.026,-72.796c0,-0 23.434,-12.171 36.396,-0Z" style="fill:#020144;fill-rule:nonzero;"/><path d="M790.8,3278.04c0,-0 -24.35,17.254 -12.133,40.441c12.221,23.188 -8.917,6.392 -8.088,20.221c0.829,13.829 28.183,24.729 34.592,12.134c6.408,-12.6 22.029,-72.796 22.029,-72.796c0,-0 -23.438,-12.171 -36.4,-0Z" style="fill:#020144;fill-rule:nonzero;"/></g><path d="M2737.8,2166.03l-429.192,-228.9c-8.4,-4.475 -18.495,-4.475 -26.896,0l-429.191,228.9c-9.317,4.967 -15.158,14.696 -15.158,25.25c-0,10.558 5.841,20.288 15.158,25.254l99.287,52.967l0,173.179c-0.033,14.05 5.146,27.629 14.521,38.092c46.854,52.183 151.825,139.704 328.834,139.704c58.687,0.483 116.941,-10.146 171.675,-31.333l-0,117.17c-0,15.696 12.916,28.613 28.612,28.613c15.696,0 28.612,-12.917 28.612,-28.613l0,-144.816c37.313,-21.538 71.03,-48.775 99.934,-80.725c9.375,-10.463 14.55,-24.042 14.521,-38.092l-0,-173.179l99.283,-52.967c9.317,-4.966 15.158,-14.696 15.158,-25.254c0,-10.554 -5.841,-20.283 -15.158,-25.25Zm-442.638,397.221c-154.762,-0 -245.787,-75.613 -286.129,-120.571l0,-142.671l272.679,145.425c8.4,4.475 18.496,4.475 26.896,0l158.229,-84.371l0,165.742c-45.066,21.029 -101.862,36.446 -171.675,36.446Zm286.125,-120.713c-17.15,19.034 -36.341,36.125 -57.225,50.967l0,-162.987l57.225,-30.509l0,142.529Zm-71.529,-169.208l-0.787,-0.467l-200.292,-106.833c-4.029,-2.058 -8.487,-3.129 -13.012,-3.129c-15.7,-0 -28.613,12.917 -28.613,28.612c0,10.384 5.65,19.984 14.729,25.021l167.171,89.2l-153.792,82.013l-368.391,-196.467l368.391,-196.462l368.388,196.462l-153.792,82.05Z" style="fill:#020144;fill-rule:nonzero;"/><g id="Java"><path d="M1349.7,1247.41l62.554,-0c11.438,-0 20.85,-9.413 20.85,-20.851l0,-333.62l-145.958,-145.959l-250.217,0c-11.437,0 -20.85,9.413 -20.85,20.855l0,229.362" style="fill:none;fill-rule:nonzero;stroke:#020144;stroke-width:34.71px;stroke-linecap:round;stroke-miterlimit:4;"/><path d="M1287.15,746.983l-0,145.959l145.958,-0" style="fill:none;fill-rule:nonzero;stroke:#020144;stroke-width:34.71px;stroke-linecap:round;stroke-miterlimit:4;"/><path d="M927.654,1196.78c-8.879,0 -16.896,-1.587 -24.041,-4.754c-7.15,-3.171 -13.105,-7.804 -17.871,-13.904l20.633,-26.909c3.029,4.067 6.008,7.146 8.933,9.238c2.925,2.091 5.959,3.137 9.1,3.137c8.23,0 12.346,-5.2 12.346,-15.604l0,-47.721l-38.666,0l-0,-31.933l76.52,0l0,77.142c0,17.22 -4.008,30.079 -12.025,38.57c-8.012,8.492 -19.658,12.738 -34.929,12.738Z" style="fill:#020144;fill-rule:nonzero;"/><path d="M977.367,1193.9l49.716,-125.579l37.688,0l49.712,125.579l-39.637,0l-36.717,-105.487l14.946,-0l-36.717,105.487l-38.991,0Zm29.571,-21.887l9.745,-30.496l52.313,-0l9.746,30.496l-71.805,-0Z" style="fill:#020144;fill-rule:nonzero;"/><path d="M1149.9,1193.9l-48.088,-125.579l41.267,0l39.15,106.025l-24.529,0l40.287,-106.025l37.692,0l-48.087,125.579l-37.692,0Z" style="fill:#020144;fill-rule:nonzero;"/><path d="M1223.01,1193.9l49.713,-125.579l37.691,0l49.713,125.579l-39.642,0l-36.716,-105.487l14.945,-0l-36.712,105.487l-38.992,0Zm29.567,-21.887l9.75,-30.496l52.308,-0l9.75,30.496l-71.808,-0Z" style="fill:#020144;fill-rule:nonzero;"/></g></g></svg> \ No newline at end of file diff --git a/content/support-care-landingpage/support-and-care-logo.svg b/content/support-care-landingpage/support-and-care-logo.svg new file mode 100644 index 00000000..831ad3cc --- /dev/null +++ b/content/support-care-landingpage/support-and-care-logo.svg @@ -0,0 +1,62 @@ +<?xml version="1.0" encoding="UTF-8"?> +<svg id="Layer_1" xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 689.94 149.31"> + <!-- Generator: Adobe Illustrator 29.0.0, SVG Export Plug-In . SVG Version: 2.1.0 Build 186) --> + <defs> + <style> + .st0 { + fill: #5dba9f; + } + + .st1 { + fill: #9cd5fd; + } + + .st2 { + fill: #020144; + } + </style> + </defs> + <g> + <g> + <g> + <path class="st1" d="M8.1,79.54h25.3c-.62-2.75-.96-5.61-.96-8.55,0-2.62.26-5.18.76-7.65h-16.41c3.93-26.63,26.93-47.14,54.64-47.14,21.27,0,39.76,12.09,48.99,29.75.38.73,1.12,1.19,1.95,1.19h13.04c1.55,0,2.63-1.58,2.03-3.02C126.7,18.25,101.16,0,71.44,0,32.05,0,0,32.05,0,71.44c0,.95.02,1.89.06,2.82.12,2.94,2.52,5.28,5.47,5.28h2.58Z"/> + <path class="st1" d="M142.82,68.61c-.12-2.94-2.52-5.27-5.47-5.27h-2.68s-21.81,0-21.81,0h0s-.7,0-.7,0h-1.34c-.19,0-.38.05-.55.15l-12.12,7c-.74.43-.74,1.49,0,1.91l12.11,6.99c.17.1.36.15.55.15h5.15s10.11,0,10.11,0c-3.93,26.63-26.93,47.14-54.64,47.14-21.27,0-39.76-12.09-48.99-29.75-.38-.73-1.12-1.19-1.95-1.19H7.46c-1.55,0-2.63,1.58-2.03,3.02,10.75,25.88,36.29,44.12,66.01,44.12,39.39,0,71.44-32.05,71.44-71.44,0-.95-.02-1.89-.06-2.82Z"/> + </g> + <path class="st0" d="M71.44,88.95c-10.04,0-18.11-8.45-17.47-18.63.53-8.44,7.2-15.43,15.62-16.29s15.05,3.75,17.95,10.53c.8,1.86,3.06,2.59,4.81,1.58l17.38-10.03c1.57-.91,2.14-2.88,1.33-4.5-7.46-14.88-23.05-24.99-40.96-24.46-23.54.69-42.6,20.05-42.97,43.59-.39,24.8,19.6,45.02,44.31,45.02,17.34,0,32.34-9.96,39.62-24.47.81-1.62.24-3.6-1.33-4.5l-17.38-10.04c-1.76-1.02-4.02-.27-4.82,1.6-2.68,6.23-8.86,10.6-16.08,10.6Z"/> + </g> + <g> + <path class="st2" d="M193.32,55.74c-1.87-3.11-7-6.07-12.92-6.07-7.63,0-11.28,3.19-11.28,7.24,0,4.75,5.6,6.07,12.14,6.85,11.36,1.4,21.94,4.36,21.94,17.35,0,12.14-10.74,17.35-22.88,17.35-11.13,0-19.69-3.42-23.73-13.38l8.56-4.43c2.41,5.99,8.71,8.64,15.33,8.64s12.53-2.26,12.53-8.17c0-5.14-5.37-7.24-12.61-8.01-11.13-1.32-21.4-4.28-21.4-16.5,0-11.2,11.05-15.8,21.09-15.87,8.48,0,17.27,2.41,21.4,10.82l-8.17,4.2Z"/> + <path class="st2" d="M218.59,58.69v20.07c0,5.84,3.19,10.27,9.26,10.27s9.8-4.9,9.8-10.74v-19.61h9.41v38.44h-8.48l-.62-5.21c-3.97,3.89-7.63,5.76-12.99,5.76-9.18,0-15.87-6.92-15.87-18.83v-20.15h9.49Z"/> + <path class="st2" d="M254.19,113.08v-54.39h8.87l.62,5.29c2.96-4.28,8.09-6.15,12.45-6.15,11.83,0,19.69,8.79,19.69,20.08s-7.08,20.07-19.37,20.07c-4.05,0-10.04-1.24-12.76-5.45v20.54h-9.49ZM286.32,77.91c0-5.99-4.05-10.89-10.89-10.89s-10.89,4.9-10.89,10.89,4.43,10.89,10.89,10.89,10.89-4.9,10.89-10.89Z"/> + <path class="st2" d="M301.53,113.08v-54.39h8.87l.62,5.29c2.96-4.28,8.09-6.15,12.45-6.15,11.83,0,19.69,8.79,19.69,20.08s-7.08,20.07-19.37,20.07c-4.05,0-10.04-1.24-12.76-5.45v20.54h-9.49ZM333.67,77.91c0-5.99-4.05-10.89-10.89-10.89s-10.89,4.9-10.89,10.89,4.43,10.89,10.89,10.89,10.89-4.9,10.89-10.89Z"/> + <path class="st2" d="M388.29,77.91c0,11.05-7.55,20-20,20s-19.92-8.95-19.92-20,7.63-20,19.84-20,20.07,9.03,20.07,20ZM357.87,77.91c0,5.84,3.5,11.28,10.43,11.28s10.43-5.45,10.43-11.28-4.05-11.36-10.43-11.36c-6.85,0-10.43,5.6-10.43,11.36Z"/> + <path class="st2" d="M402.33,58.69l.7,4.44c2.96-4.75,6.93-5.45,10.82-5.45s7.78,1.56,9.88,3.66l-4.28,8.25c-1.95-1.63-3.73-2.49-6.85-2.49-4.98,0-9.57,2.65-9.57,9.73v20.23h-9.49v-38.36h8.79Z"/> + <path class="st2" d="M444.39,47.88v10.89h10.58v8.17h-10.66v16.57c0,3.66,2.02,5.45,4.98,5.45,1.48,0,3.19-.47,4.59-1.17l2.65,8.09c-2.72,1.09-4.98,1.56-7.86,1.63-8.33.31-13.77-4.43-13.77-14.01v-16.57h-7.16v-8.17h7.16v-4.89l9.49-6.01Z"/> + <path class="st2" d="M566.78,90.21c-5.6,5.52-12.84,8.09-20.7,8.09-20.23,0-28.79-13.93-28.87-28.09-.08-14.24,9.18-28.71,28.87-28.71,7.39,0,14.39,2.8,20,8.33l-6.85,6.61c-3.58-3.5-8.4-5.14-13.15-5.14-13.15,0-18.83,9.8-18.75,18.91.08,9.03,5.29,18.44,18.75,18.44,4.75,0,10.12-1.95,13.69-5.52l7,7.08Z"/> + <path class="st2" d="M601.27,58.69h9.1v38.36h-8.95l-.47-5.6c-2.18,4.51-8.17,6.69-12.45,6.77-11.36.08-19.76-6.93-19.76-20.39s8.79-20.15,20-20.08c5.14,0,10.04,2.41,12.22,6.22l.31-5.29ZM578.24,77.84c0,7.31,5.06,11.67,11.36,11.67,14.94,0,14.94-23.27,0-23.27-6.3,0-11.36,4.28-11.36,11.59Z"/> + <path class="st2" d="M625.25,58.69l.7,4.44c2.96-4.75,6.93-5.45,10.82-5.45s7.78,1.56,9.88,3.66l-4.28,8.25c-1.95-1.63-3.73-2.49-6.85-2.49-4.98,0-9.57,2.65-9.57,9.73v20.23h-9.49v-38.36h8.79Z"/> + <path class="st2" d="M658.32,81.26c.62,4.75,4.75,8.17,11.44,8.17,3.5,0,8.09-1.32,10.27-3.58l6.07,5.99c-4.05,4.2-10.66,6.22-16.5,6.22-13.23,0-21.09-8.17-21.09-20.46s7.94-20.07,20.39-20.07,20.85,7.94,19.37,23.73h-29.96ZM679.17,73.4c-.62-4.98-4.51-7.47-9.96-7.47-5.14,0-9.34,2.49-10.74,7.47h20.7Z"/> + </g> + </g> + <g> + <path class="st2" d="M398.34,126.27c.79-1.06,1.71-1.9,2.76-2.51,1.05-.61,2.27-.92,3.67-.92,1.09,0,2.06.2,2.92.6.86.4,1.59.97,2.19,1.72s1.06,1.67,1.37,2.77c.31,1.1.47,2.34.47,3.73,0,1.46-.18,2.8-.53,4-.35,1.2-.86,2.23-1.53,3.09-.67.85-1.49,1.51-2.46,1.98-.97.47-2.08.7-3.32.7s-2.38-.25-3.28-.74-1.68-1.22-2.33-2.19l-.13,2.23c-.04.3-.2.45-.49.45h-1.05v-26.41h1.74v11.49ZM398.34,137.25c.7,1.04,1.47,1.77,2.31,2.19.84.42,1.79.63,2.84.63s2.02-.19,2.82-.58c.8-.39,1.48-.94,2.02-1.66.54-.72.94-1.59,1.21-2.62.27-1.03.4-2.18.4-3.47,0-2.49-.5-4.37-1.49-5.63-.99-1.26-2.38-1.89-4.18-1.89-1.28,0-2.4.31-3.36.93-.96.62-1.82,1.48-2.58,2.58v9.53Z"/> + <path class="st2" d="M430.78,123.13l-10.38,23.87c-.07.17-.17.31-.28.42-.12.11-.28.16-.5.16h-1.23l3.18-7.06-7.64-17.39h1.43c.18,0,.33.05.44.14.11.09.18.19.22.3l6.08,14.05c.07.18.14.37.19.55.05.19.11.38.15.57.06-.19.12-.38.19-.57.07-.19.14-.37.21-.55l6.01-14.05c.06-.13.15-.24.25-.32.11-.08.23-.12.36-.12h1.33Z"/> + <g> + <path class="st2" d="M465.12,129.08c-.07,6.63-4.14,13.26-13.15,13.26s-13.19-6.49-13.19-13.23,4.32-13.52,13.19-13.52,13.23,6.78,13.15,13.48ZM443.54,129.19c.11,4.21,2.38,8.72,8.43,8.72s8.32-4.54,8.39-8.76c.07-4.32-2.35-9.16-8.39-9.16s-8.54,4.87-8.43,9.2Z"/> + <path class="st2" d="M468.34,149.31v-25.61h4.18l.29,2.49c1.39-2.02,3.81-2.89,5.86-2.89,5.57,0,9.27,4.14,9.27,9.45s-3.33,9.45-9.12,9.45c-1.91,0-4.73-.59-6.01-2.57v9.67h-4.47ZM483.47,132.75c0-2.82-1.91-5.13-5.13-5.13s-5.13,2.31-5.13,5.13,2.09,5.13,5.13,5.13,5.13-2.31,5.13-5.13Z"/> + <path class="st2" d="M495.05,134.32c.29,2.24,2.24,3.85,5.39,3.85,1.65,0,3.81-.62,4.84-1.69l2.86,2.82c-1.91,1.98-5.02,2.93-7.77,2.93-6.23,0-9.93-3.85-9.93-9.64s3.74-9.45,9.6-9.45,9.82,3.74,9.12,11.18h-14.11ZM504.87,130.62c-.29-2.35-2.13-3.52-4.69-3.52-2.42,0-4.4,1.17-5.06,3.52h9.75Z"/> + <path class="st2" d="M525.9,141.76v-9.45c0-2.75-1.5-4.84-4.36-4.84s-4.62,2.31-4.62,5.06v9.23h-4.43v-18.1h3.99l.29,2.46c1.83-1.8,3.66-2.71,5.94-2.71,4.25,0,7.66,3.19,7.66,8.87v9.49h-4.47Z"/> + <rect class="st2" x="535.1" y="116.11" width="17.7" height="1.87"/> + <polygon class="st2" points="535.1 139.83 535.1 141.76 553.23 141.76 553.23 139.85 535.1 139.83"/> + <polygon class="st2" points="552.06 129.74 552.06 127.95 535.1 127.93 535.1 129.74 552.06 129.74"/> + <path class="st2" d="M559.06,116.11v25.65h-1.8v-25.65h1.8Z"/> + <path class="st2" d="M563.05,132.71c0-5.42,4.1-9.34,9.2-9.34s9.64,3.11,8.94,10.19h-16.31c.37,4.25,3.63,6.71,7.37,6.71,2.38,0,5.17-.95,6.52-2.75l1.28,1.03c-1.76,2.31-4.91,3.48-7.8,3.48-5.09,0-9.2-3.55-9.2-9.31ZM579.58,131.98c-.04-4.47-2.97-6.96-7.33-6.96-3.74,0-6.96,2.53-7.37,6.96h14.69Z"/> + <path class="st2" d="M612.3,141.76v-10.85c0-3.48-2.35-5.94-5.79-5.94s-5.83,2.57-5.83,6.05v10.74h-1.8v-10.74c0-3.48-2.38-6.01-5.83-6.01s-5.79,2.53-5.79,6.01v10.74h-1.8v-18.1h1.69l.04,3c1.25-2.38,3.55-3.37,5.9-3.37,2.75,0,5.64,1.25,6.71,4.47,1.1-2.97,3.92-4.47,6.71-4.47,4.43,0,7.58,3.11,7.58,7.62v10.85h-1.8Z"/> + <path class="st2" d="M618.12,132.71c0-5.42,4.1-9.34,9.2-9.34s9.64,3.11,8.94,10.19h-16.31c.37,4.25,3.63,6.71,7.37,6.71,2.38,0,5.17-.95,6.52-2.75l1.28,1.03c-1.76,2.31-4.91,3.48-7.8,3.48-5.09,0-9.2-3.55-9.2-9.31ZM634.64,131.98c-.04-4.47-2.97-6.96-7.33-6.96-3.74,0-6.96,2.53-7.37,6.96h14.69Z"/> + <path class="st2" d="M642.66,123.66v3.22c1.39-2.49,3.92-3.52,6.45-3.55,4.84,0,8.17,2.97,8.17,7.99v10.44h-1.8v-10.41c0-4.1-2.53-6.3-6.45-6.27-3.74.04-6.34,2.86-6.34,6.6v10.08h-1.8v-18.1h1.76Z"/> + <path class="st2" d="M665.34,118.2v5.46h6.16v1.5h-6.16v11.03c0,2.45.51,4.18,3.33,4.18.88,0,1.87-.29,2.78-.73l.62,1.47c-1.14.55-2.27.92-3.41.92-3.85,0-5.09-2.27-5.09-5.83v-11.03h-3.85v-1.5h3.85v-5.28l1.76-.18Z"/> + <path class="st2" d="M688.06,126.96c-1.83-1.61-3.63-1.91-5.64-1.91-2.82-.04-5.53,1.03-5.46,3.33.07,2.42,3.22,2.89,5.5,3.3,3.22.55,7.66,1.1,7.48,5.31-.11,3.99-4.25,5.06-7.44,5.06s-6.34-1.21-7.92-3.63l1.32-1.17c1.5,2.16,4.21,3.08,6.63,3.08,2.2,0,5.53-.59,5.64-3.44.07-2.6-2.93-3.11-5.9-3.59-3.52-.59-7-1.25-7.04-4.87-.04-3.55,3.52-5.09,7.18-5.06,2.64,0,4.95.73,6.74,2.42l-1.1,1.17Z"/> + </g> + </g> + <path class="st2" d="M517.26,97.66h-3.57c-.48,0-.88-.05-1.18-.16-.31-.11-.66-.35-1.06-.72l-8.23-8.07c-1.18,1.39-2.49,2.67-3.93,3.83-1.44,1.16-3.01,2.17-4.69,3.03-1.69.86-3.49,1.52-5.42,2.01s-3.95.72-6.06.72-3.99-.33-5.94-1c-1.95-.67-3.7-1.65-5.24-2.95-1.54-1.3-2.78-2.89-3.73-4.77-.95-1.89-1.42-4.03-1.42-6.44,0-1.93.35-3.77,1.04-5.52.7-1.75,1.64-3.36,2.85-4.81,1.2-1.46,2.63-2.76,4.29-3.91,1.66-1.15,3.45-2.09,5.38-2.81-1.93-2.17-3.36-4.25-4.29-6.26-.94-2.01-1.4-4.16-1.4-6.46,0-1.87.34-3.6,1.02-5.2.68-1.59,1.65-2.98,2.91-4.15,1.26-1.18,2.76-2.1,4.51-2.77,1.75-.67,3.71-1,5.88-1,1.79,0,3.49.31,5.1.92,1.6.62,3,1.44,4.19,2.49,1.19,1.04,2.14,2.25,2.85,3.63.71,1.38,1.09,2.82,1.14,4.31l-2.17.44c-.27.05-.52,0-.74-.14-.23-.15-.41-.41-.54-.78-.13-.72-.42-1.54-.86-2.45-.44-.91-1.06-1.77-1.87-2.57-.8-.8-1.79-1.48-2.97-2.03-1.18-.55-2.55-.82-4.13-.82s-3.06.25-4.37.74c-1.31.5-2.43,1.19-3.37,2.09-.94.9-1.67,1.96-2.19,3.19-.52,1.23-.78,2.58-.78,4.05,0,2.19.56,4.29,1.69,6.3,1.12,2.01,2.86,4.16,5.22,6.46l17.94,17.62c1.2-1.93,2.15-3.93,2.85-6,.7-2.07,1.15-4.09,1.36-6.04.05-.35.16-.62.32-.82.16-.2.4-.3.72-.3h2.21c-.05,2.51-.52,5.1-1.4,7.76-.88,2.66-2.15,5.21-3.81,7.64l11.92,11.72ZM482.19,68.04c-1.77.72-3.36,1.6-4.8,2.65-1.43,1.04-2.64,2.21-3.63,3.49-.99,1.28-1.75,2.66-2.29,4.13-.54,1.47-.8,3-.8,4.57,0,2.06.39,3.85,1.18,5.38.79,1.52,1.81,2.8,3.07,3.83,1.26,1.03,2.65,1.8,4.19,2.31,1.54.51,3.06.76,4.55.76,1.9,0,3.68-.21,5.36-.64,1.67-.43,3.23-1.02,4.67-1.79,1.44-.76,2.78-1.67,4.01-2.73,1.23-1.06,2.34-2.2,3.33-3.43l-18.42-18.1-.44-.44Z"/> +</svg> \ No newline at end of file