skill-library-mcp 1.0.0

package/skills/calendly-automation/SKILL.md

@@ -0,0 +1,211 @@
+---
+name: calendly-automation
+description: "Automate Calendly scheduling, event management, invitee tracking, availability checks, and organization administration via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Calendly Automation via Rube MCP
+
+Automate Calendly operations including event listing, invitee management, scheduling link creation, availability queries, and organization administration through Composio's Calendly toolkit.
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Calendly connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `calendly`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+- Many operations require the user's Calendly URI, obtained via `CALENDLY_GET_CURRENT_USER`
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `calendly`
+3. If connection is not ACTIVE, follow the returned auth link to complete Calendly OAuth
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Core Workflows
+
+### 1. List and View Scheduled Events
+
+**When to use**: User wants to see their upcoming, past, or filtered Calendly events
+
+**Tool sequence**:
+1. `CALENDLY_GET_CURRENT_USER` - Get authenticated user URI and organization URI [Prerequisite]
+2. `CALENDLY_LIST_EVENTS` - List events scoped by user, organization, or group [Required]
+3. `CALENDLY_GET_EVENT` - Get detailed info for a specific event by UUID [Optional]
+
+**Key parameters**:
+- `user`: Full Calendly API URI (e.g., `https://api.calendly.com/users/{uuid}`) - NOT `"me"`
+- `organization`: Full organization URI for org-scoped queries
+- `status`: `"active"` or `"canceled"`
+- `min_start_time` / `max_start_time`: UTC timestamps (e.g., `2024-01-01T00:00:00.000000Z`)
+- `invitee_email`: Filter events by invitee email (filter only, not a scope)
+- `sort`: `"start_time:asc"` or `"start_time:desc"`
+- `count`: Results per page (default 20)
+- `page_token`: Pagination token from previous response
+
+**Pitfalls**:
+- Exactly ONE of `user`, `organization`, or `group` must be provided - omitting or combining scopes fails
+- The `user` parameter requires the full API URI, not `"me"` - use `CALENDLY_GET_CURRENT_USER` first
+- `invitee_email` is a filter, not a scope; you still need one of user/organization/group
+- Pagination uses `count` + `page_token`; loop until `page_token` is absent for complete results
+- Admin rights may be needed for organization or group scope queries
+
+### 2. Manage Event Invitees
+
+**When to use**: User wants to see who is booked for events or get invitee details
+
+**Tool sequence**:
+1. `CALENDLY_LIST_EVENTS` - Find the target event(s) [Prerequisite]
+2. `CALENDLY_LIST_EVENT_INVITEES` - List all invitees for a specific event [Required]
+3. `CALENDLY_GET_EVENT_INVITEE` - Get detailed info for a single invitee [Optional]
+
+**Key parameters**:
+- `uuid`: Event UUID (for `LIST_EVENT_INVITEES`)
+- `event_uuid` + `invitee_uuid`: Both required for `GET_EVENT_INVITEE`
+- `email`: Filter invitees by email address
+- `status`: `"active"` or `"canceled"`
+- `sort`: `"created_at:asc"` or `"created_at:desc"`
+- `count`: Results per page (default 20)
+
+**Pitfalls**:
+- The `uuid` parameter for `CALENDLY_LIST_EVENT_INVITEES` is the event UUID, not the invitee UUID
+- Paginate using `page_token` until absent for complete invitee lists
+- Canceled invitees are excluded by default; use `status: "canceled"` to see them
+
+### 3. Create Scheduling Links and Check Availability
+
+**When to use**: User wants to generate a booking link or check available time slots
+
+**Tool sequence**:
+1. `CALENDLY_GET_CURRENT_USER` - Get user URI [Prerequisite]
+2. `CALENDLY_LIST_USER_S_EVENT_TYPES` - List available event types [Required]
+3. `CALENDLY_LIST_EVENT_TYPE_AVAILABLE_TIMES` - Check available slots for an event type [Optional]
+4. `CALENDLY_CREATE_SCHEDULING_LINK` - Generate a single-use scheduling link [Required]
+5. `CALENDLY_LIST_USER_AVAILABILITY_SCHEDULES` - View user's availability schedules [Optional]
+
+**Key parameters**:
+- `owner`: Event type URI (e.g., `https://api.calendly.com/event_types/{uuid}`)
+- `owner_type`: `"EventType"` (default)
+- `max_event_count`: Must be exactly `1` for single-use links
+- `start_time` / `end_time`: UTC timestamps for availability queries (max 7-day range)
+- `active`: Boolean to filter active/inactive event types
+- `user`: User URI for event type listing
+
+**Pitfalls**:
+- `CALENDLY_CREATE_SCHEDULING_LINK` can return 403 if token lacks rights or owner URI is invalid
+- `CALENDLY_LIST_EVENT_TYPE_AVAILABLE_TIMES` requires UTC timestamps and max 7-day range; split longer searches
+- Available times results are NOT paginated - all results returned in one response
+- Event type URIs must be full API URIs (e.g., `https://api.calendly.com/event_types/...`)
+
+### 4. Cancel Events
+
+**When to use**: User wants to cancel a scheduled Calendly event
+
+**Tool sequence**:
+1. `CALENDLY_LIST_EVENTS` - Find the event to cancel [Prerequisite]
+2. `CALENDLY_GET_EVENT` - Confirm event details before cancellation [Prerequisite]
+3. `CALENDLY_LIST_EVENT_INVITEES` - Check who will be affected [Optional]
+4. `CALENDLY_CANCEL_EVENT` - Cancel the event [Required]
+
+**Key parameters**:
+- `uuid`: Event UUID to cancel
+- `reason`: Optional cancellation reason (may be included in notification to invitees)
+
+**Pitfalls**:
+- Cancellation is IRREVERSIBLE - always confirm with the user before calling
+- Cancellation may trigger notifications to invitees
+- Only active events can be canceled; already-canceled events return errors
+- Get explicit user confirmation before executing `CALENDLY_CANCEL_EVENT`
+
+### 5. Manage Organization and Invitations
+
+**When to use**: User wants to invite members, manage organization, or handle org invitations
+
+**Tool sequence**:
+1. `CALENDLY_GET_CURRENT_USER` - Get user and organization context [Prerequisite]
+2. `CALENDLY_GET_ORGANIZATION` - Get organization details [Optional]
+3. `CALENDLY_LIST_ORGANIZATION_INVITATIONS` - Check existing invitations [Optional]
+4. `CALENDLY_CREATE_ORGANIZATION_INVITATION` - Send an org invitation [Required]
+5. `CALENDLY_REVOKE_USER_S_ORGANIZATION_INVITATION` - Revoke a pending invitation [Optional]
+6. `CALENDLY_REMOVE_USER_FROM_ORGANIZATION` - Remove a member [Optional]
+
+**Key parameters**:
+- `uuid`: Organization UUID
+- `email`: Email address of user to invite
+- `status`: Filter invitations by `"pending"`, `"accepted"`, or `"declined"`
+
+**Pitfalls**:
+- Only org owners/admins can manage invitations and removals; others get authorization errors
+- Duplicate active invitations for the same email are rejected - check existing invitations first
+- Organization owners cannot be removed via `CALENDLY_REMOVE_USER_FROM_ORGANIZATION`
+- Invitation statuses include pending, accepted, declined, and revoked - handle each appropriately
+
+## Common Patterns
+
+### ID Resolution
+Calendly uses full API URIs as identifiers, not simple IDs:
+- **Current user URI**: `CALENDLY_GET_CURRENT_USER` returns `resource.uri` (e.g., `https://api.calendly.com/users/{uuid}`)
+- **Organization URI**: Found in current user response at `resource.current_organization`
+- **Event UUID**: Extract from event URI or list responses
+- **Event type URI**: From `CALENDLY_LIST_USER_S_EVENT_TYPES` response
+
+Important: Never use `"me"` as a user parameter in list/filter endpoints. Always resolve to the full URI first.
+
+### Pagination
+Most Calendly list endpoints use token-based pagination:
+- Set `count` for page size (default 20)
+- Follow `page_token` from `pagination.next_page_token` until absent
+- Sort with `field:direction` format (e.g., `start_time:asc`, `created_at:desc`)
+
+### Time Handling
+- All timestamps must be in UTC format: `yyyy-MM-ddTHH:mm:ss.ffffffZ`
+- Use `min_start_time` / `max_start_time` for date range filtering on events
+- Available times queries have a maximum 7-day range; split longer searches into multiple calls
+
+## Known Pitfalls
+
+### URI Formats
+- All entity references use full Calendly API URIs (e.g., `https://api.calendly.com/users/{uuid}`)
+- Never pass bare UUIDs where URIs are expected, and never pass `"me"` to list endpoints
+- Extract UUIDs from URIs when tools expect UUID parameters (e.g., `CALENDLY_GET_EVENT`)
+
+### Scope Requirements
+- `CALENDLY_LIST_EVENTS` requires exactly one scope (user, organization, or group) - no more, no less
+- Organization/group scoped queries may require admin privileges
+- Token scope determines which operations are available; 403 errors indicate insufficient permissions
+
+### Data Relationships
+- Events have invitees (attendees who booked)
+- Event types define scheduling pages (duration, availability rules)
+- Organizations contain users and groups
+- Scheduling links are tied to event types, not directly to events
+
+### Rate Limits
+- Calendly API has rate limits; avoid tight loops over large datasets
+- Paginate responsibly and add delays for batch operations
+
+## Quick Reference
+
+| Task | Tool Slug | Key Params |
+|------|-----------|------------|
+| Get current user | `CALENDLY_GET_CURRENT_USER` | (none) |
+| Get user by UUID | `CALENDLY_GET_USER` | `uuid` |
+| List events | `CALENDLY_LIST_EVENTS` | `user`, `status`, `min_start_time` |
+| Get event details | `CALENDLY_GET_EVENT` | `uuid` |
+| Cancel event | `CALENDLY_CANCEL_EVENT` | `uuid`, `reason` |
+| List invitees | `CALENDLY_LIST_EVENT_INVITEES` | `uuid`, `status`, `email` |
+| Get invitee | `CALENDLY_GET_EVENT_INVITEE` | `event_uuid`, `invitee_uuid` |
+| List event types | `CALENDLY_LIST_USER_S_EVENT_TYPES` | `user`, `active` |
+| Get event type | `CALENDLY_GET_EVENT_TYPE` | `uuid` |
+| Check availability | `CALENDLY_LIST_EVENT_TYPE_AVAILABLE_TIMES` | event type URI, `start_time`, `end_time` |
+| Create scheduling link | `CALENDLY_CREATE_SCHEDULING_LINK` | `owner`, `max_event_count` |
+| List availability schedules | `CALENDLY_LIST_USER_AVAILABILITY_SCHEDULES` | user URI |
+| Get organization | `CALENDLY_GET_ORGANIZATION` | `uuid` |
+| Invite to org | `CALENDLY_CREATE_ORGANIZATION_INVITATION` | `uuid`, `email` |
+| List org invitations | `CALENDLY_LIST_ORGANIZATION_INVITATIONS` | `uuid`, `status` |
+| Revoke org invitation | `CALENDLY_REVOKE_USER_S_ORGANIZATION_INVITATION` | org UUID, invitation UUID |
+| Remove from org | `CALENDLY_REMOVE_USER_FROM_ORGANIZATION` | membership UUID |

package/skills/canva-automation/SKILL.md

@@ -0,0 +1,217 @@
+---
+name: canva-automation
+description: "Automate Canva tasks via Rube MCP (Composio): designs, exports, folders, brand templates, autofill. Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Canva Automation via Rube MCP
+
+Automate Canva design operations through Composio's Canva toolkit via Rube MCP.
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Canva connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `canva`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `canva`
+3. If connection is not ACTIVE, follow the returned auth link to complete Canva OAuth
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Core Workflows
+
+### 1. List and Browse Designs
+
+**When to use**: User wants to find existing designs or browse their Canva library
+
+**Tool sequence**:
+1. `CANVA_LIST_USER_DESIGNS` - List all designs with optional filters [Required]
+
+**Key parameters**:
+- `query`: Search term to filter designs by name
+- `continuation`: Pagination token from previous response
+- `ownership`: Filter by 'owned', 'shared', or 'any'
+- `sort_by`: Sort field (e.g., 'modified_at', 'title')
+
+**Pitfalls**:
+- Results are paginated; follow `continuation` token until absent
+- Deleted designs may still appear briefly; check design status
+- Search is substring-based, not fuzzy matching
+
+### 2. Create and Design
+
+**When to use**: User wants to create a new Canva design from scratch or from a template
+
+**Tool sequence**:
+1. `CANVA_ACCESS_USER_SPECIFIC_BRAND_TEMPLATES_LIST` - Browse available brand templates [Optional]
+2. `CANVA_CREATE_CANVA_DESIGN_WITH_OPTIONAL_ASSET` - Create a new design [Required]
+
+**Key parameters**:
+- `design_type`: Type of design (e.g., 'Presentation', 'Poster', 'SocialMedia')
+- `title`: Name for the new design
+- `asset_id`: Optional asset to include in the design
+- `width` / `height`: Custom dimensions in pixels
+
+**Pitfalls**:
+- Design type must match Canva's predefined types exactly
+- Custom dimensions have minimum and maximum limits
+- Asset must be uploaded first via CANVA_CREATE_ASSET_UPLOAD_JOB before referencing
+
+### 3. Upload Assets
+
+**When to use**: User wants to upload images or files to Canva for use in designs
+
+**Tool sequence**:
+1. `CANVA_CREATE_ASSET_UPLOAD_JOB` - Initiate the asset upload [Required]
+2. `CANVA_FETCH_ASSET_UPLOAD_JOB_STATUS` - Poll until upload completes [Required]
+
+**Key parameters**:
+- `name`: Display name for the asset
+- `url`: Public URL of the file to upload (for URL-based uploads)
+- `job_id`: Upload job ID returned from step 1 (for status polling)
+
+**Pitfalls**:
+- Upload is asynchronous; you MUST poll the job status until it completes
+- Supported formats include PNG, JPG, SVG, MP4, GIF
+- File size limits apply; large files may take longer to process
+- The `job_id` from CREATE returns the ID needed for status polling
+- Status values: 'in_progress', 'success', 'failed'
+
+### 4. Export Designs
+
+**When to use**: User wants to download or export a Canva design as PDF, PNG, or other format
+
+**Tool sequence**:
+1. `CANVA_LIST_USER_DESIGNS` - Find the design to export [Prerequisite]
+2. `CANVA_CREATE_CANVA_DESIGN_EXPORT_JOB` - Start the export process [Required]
+3. `CANVA_GET_DESIGN_EXPORT_JOB_RESULT` - Poll until export completes and get download URL [Required]
+
+**Key parameters**:
+- `design_id`: ID of the design to export
+- `format`: Export format ('pdf', 'png', 'jpg', 'svg', 'mp4', 'gif', 'pptx')
+- `pages`: Specific page numbers to export (array)
+- `quality`: Export quality ('regular', 'high')
+- `job_id`: Export job ID for polling status
+
+**Pitfalls**:
+- Export is asynchronous; you MUST poll the job result until it completes
+- Download URLs from completed exports expire after a limited time
+- Large designs with many pages take longer to export
+- Not all formats support all design types (e.g., MP4 only for animations)
+- Poll interval: wait 2-3 seconds between status checks
+
+### 5. Organize with Folders
+
+**When to use**: User wants to create folders or organize designs into folders
+
+**Tool sequence**:
+1. `CANVA_POST_FOLDERS` - Create a new folder [Required]
+2. `CANVA_MOVE_ITEM_TO_SPECIFIED_FOLDER` - Move designs into folders [Optional]
+
+**Key parameters**:
+- `name`: Folder name
+- `parent_folder_id`: Parent folder for nested organization
+- `item_id`: ID of the design or asset to move
+- `folder_id`: Target folder ID
+
+**Pitfalls**:
+- Folder names must be unique within the same parent folder
+- Moving items between folders updates their location immediately
+- Root-level folders have no parent_folder_id
+
+### 6. Autofill from Brand Templates
+
+**When to use**: User wants to generate designs by filling brand template placeholders with data
+
+**Tool sequence**:
+1. `CANVA_ACCESS_USER_SPECIFIC_BRAND_TEMPLATES_LIST` - List available brand templates [Required]
+2. `CANVA_INITIATE_CANVA_DESIGN_AUTOFILL_JOB` - Start autofill with data [Required]
+
+**Key parameters**:
+- `brand_template_id`: ID of the brand template to use
+- `title`: Title for the generated design
+- `data`: Key-value mapping of placeholder names to replacement values
+
+**Pitfalls**:
+- Template placeholders must match exactly (case-sensitive)
+- Autofill is asynchronous; poll for completion
+- Only brand templates support autofill, not regular designs
+- Data values must match the expected type for each placeholder (text, image URL)
+
+## Common Patterns
+
+### Async Job Pattern
+
+Many Canva operations are asynchronous:
+```
+1. Initiate job (upload, export, autofill) -> get job_id
+2. Poll status endpoint with job_id every 2-3 seconds
+3. Check for 'success' or 'failed' status
+4. On success, extract result (asset_id, download_url, design_id)
+```
+
+### ID Resolution
+
+**Design name -> Design ID**:
+```
+1. Call CANVA_LIST_USER_DESIGNS with query=design_name
+2. Find matching design in results
+3. Extract id field
+```
+
+**Brand template name -> Template ID**:
+```
+1. Call CANVA_ACCESS_USER_SPECIFIC_BRAND_TEMPLATES_LIST
+2. Find template by name
+3. Extract brand_template_id
+```
+
+### Pagination
+
+- Check response for `continuation` token
+- Pass token in next request's `continuation` parameter
+- Continue until `continuation` is absent or empty
+
+## Known Pitfalls
+
+**Async Operations**:
+- Uploads, exports, and autofills are all asynchronous
+- Always poll job status; do not assume immediate completion
+- Download URLs from exports expire; use them promptly
+
+**Asset Management**:
+- Assets must be uploaded before they can be used in designs
+- Upload job must reach 'success' status before the asset_id is valid
+- Supported formats vary; check Canva documentation for current limits
+
+**Rate Limits**:
+- Canva API has rate limits per endpoint
+- Implement exponential backoff for bulk operations
+- Batch operations where possible to reduce API calls
+
+**Response Parsing**:
+- Response data may be nested under `data` key
+- Job status responses include different fields based on completion state
+- Parse defensively with fallbacks for optional fields
+
+## Quick Reference
+
+| Task | Tool Slug | Key Params |
+|------|-----------|------------|
+| List designs | CANVA_LIST_USER_DESIGNS | query, continuation |
+| Create design | CANVA_CREATE_CANVA_DESIGN_WITH_OPTIONAL_ASSET | design_type, title |
+| Upload asset | CANVA_CREATE_ASSET_UPLOAD_JOB | name, url |
+| Check upload | CANVA_FETCH_ASSET_UPLOAD_JOB_STATUS | job_id |
+| Export design | CANVA_CREATE_CANVA_DESIGN_EXPORT_JOB | design_id, format |
+| Get export | CANVA_GET_DESIGN_EXPORT_JOB_RESULT | job_id |
+| Create folder | CANVA_POST_FOLDERS | name, parent_folder_id |
+| Move to folder | CANVA_MOVE_ITEM_TO_SPECIFIED_FOLDER | item_id, folder_id |
+| List templates | CANVA_ACCESS_USER_SPECIFIC_BRAND_TEMPLATES_LIST | (none) |
+| Autofill template | CANVA_INITIATE_CANVA_DESIGN_AUTOFILL_JOB | brand_template_id, data |

package/skills/canvas-design/LICENSE.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.