Update modeling-introduction.md

Add Viewing Changes article

CODE_OF_CONDUCT.md

@@ -0,0 +1,46 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at robbins@stoplight.io. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

README.md

@@ -2,17 +2,23 @@
 
 The time is nigh!
 
-All work should be done in the develop branch.
+## Workflow
+
+* All work should be done in a branch off of develop, and submitted via a PR upon completion.
 
 ## Templates
 
+TODO
+
 ## Articles
 
+TODO
+
 ## Assets
 
 Assets (like images) should be placed in the assets/images folder.
 
-JPEG, PNG, and GIF image formats are supported. Images can be included in markdown by using the path to the image.
+JPEG, PNG, and GIF image formats are supported. Images can be included in markdown by using the relative path to the image.
 
 For example:
 
@@ -21,7 +27,7 @@ For example:
 
 # Organization Overview
 
-![my image](./assets/images/my-image.jpg)
+![my image](../../assets/images/my-image.jpg)
 ```
 
 ## Linking
@@ -35,5 +41,5 @@ For example:
 
 # Organization Overview
 
-A link to [Projects Overview](./articles/projects/overview.md).
+A link to [Projects Overview](../projects/overview.md).
 ```

TOC.md

@@ -0,0 +1,152 @@
+---
+title: Stoplight Help
+description: 'Bout time.
+theme: ./theme.css
+javascript: ./global.js
+nav: [['Platform'], [], ['Editor']]
+---
+
+* ![Platform](./logo.png "Platform")
+  * Getting Started
+    * [What is Stoplight?](./articles/getting-started/what-is-stoplight.md)
+    * Getting started for new users
+    * Getting started for organization owners
+    * Onboard your organization to Stoplight (example: https://get.slack.help/hc/en-us/articles/115004378828-Onboard-your-company-to-Slack-#use-case-1-1)
+    * Account Basics
+      * Sign In to Stoplight
+      * Edit Your Profile
+      * Manage Your Password
+      * Change your Username
+      * Change your Email Address
+      * Sign out of Stoplight
+      * Deactivate your Stoplight Account
+      * Working with Todos
+      * Billing
+        * Plan Overview
+        * Invoices
+        * Cancel Your Account
+        * Discounts for Nonprofits/Educational Institutions
+    * Migrating from Stoplight Classic
+      * Overview
+      * Migrating Workspaces
+      * Migrating Published Documentation
+      * Migrating Billing
+  * Projects
+    * Creating a Project
+    * Inviting People & Teams to Projects
+    * Changing People & Team Project Roles
+    * Making Your Project Private/Public
+  * Organizations
+    * Create an Organization
+    * Invite People to Organization
+    * Remove People from Your Organization
+    * Member Roles and Permissions
+    * Customize your Organization
+    * Transfer Primary Ownership
+    * Delete an Organization
+    * Teams
+      * Create a Team
+      * Add People to a Team
+      * Remove People from a Team
+      * Member Roles and Permissions
+      * Customize a Team
+      * Transfer Primary Ownership
+      * Delete a Team
+  * Desktop App
+    * Overview (Differences between the web and desktop apps)
+    * Custom Hosts and Proxies
+  * Department Playbooks
+    * Stoplight for software developers
+    * Stoplight for QA testers
+    * Stoplight for technical writers
+    * Stoplight for product managers
+  * FAQs
+* Editor
+  * Basics
+    * Working with files
+    * Switching between visual and code views
+    * Viewing history of changes
+    * File validation
+    * Working with environments
+    * Editor configuration
+  * Issues
+    * Creating Issues
+    * Replying to Issues
+    * Closing Issues
+    * Attaching issues to files
+    * @Mention People (link to todos article)
+  * Modeling APIs with OpenAPI (Swagger 2)
+    * Introduction (what is modeling and OAS)
+    * Building up an API Library
+    * Using the CRUD builder
+    * API operations
+    * API models
+    * Security schemes
+    * Shared parameters and responses
+    * Referencing another API spec
+    * Sending HTTP requests to your API
+    * Validating your API Spec
+  * Modeling Objects with JSON Schema
+    * Introduction
+    * Modeling open-ended objects (patternProperties)
+    * Modeling polymorphic objects (anyOf, oneOf)
+    * Using object inheritance (allOf)
+    * Adding validations
+    * Reducing duplication with $refs
+    * Generating schemas from examples
+  * Testing with Scenarios
+    * Introduction
+    * Understanding the scenario specification
+    * Running your tests
+      * In Stoplight
+      * In the Terminal
+      * Triggering by URL
+    * Using Variables
+      * Overview
+      * Passing data between steps (Capturing)
+      * $$.env (Environment)
+      * $.ctx (Context)
+    * Sending HTTP Requests
+      * Overview
+      * Using assertions
+      * Authorization
+      * Basic Authentication
+        * OAuth 2
+        * OAuth 1
+        * AWS Signature Auth
+    * Scripting
+      * Overview
+      * Before / After Scripts
+      * Script Step Type
+    * Referencing Other Scenarios
+      * Overview
+      * Using $.ctx with references
+    * Leveraging OpenAPI (Swagger 2)
+      * Overview
+      * Contract testing
+      * Generating tests from API specs
+      * Using coverage reports
+    * Integrating in Continuous Integration
+      * Circle CI
+      * Jenkins
+      * Travis
+  * Documenting with Hubs
+    * Introduction
+    * Routing
+    * Managing the Header & Footer
+    * Pages
+    * Subpages
+    * Blocks
+    * Referencing / Embedding Other Data Sources
+      * Overview
+      * OpenAPI Specifications
+      * Markdown
+    * Theming
+    * Publishing
+      * Overview
+      * ...
+  * Running Servers with Prism
+    * Introduction
+    * Mock Servers
+    * Validation Servers
+    * Record / Replay Servers

articles/accounts/authentication.md

@@ -0,0 +1,15 @@
+# Authenticating to Stoplight
+
+## Registering
+
+### With Email
+
+### With Github
+
+## Logging In
+
+### With Email
+
+### With Github
+
+## Logging Out

articles/accounts/changing-your-email.md

@@ -0,0 +1,13 @@
+# Change your Email Address
+
+![](/assets/gifs/account-info.gif)
+
+## What 
+Changing your email address is easy as pie 
+
+## How 
+1. Click on your **username** in the top right 
+2. Click on the **Account** button
+3. In the **Basic Info** section, replace the email listed with one you would like to change to 
+4. Click **Save** and you’re all done 
+

articles/accounts/changing-your-username.md

@@ -0,0 +1,12 @@
+# Change Your Username 
+
+![](../../assets/gifs/account-info.gif)
+
+## What 
+You can change your username at any time 
+
+## How 
+1. Click on your current **username** in the top right 
+2. Click on **Account** 
+3. Under **Basic Info**, input a new username 
+4. Click **Save** 

articles/accounts/deactivate-account.md

@@ -0,0 +1,8 @@
+# Deactivate Your Stoplight Account 
+
+## What
+* We're sorry to see you leave. Come back soon! 
+
+## How
+1. Email [support@stoplight.io](mailto:support@stoplight.io) with your deactivation request 
+2. We'll take care of the rest 

articles/accounts/edit-profile.md

@@ -0,0 +1,22 @@
+# Edit your Profile 
+
+![](../../assets/gifs/account-info.gif)
+
+## What 
+In your profile you can edit things like: 
+* Basic Info 
+    * Username 
+    * Name
+    * Email
+* Upload a profile image 
+* Change Password 
+ 
+##  How
+1. Select your **Username** in the top right corner
+2. Click **Account**
+3. Make your edits in **Basic Info**, then click **Save** 
+    * You can also click **Reset** if you would like to start from scratch 
+4. Upload a profile image 
+5. Make your edits in Change Password then click **Change Password** 
+    * Password must be at least 6 characters 
+ 

articles/accounts/manage-password.md

@@ -0,0 +1,14 @@
+# Manage Your Password 
+
+![](../../assets/gifs/account-info.gif)
+
+## What 
+If you’ve forgotten the password you use to sign in to Stoplight; you can easily reset it at any time
+
+## What
+1. At the login page, select **Forgot Password?**
+2. Input your email in the space provided 
+3. Click **Send Email Link** 
+4. An email will be sent with a link to your email address
+5. Click on the link and you will be sent to an email reset page 
+6. Choose a new password and Voila 

articles/accounts/sign-in.md

@@ -0,0 +1,25 @@
+# Sign In To Stoplight 
+
+## What
+There are two separate options for creating your snazzy new Stoplight account: 
+* Login with GitHub 
+* Create a new account 
+  
+## How
+
+### Login  with Github
+
+1. Click **Login with Github** 
+2. A window will popup asking you to authorize access to your Github account 
+3. Click **Authorize stoplightio**
+
+### To Create a New Account
+
+1. Click on **Join**
+2. Fill in your **Name** 
+3. Create a **Username** 
+4. Input the **Email** you want associated with this account 
+5. Create a **Password**
+    * Password must be more than 6 characters 
+6. Click **Join Stoplight**
+

articles/accounts/sign-out.md

@@ -0,0 +1,11 @@
+# Sign Out of Stoplight 
+
+![](../../assets/gifs/sign-out.gif)
+
+## What 
+* By default, Stoplight remains open. If you wish to sign out follow these quick and easy steps 
+
+## How
+1. Click on your **username** in the top right corner 
+2. In the dropdown menu select **Sign Out** 
+3. All set, come back soon! 

articles/accounts/todos.md

@@ -0,0 +1 @@
+# How Todos Work

articles/desktop/overview.md

@@ -0,0 +1,23 @@
+# Web & Desktop App
+
+
+Stoplight has a desktop app! Download the appropriate version [here](https://stoplight.io/download) .
+
+
+## Web or Local?
+
+
+The main difference between the Stoplight desktop app and the web app is that the desktop app can store requests and test data offline. The desktop app can also connect with APIs that are behind firewalls or otherwise not available on the public internet (localhost as well).
+
+
+## Local Prism
+
+
+When you start the Stoplight desktop app, it will start an instance of Prism on http://localhost:4010. The desktop Prism instance is identical to the downloadable Prism binary run manually from your terminal. When you run local tests in the desktop app, it automatically calls a local Prism instance with the correct arguments and spec files.
+
+
+## Local Save
+
+
+* The Stoplight desktop app can read/write specification files on your local file system. This is perfect for generating specification outside of Stoplight (like from code), want to use version control systems like Git, or want to use your favorite IDE to work on a spec. 
+* This feature is **NOT** available in the web app 

articles/editor/editor-configuration.md

@@ -0,0 +1,35 @@
+# Configuration with the `.stoplight.yml` File
+
+This document describes the usage of `.stoplight.yml`, the file that is used by the Stoplight editor to manage its configuration.
+
+It is placed in the root of your project and allows you to configure editor settings and environments that will apply to **all** users of the project. This allows you to share commonly-used settings between members of your team directly.
+
+You can make changes to the `.stoplight.yml` file by opening it:
+
+![](../../assets/images/editor-configuration.png)
+
+### Editor Configuration
+
+- **defaultFile**: The `defaultFile` setting allows you to control which file is displayed to read-only users when they navigate to the project. This can be useful to show them a particular markdown or hub on first load.
+
+### Environments
+
+![](../../assets/images/editor-configuration2.png)
+
+Environments make it easy to auto-populate variables (hostnames, ports, passwords, etc.) used by specifications and scenarios. Read more about them [here](../testing/variables-environment.md).
+
+The environments and variables defined in the `.stoplight.yml` are shared amongst all users, which makes this a good place to define common or shared variables, such as the url host for a particular API + environment. 
+
+There are three environments included with a new project:
+
+* __Default__ - The __Default__ environment is used by the Stoplight editor when first logging in and if no other environment has been selected. This is commonly used for variables needed for development and prototyping.
+* __Staging__ - The __Staging__ environment is automatically created for the storing of"staging" or "pre-production" variables and settings.
+* __Production__ - The __Production__ environment is automatically created for the storing of production variables and settings.
+
+These environments can be customized by editing the `environments` key of the `.stoplight.yml` file. To add a new environment, simply add a new key to the `environments` property, and set the value to an empty object or an object with default variables to share amongst your team.
+
+***
+
+**Related**
+
+* [Testing Environment Variables](../testing/variables-environment.md)

articles/editor/environments.md

@@ -0,0 +1,51 @@
+# Environments
+
+<!--(FIXME - SHOW CLICKING BETWEEN DIFFERENT ENVIRONMENTS)-->
+
+An environment is simply a container for data, represented as a list of key-value pairs (behind the scenes, this is a JSON object). Every Stoplight project has one or more environments associated with it. The data stored in an environment can be used in many places within the Stoplight editor.
+
+Environments, and their default data, are defined in the [Stoplight configuration file](./editor-configuration.md#environments).
+
+- __Do__ create an environment for each development environment associated with the project. For example, `development`, `staging`, and `production`.
+- __Don't__ create environments for individual users. Instead, use private variables (below) to customize existing environments.
+- __Do__ use environment default data to store shared information like hostnames, ports, passwords, etc.
+- __Don't__ use environments to store fixture/seed/temporary data.
+
+<!--(FIXME - SHOW SCREENSHOT OF THE ENVIRONMENTS WINDOW)-->
+
+For more information on environment variables and how they can be used during API testing, please
+see [here](../testing/variables-environment.md).
+
+## Private Variables
+
+Private Variables are _only_ stored locally on your system,
+and are never sent to Stoplight or the rest of your team. Private variables
+should be reserved for secrets specific to you, such as user-specific passwords,
+API keys, and other pieces of sensitive and/or individually specific data.
+
+Edit private variables by clicking on the environment button in the top right of the Stoplight editor.
+
+> Since private variables are only stored on your computer, make sure they are
+  backed up in a secure location.
+
+## Resolved Variables
+
+Resolved Variables shows a read-only view of the variables that are currently
+exposed to your editor. They are based on:
+
+* The currently selected (active) environment
+* The active environment's default variables, as defined in the stoplight configuration file
+* The active environment's private variables, as defined by you
+
+Private variables are merged over default variables that share the same name. This makes it easy
+for individual team members to customize and extend environments without affecting the rest of the team.
+
+For more information on updating and customizing environment variables, please
+see [here](./editor-configuration.md#environments).
+
+***
+
+**Results**
+
+* [Using Environment Variables in Testing](../testing/variables-environment.md)
+* [Configuration with the `.stoplight.yml` File](./editor-configuration.md#environments)

articles/editor/file-validation.md

@@ -0,0 +1,27 @@
+# File Validation
+
+![](../../assets/gifs/file-validation-OpenAPI-spec.gif)
+
+File validation is the process of checking a file's syntax and structure to make sure it meets specific requirements. Stoplight's validation ensures file edits are in the correct format. This is especially helpful while editing structured file formats (e.g. OpenAPI documents) so that any errors can be resolved quickly and efficiently.
+
+File validation is run after every file edit to make sure no errors were introduced. A notification will appear if validation errors were introduced so that they can be resolved before attempting to save. If a validation error is detected, an alert will appear with an explanation of the issue and where it occurred.
+
+![](../../assets/images/file-validation-error-overview.png)
+
+Validation failures come in two levels:
+
+* __Warnings__ - A warning is generated if the validation process found a non-critical issue that did not interrupt the processing of the document. As an example, inclusion of non-standard fields in an OpenAPI document will display as a warning.
+
+* __Errors__ - An error is generated if the validation process found a critical issue that prevented the processing of the document. As an example, not including the correct fields in an OpenAPI document will display as an error.
+
+Different types of file validations are used throughout the Stoplight platform. At a high level, file validations aim to identify the following two groups of errors:
+
+* __Syntax__ - Most files stored in Stoplight are either JSON or YAML format, so they must always adhere to the JSON/YAML formatting standards. If anything typed into the editor does not meet the format criteria, it will be rejected with a notification pointing to where the syntax error occurred. _Syntax errors will prevent the file from being saved until all errors are resolved._
+
+* __Correctness__ - Certain files stored within Stoplight must adhere to high-level specifications to ensure they are able to be read and processed correctly. The OAS/Swagger specification is one such standard. It is critical that every OAS document stored in Stoplight meet these standards. If an error is detected in any document, either an error or warning will be generated with a description of the issue.
+
+***
+
+**Related**
+
+* [OpenAPI Validation](../modeling/openapi-validation.md)

articles/editor/view-history-changes.md

@@ -0,0 +1,32 @@
+# Viewing Changes
+
+As more users edit files within the same project, tracking changes over time
+becomes increasingly difficult. To mitigate these effects, Stoplight provides the full history of changes, which allows you to view and track any changes made.
+
+To see the history of changes for a project, use the 'History' button on the
+navigation bar to the left of the project window (shown below). When the history
+is being viewed, you will see a series of changes for the project, listed in
+descending order by date.
+
+![](../../assets/images/viewing-changes2.png)
+
+Each change event includes:
+
+* The date when the change was made
+
+* The user who made the change
+
+* The files updated by the change
+
+* The differences (known as the 'diff') between each file before and after the
+  change occurred
+
+See the image below for an overview of the contents of the change view.
+
+![](../../assets/images/viewing-changes.png)
+
+---
+
+**Related**
+
+* [Working with Files](./working-with-files.md)

articles/editor/visual-code-view.md

@@ -0,0 +1,7 @@
+# Visual & Code Views
+
+![](../../assets/gifs/editor-visual-toggle.gif)
+
+Stoplight NEXT now has a toggle for switching between our visual editor and our code editor. If you prefer working with code, need to paste in some OAS, or just want to make changes manually, switch over to the code editor.  This new feature is included in all our editors including Hubs, Modeling, and Scenarios. 
+
+<callout> New Feature! Any changes made in the code editor will automatically populate the visual editor. </>

articles/editor/working-with-files.md

@@ -0,0 +1,24 @@
+# Working with Files 
+
+![](../../assets/gifs/fileexplorer.gif)
+
+As part of our effort to make the Stoplight platform more flexible and familiar we added a file explorer to Stoplight NEXT. You can now see all your files sorted by filetype in one central location within Projects. File types include: 
+
+* .hub (Hub/Docs Files)
+* .oas2 (Modeling Files)
+* .scenarios (Scenario/Testing FIles)
+* .prism (Prism Files) 
+* .md (Markdown Files) 
+
+## File Explorer 
+
+Within the file explorer you can:
+ 
+* **Search for Files**
+	* Search for files using the **search bar** at the top of the file explorer 
+* **Create Files** 
+	* Hover to the right of the filetype headers and click the **+** to create a new file 
+* **Export Files** 
+	* Hover to the right of a file and click the **arrow** to export files into OAS
+* **Delete Files** 
+	* Hover to the right of a file and click the **trash can** to delete files

articles/getting-started/faq.md

@@ -0,0 +1,51 @@
+# FAQs
+
+## General
+
+**Is Stoplight v2 being discontinued?**
+
+Stoplight Classic (v2) will persist, but new feature development will only occur on Stoplight v3. Major bugs in Stoplight v2 will continue to be addressed. We encourage all our Stoplight Classic (v2) users to move onto our new platform. Read more about migrating from v2 to v3 [here](LINK).
+
+**Can I save my files locally?**
+
+Yes, but only on the desktop app. Click [here](LINK) to learn more about the Stoplight desktop app.
+
+**Is there a way to manage multiple APIs in a single Project**
+
+Yes. In Stoplight v3 you can manage unlimited APIs in a single Project. To learn more click [here](LINK).
+
+**What are the differences between Stoplight Classic (v2) and Stoplight v3?**
+
+Stoplight Classic is our original platform. Stoplight v3 is the next generation of platform, including all the features and tools from Stoplight Classic and much more. To learn more, click [here](LINK).
+
+**Can I transfer Account ownership?**
+
+Yes, you can [transfer ownership of an Organization](https://next.stoplight.io/stoplight/stoplight-next-docs/blob/master/Stoplight%20Platform.hub.yml?edit=%23%2Fpages%2F~1%2Fdata%2Fchildren%2F2%2Fdata%2Fchildren%2F5) or [make changes to your personal account](https://next.stoplight.io/stoplight/stoplight-next-docs/blob/master/Stoplight%20Platform.hub.yml?edit=%23%2Fpages%2F~1%2Fdata%2Fchildren%2F0%2Fdata%2Fchildren%2F1)
+
+**Is there a way to edit my OpenAPI (Swagger) directly?**
+
+Yes. In Stoplight v3 you can switch between the GUI editor and the source code via a TAB in the editor.For more information click [here](LINK).
+
+**Does Stoplight offer monitoring solutions?**
+
+Not at the moment, however, scheduling scenarios + alerting (monitoring) is on our roadmap.
+
+**Does Stoplight support SSO?**
+
+Yes. The business and enterprise plans support SSO. For more information, click [here](LINK).
+
+**I am looking for a secure solution for hosting my API and restricting access, what do you recommend for hosting?**
+
+Stoplight offers an on-premise installation option that will meet most security needs. For more information, click [here](LINK).
+
+**Does Stoplight support OpenAPI 3?**
+
+Currently we support OpenAPI 2 (Swagger 2). OpenAPI 3 support on our short term roadmap.
+
+**My sign-up token has expired, how do I generate a new one?**
+
+On the login page, go to forgot password and reset it using your email. This will renew your token.
+
+**Can I remove the Stoplight branding from my API docs?**
+
+Yes! In Stoplight v3 all paid users have access to the underlying CSS, and can customize it to remove or change any of the visual elements on the page. Click [here](LINK) for more information on themeing.

articles/getting-started/new-user-introduction.md

@@ -0,0 +1,24 @@
+# Welcome to Stoplight NEXT! 
+
+![](../../assets/images/stoplight-crew.jpg)
+
+Now that you have the basics on what the [Stoplight NEXT Platform](../what-is-stoplight.md) is, we can go over how to get started. 
+
+First things first, are you using it for Personal Projects or as part of an Organization?
+
+## Personal Projects 
+1. Create an Account (link)
+2. Create a Project (link) 
+
+## Organization 
+1. Create an Account (link)
+2. Create an Organization (link) 
+3. Invite Members (link) 
+4. Accept an Organization Invite 
+5. Create a Project (link) 
+
+## Web App or Download 
+* You can log in to the Web App at [next.stoplight.io](http://next.stoplight.io) or 
+* You can download the platform here (link) 
+
+If you have any questions you can reach out to us through Intercom or email us at [support@stoplight.io](support@stoplight.io) otherwise... **Full Steam Ahead!**

articles/getting-started/organization-onboarding.md

@@ -0,0 +1 @@
+

articles/getting-started/organization-owner-introduction.md

@@ -0,0 +1,37 @@
+# Organization Owner Introduction 
+
+![](/assets/gifs/org-create.gif)
+
+## Welcome to Stoplight NEXT!
+
+If you are trying to create a new Organization then you are in the right place. Stoplight NEXT was designed with large scale collaboration and governance as a central principle. The following guide will take you through the process of creating and populating an Organization, and offer an overview of the governance tools within Stoplight NEXT. 
+
+## Organization 
+Organizations function as a shared space for you and your co-workers. Members of an Organization have access to a centralized Activity Feed, Project Repository, and an Issues (link) discussion tool. Organization Owners can also assign varying levels of Permissions to other members of the Organization.  
+ 
+* Create an Organization (link)
+* Invite People to Organization (link) 
+* Remove People from your Organization (link) 
+* Member Roles and Permissions (link)
+* Customize your Organization (link) 
+* Transfer Primary Ownership (link) 
+* Delete an Organization (link)
+
+## Teams 
+If you are managing a large Organization with multiple teams you can use Teams to group Organization members together. 
+
+* Create a Team (link)
+* Add People to a Team (link)
+* Remove People from a Team (link)
+* Member Roles and Permissions (link) 
+* Customize a Team (link) 
+* Transfer Primary Ownership (link) 
+* Delete a Team (link) 
+
+## Projects 
+Projects are the workspaces you can create for your Organization. 
+
+* Creating a Project (link) 
+* Invite People & Teams to a Project (link)
+* Change a Project Member’s Role (link) 
+* Make Your Project Private/Public (link) 

articles/getting-started/stoplight-for-org-owners.md

@@ -0,0 +1 @@
+

articles/getting-started/what-is-stoplight.md

@@ -0,0 +1,36 @@
+# The Stoplight Platform 
+The Stoplight platform provides a suite of products that cover the entire pre-production API lifecycle. Here is an overview of the platform:
+
+![](../../assets/images/platform-overview.png) 
+
+Stoplight promotes a design-first philosophy. Developing good design-first practices at your organization will minimize future cost, speed up your time to market, and lead to more consistent, higher quality APIs.
+
+## API Modeling & Design
+At Stoplight, everything starts with design. Our visual designer makes it easy for anybody in your organization to model and document APIs, no matter the complexity.
+
+Whether you have an existing OpenAPI (Swagger) or are creating a new API design from scratch, we've got you covered.
+
+![](../../assets/images/modeling-editor.png)
+
+## API Testing
+Once you have your API design / documentation, how do you make sure that it remains accurate over time? Stoplight contract testing, powered by Prism, makes it trivial to create a full suite of tests that apply your API documentation (your contract) to your API. Run these tests from the Stoplight app, and standalone in your CI process or elsewhere.
+
+![](../../assets/images/scenarios-editor.png)
+
+## Hosted Documentation 
+
+You have your API designed and documented privately in the Stoplight app, and now you want to share all or part of it with 3rd parties (developers, customers, clients, etc). Stoplight makes it easy to publish your documentation to the world, with a single click.
+
+
+![](../../assets/images/HubsPreview.png)
+
+## Mock Server
+Stoplight provides a complete mock server for every API described in the app. Run tests against this mock server, build consumers (like mobile apps, SDKS, etc) before the final API is ready, and more.
+
+Spinning up your own mock server is as simple as:
+
+### install prism on macOS
+curl https://raw.githubusercontent.com/stoplightio/prism/master/install.sh | sh
+
+### run a fake petstore api on http://localhost:4010
+prism run --mock --list --spec http://petstore.swagger.io/v2/swagger.json

articles/help.md

@@ -0,0 +1,5 @@
+# Contact Us
+
+Having trouble finding what you are looking for? Need some additional support? We’ve got you covered. Shoot us a message and we will get back to you as soon as possible. 
+
+Email us at [support@stoplight.io](mailto:support@stoplight.io) or message us in Intercom. 

articles/hubs/blocks.md

@@ -0,0 +1,33 @@
+# Blocks 
+
+![](../../assets/gifs/Blocks.gif)
+
+## What
+Blocks are the micro-level building blocks of Hubs. They house multiple forms of content and allow for simple restructuring and modification. 
+
+<callout> Hovering over a Block reveals additional tooling including: Preview, Cut, Copy, Reference External Source, and Delete </>
+
+## Block Types 
+### Text Block 
+* A markup editor for adding any textual elements to your Hub 
+### JSON Schema
+* A block for describing the structure of a JSON object 
+### HTTP Request Maker 
+* A block for making HTTP requests 
+### Code
+* A block for inserting code snippets 
+### Image 
+* A block for inserting images
+### Tabs 
+* An upper level block for organizing text within tabs 
+### Callout 
+* A text block with color for emphasis 
+### Hero 
+* A large stylized text block with additional functionality typically found on landing pages 
+### Bar List 
+* A navigational block composed of bars with buttons 
+### Card List 
+* A navigational block composed of cards with text, buttons, and optional images
+### HTML 
+* Include arbitrary HTML in your hubs when the other base block types don't quite do the trick
+

articles/hubs/hubs-introduction.md

@@ -0,0 +1 @@
+

articles/hubs/managing-headers-footers.md

@@ -0,0 +1,32 @@
+
+# Managing Headers and Footers 
+
+![](../../assets/gifs/headers-footers.gif)
+
+## What 
+You can customize the headers and footers of your Hub to add additional navigation to your documentation. You can modify a header and footer: 
+
+- **Location on Page**: Drag and drop along the header and footer to the desired location 
+- **Type**: Page, External Link, Image 
+- **Title**: What text is displayed on page
+- **Path to Page**: Specify path to page  
+- **Image URL**: If you want to display an image instead of text for the link input image URL 
+
+
+## How 
+
+### Modify Existing Header and Footer
+
+1. Select the Hub you wish to modify
+2. Click on the **Editing toggle** 
+3. By default, there will already be three headers (Home, API Reference, Help) and a footer (Home) 
+    1. Hover over one of the headers or footers and click on the **gear icon** to modify 
+    2. Drag the header or footer to another location to change its location 
+
+
+### Create New Header and Footer 
+
+1. Select the Hub you wish to modify 
+2. Click on the **Editing toggle**
+3. Hover over the left or right edge of the header or footer 
+    1. Click on the **+** button 

articles/hubs/pages.md

@@ -0,0 +1,31 @@
+# Pages 
+
+![](../../assets/gifs/create-pages.gif)
+
+## What
+Pages are the macro level building blocks of a Hub. They function as the canvas on which all other Hubs objects reside. They are commonly used as a way to separate information based on the broadest topics. 
+
+### Hubs Architecture from Top Down 
+
+- Pages 
+    - Subpages 
+        - Blocks
+    - Header and Footer 
+    - Blocks 
+
+## How 
+
+### Create a New Page
+
+1. Select the Hub you wish to modify 
+2. Click on **Toggle Editor** 
+3. Select **+** Page in the editor toolbar 
+    1. Input a **Page Title** 
+    2. Input a **Page Route** (optional) 
+    3. **Power the Page** with an External Data Source (optional) 
+
+<!-- theme: info -->
+ >Did you know? After creating a new page; a header link will automatically be generated
+
+
+

articles/hubs/publishing.md

@@ -0,0 +1 @@
+

articles/hubs/ref-other-sources-hubs.md

@@ -0,0 +1,29 @@
+# Reference Other Sources
+
+![](../../assets/gifs/ref-other-sources-hubs.gif)
+
+## What
+Hubs allows you to reference other sources to automatically populate your Hub with content. We call this “powering” a building block. You can power a building block with a file from the current file, a file from the current project, a file from another project, or a file from an external source. 
+
+### What Can I Power
+
+- Pages 
+- Subpages 
+- Text Blocks 
+
+## How
+
+### Power a Subpage 
+
+1. Select the Hub you wish to modify 
+2. Select (or create a new) **Subpage** 
+3. Click on the **gear icon** in the center of the editor toolbar (If new, this window automatically opens)  
+    1. Select **Power this Subpage with an External Data Source**
+    2. Select the data source from the drop-down menu 
+    3. Input the specific data source or select from the drop-down menu
+    4. Input an inner data source (optional)  
+4. Click **Confirm**  
+
+<!-- theme: info -->
+>Try it Out! Power a Subpage with an API Spec from the same project.
+

articles/hubs/routing.md

@@ -0,0 +1,37 @@
+
+# Routing 
+
+![](../../assets/gifs/routing-hubs.gif)
+
+## What 
+Stoplight’s Hubs features an easy to use routing system to make sure your docs have identifiable and friendly URL’s. The routing system allows customization of the following objects: 
+
+- Your Hub 
+- Pages within a Hub (link) 
+- Subpages within a Hub (link) 
+- Headers + Footers (link)
+- Links 
+
+
+<!-- theme: info -->
+>Friendly URLs are links that are easily readable, rememberable, and relevant to the content.
+Take a look at the URL for this page. Instead of something like https://help.stoplight.io/docs/fnIenof/123, it is https://help.stoplight.io/docs/hosted-documentation/create-friendly-urls, which is much nicer. </>
+
+## How 
+
+### Pages & Subpages 
+
+1. Select the **Hub** you wish to modify 
+2. Add a new **page** or **subpage** (link) 
+   1. Select a **page title** to auto-fill the **Page Route** or 
+   2. Input a **custom page route** 
+3. Select an **existing page** or **subpage** 
+4. Select the **gear icon** at the top of the Hub in the center of the page or subpage you wish to modify  
+   1. Input a **new UR**L under Page Route  
+
+### Headers & Footers 
+
+1. Select the **Hub** you wish to modify 
+2. Add a new **header or footer** (link) or
+3. Hover over an existing header or footer and click the **gear icon** 
+    a. Input a **Path to Page** or **image URL**  

articles/hubs/subpages.md

@@ -0,0 +1,32 @@
+# Subpages 
+
+![](../../assets/gifs/create-subpages.gif)
+
+## What
+Subpages are the second tier macro building blocks of Hubs. They function as a canvas for blocks. They are commonly used to house content based on a specific topic.  Subpages can have more subpages nested underneath them, which gives you lots of flexibility to organize your Hub as you see fit. If a subpage has subpages nested inside of it, it will be displayed as a collapsible group in the left sidebar.
+
+<!-- theme: info -->
+>Subpages populate the navigational sidebar of a page.
+
+### Hubs Architecture Top Down
+- Pages 
+    - Subpages 
+        - Blocks
+    - Header and Footer 
+    - Blocks  
+
+## How 
+
+### Create a New Subpage 
+
+1. Select the Hub you wish to modify 
+2. Click on **Toggle Editor** 
+3. Select **+ Subpage** in the editor toolbar
+    1. Input a **Subpage Name** 
+    2. Modify the **Subpage Route** (optional) 
+    3. Give the Subpage a **Sidebar Token** (optional) 
+    4. **Power the Subpage** with an External Data Source (optional) 
+
+<!-- theme: info --> 
+>Just like pages, subpages can have blocks. Any blocks added to a subpage will be displayed when a reader navigates to that subpage in your hub
+

articles/hubs/themes.md

@@ -0,0 +1 @@
+

articles/issues/attaching-issues-to-files.md

@@ -0,0 +1 @@
+

articles/issues/closing-issues.md

@@ -0,0 +1 @@
+

articles/issues/creating-issues.md

@@ -0,0 +1 @@
+

articles/issues/replying-to-issues.md

@@ -0,0 +1 @@
+

articles/modeling/api-models.md

@@ -0,0 +1,37 @@
+# API Models
+An API model is a blueprint that identifies the requirements and proposed solution for an API development project. A well crafted API model indicates you understand the problem you are trying to solve. The following steps can help you get started with creating an excellent API model.
+
+## Identify Needs  
+During interactive sessions with stakeholders, outline all the requirements you want your API to meet . Some important questions to ask: 
+- What goal(s) do we want to achieve with the API?
+- Who are the principal users that will consume or interact with the API?
+- What activities will the users execute?
+- How can we group the activities into steps?
+- What are the API methods that are required for these steps? (Place the methods into common resource groups.)
+- What resources will the API expose? 
+- What permissions will we need? 
+This process may need to be repeated until the API development team is sure that all requirements are covered.
+
+## Build a Common Vocabulary 
+Vocabulary is used in your API artifacts such as your data fields, resource names, identifiers, and documentation. Creating a standard vocabulary helps you:
+- Communicate well with different audiences. 
+- Establish a standard or style guide  that can be adopted by members of the API development team.
+- Easily update your documentation.
+
+## Identify Resource Relationships 
+If your resources contain references to other resources or contain child resources, it is important to understand and define the types of relationships between resources because this will help you to show the link between the resources to the API user making the API more readable. Relationships can be:
+- **Dependent**: the resource cannot exist without a parent resource.
+- **Independent**: the resource can stand on its own and can reference another resource but does not need another resource to exist or function.
+- **Associative**: the resources are independent but the relationship includes or needs further properties to describe it.
+
+## Create a Test Plan
+Ensuring that your API meets predefined criteria requires testing. Design test plans early. Feasible tests you can execute include:
+- **Functional Testing**:  Test the API calls to ensure that it delivers or behaves as expected.  For example, you can test to see that the API delivers the expected data based on your model.
+- **Mocking** (service simulation): Mocking allows you to execute tests on an API deployment without calling it through a defined API key.  Effective API tools will allow you to test your API before implementation.
+- **Load Testing**: How will your API perform when deployed on a production server? A load test is one way to simulate the effect of traffic on your servers and observe the performance of your API when it is available to users. Doing a load test will help you understand your API threshold and if the users exceed the threshold.
+
+## Additional Notes
+- Create tests that match your use case. 
+- Discuss security issues during your modelling meetings with your team.
+- Ensure the test case is executed to see if the security issues are addressed before deployment. Click here to know more about security schemes and how to secure your API using best practices. 
+

articles/modeling/api-operations.md

@@ -0,0 +1,90 @@
+# API Operations
+## Introduction
+API operations describe the way you define how an API is exposed to a user. Properly defined operations are fundamental to the API development life cycle and the outcome is a final product that is easy to understand and use. Creating a properly designed RESTful API requires research, analysis, and planning. It is the API developer’s responsibility to ensure that the API design, resources, and connected operations are easy to understand by consumers. The following characteristics are true of well-designed APIs: 
+
+- Comprehensive, yet succinct 
+- Understandable and easy to use
+- Supports delta (incremental) development
+- Expedites and simplifies the API documentation process 
+
+## Key Terms
+- A **resource** is an entity or object that has data linked to it, relationships to other objects or entities, and a set of methods that operate on it to access, use, or manipulate the associated data. When resources are grouped together, it is called a collection. 
+- A **Uniform Resource Locator (URL)** is used to indicate and identify the location of an API resource and perform some actions to it. Note that the base URL is the constant part of this location. 
+- **GET** method requests data from a resource and the body of the response message holds the information requested.  
+- **PUT** method requests the server to update the resource or create it (if it does not exist) and the body of the request message indicates the resource to be updated or created.
+- **PATCH** method performs a partial update on a resource and the body of the request message indicates the change to be applied.  This can occasionally be more efficient than PUT because the client forwards changes required and not the entire details about the resource. 
+- **POST** creates a new resource and the body of the request message indicates the details of the new resource to be created. This method can be used to activate operations that will not create a resource.
+- **DELETE** method requests that the specified resource be removed.
+
+## Best Practices
+
+### Resource URL should be based on nouns and not verbs
+
+For example, to retrieve pet details for a pet store which has different kinds of pets:
+
+- /pets (Good) 
+- /getAllPets (Bad)
+
+<!-- theme: info -->
+> A good resource URL contains resources (nouns) and not actions or verbs. Ensure that the resource is in the plural form at the API endpoint.
+
+### Use HTTP methods to operate on resources
+
+To add, delete, or update information, use the HTTP methods GET, POST, DELETE, PUT, and PATCH (also known as verbs). For example:
+
+- GET /pets (returns the list of all pets)
+- GET /pets/5 (returns details of pet 5)
+
+<!-- theme: info -->
+> A successful GET method normally returns a HTTP status code of 200 (OK) and 404 (Not found) if the resource cannot be located.
+
+| GET                                   | PUT/PATCH                                     | POST                                | DELETE                                      | Resource               |
+|---------------------------------------|-----------------------------------------------|-------------------------------------|---------------------------------------------|------------------------|
+| Return list of all pets               | Update all pets                               | Add a new pet                       | Remove all pets                             | path/pets              |
+| Return details of treatment for pet 5 | Update all treatment for pet 5                | Add new treatment details for pet 5 | Remove all treatments associated with pet 5 | path/pets/5/treatments |
+| Returns details for pet 5             | Updates details for pet 5 assuming it exists  | Error (Not permitted)               | Deletes pet 5 details                       | path/pets/5            |
+
+### Make use of a Query String (?) for complex parameter optional parameters
+When you need to add more complexity and dynamics to the request, add parameters to the query string. For example:
+
+- GET /pets?type=feline&age=5 (Good)
+- getFelinePets (Bad)
+
+### Utilize HTTP Status Codes 
+A user should know the status of request made through an API. This might include failed, passed, or invalid responses. The table below summarizes the codes.
+
+| 2xx Success                                                             | 3xx Redirect          | 4xx Client Error | 5xx Server Error          |
+|-------------------------------------------------------------------------|-----------------------|------------------|---------------------------|
+| 200 Ok (Success for GET, PUT, or POST)                                  | 301 Moved Permanently | 400 Bad Request  | 550 Internal Server Error |
+| 201 Created                                                             | 304 Not Modified      | 401 Unauthorized |                           |
+| 204 No Content (Request successfully processed but returns not content) |                       | 403 Forbidden    |                           |
+|                                                                         |                       | 404 Not Found    |                           |
+
+- Be wary of using too many status codes and confusing the API user.
+- It is good to provide an additional description of the status code in the body of the HTTP Response. For example:
+    - Request: method GET /pets?type=feline
+    - Response: 
+```   
+   //This is an invalid request.
+    {
+    "message": "Invalid Pet Type please enter a valid pet category",
+    }
+```
+### Executing search, sort, filter and pagination operations 
+- When you need to perform these actions, you can append the query parameters to the GET method and the API endpoint. For example, to carry out a **search** operation for a particular pet:
+    - GET /pets?search=Blaze (This will search for a pet named Blaze)
+- **Pagination** helps you to manage the amount of resources you return and it is advisable to use the parameters offset and limit as shown in the example below:
+    - GET /pets?offset=10&limit=20 (Return pets between 10 to 20)
+- To **sort** the list of resources we can use multiple sort parameters in the query string. For example:
+     - GET /pets?sort=age_desc (Would sort the age in descending order.)
+- For **filtering** we can use one or more parameters in the query string. For example: 
+    - GET /pets?type=canine&age=7 
+
+<!-- theme: info -->
+>If too many query parameters are used in GET methods and the URL becomes too long, the server may return a ‘414 URL too long’ HTTP status. Parameters might be passed to the request body of a POST request as a solution to this challenge.
+
+### Versioning 
+It is good practice to version an API to describe the available features and resources it exposes. When this is properly done, the application consuming the API can submit explicit requests to a specific version of a feature or resource. For example, you can specify the version of the resource by means of a parameter within the query string affixed to the HTTP request: http://api.yourdomain.com/v2/pets/10/
+
+    
+

articles/modeling/build-api-library.md

@@ -0,0 +1 @@
+

articles/modeling/crud-builder.md

@@ -0,0 +1 @@
+

articles/modeling/duplication-refs.md

@@ -0,0 +1,129 @@
+# Preventing Duplications and Simplifying OAS Files 
+
+## What 
+- API resources often have or share similar features 
+- Duplicating features increase the size and complexity of your API
+- Reusable definitions make it easier to read, understand, and update your OAS files
+- Similar features can be created as reusable definitions and utilized with references
+- These definitions can be hosted on the same server as your OAS file or on a different server 
+- You can reference a definition hosted at any location or server 
+- Apart from defining reusable definitions, you can also define reusable responses and parameters. You can store your reusable definitions, responses, and parameters in a common library
+
+<!-- theme: info --> 
+>Key Terms: A definition is a named schema object. A reference is a path to a declaration within an OAS file.
+
+## How to Reference a Definition 
+To invoke a reference to a definition, use the **$ref** keyword. For example:
+```
+#/definitions/Pets ($ref: 'reference to definition')
+```
+
+## URL, Remote, and Local References 
+
+### General Syntax for URL Reference
+- Reference a complete document or resource located on a different server: 
+```
+$ref: 'http://url_resource_path'
+```
+- Reference a particular section of a resource stored on a different server: 
+```
+$ref: 'http://url_resource_path/document_name.json#section'
+```
+
+### General Syntax for Remote Reference
+- Reference a complete document or resource located on the same server and location: 
+```
+$ref:'document_name.json'
+```
+- Reference a particular section of a resource stored on a different server: 
+```
+$ref: 'document_name.json#section'
+```
+### General Syntax for Local Reference
+- Reference a resource found in the root of the current document and the definitions:
+```
+$ref: '#/definitions/section'
+```
+
+## Best Practices 
+- Only use $ref in locations specifed by the OpenAPI Specification 
+- Always enclose the value of your local reference in quotes (when using YAML syntax) to ensure it is not treated as a comment. For example:
+
+Good
+```
+"#/definitions/todo-partial"
+```
+Bad 
+```
+#/definitions/todo-partial
+```
+
+## Examples 
+- Assuming you have the following schema object named **Todo Partial** and you want to use it inside another definition: 
+
+```
+{
+  "title": "Todo Partial",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string" 
+    },
+    "completed": {
+      "type": [
+        "boolean",
+        "null"
+      ]
+    }
+  },
+  "required": [
+    "name",
+    "completed"
+  ]
+}
+```
+- To refer to that object, you need to add $ref with the corresponding path to your response: 
+
+```
+{
+  "title": "Todo Full",
+  "allOf": [
+    {
+      "$ref": "#/definitions/todo-partial" (Reference)
+    },
+    {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 1000000
+        },
+        "completed_at": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "format": "date-time"
+        },
+        "created_at": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "updated_at": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "user": {
+          "$ref: "https://exporter.stoplight.io/4568/master/common.oas2.yml#/definitions/user" (Reference)
+        }
+      },
+      "required": [
+        "id",
+        "user"
+      ]
+    }
+  ]
+}
+    
+

articles/modeling/generating-schemas.md

@@ -0,0 +1,61 @@
+# Generating Schema 
+
+## What 
+- A schema is metadata that defines the structure, properties, and relationships between data. It also defines the rules that must be adhered to and is usually in the form of a document. 
+- A structured approach is always recommended for handling and manipulating data. 
+- The "$ref" keyword is used to reference a schema. 
+
+## Why 
+- A schema definition makes the process of handling data more structured.
+- The process of validation and handling user input errors can be imprioved through the use of schemas. 
+- Schemas encourage the 'single source of truth' (single place to update a definition) concept which, among other things, makes it easier to create and maintain endpoints. 
+
+## Best Practices 
+- It is advisable to always use a schema when you define and implement your API.
+- Use schemas to rapidly extract titles, descriptions, and samples for easy API documentation. 
+
+## JSON Schema 
+- JSON (Javascript Object Notation) is a popular, human readable data format that is easy to parse at the server or client side. 
+- JSON Schema is a standard that contains information about the properties of a JSON object that can be used by an API. It also helps validate the structure of JSON data. 
+    -The properties include: name, title, type etc. 
+- JSON Schema Specification is divided into three parts: 
+  - **JSON Schema Core**: describes the basic foundation of JSON Schema
+  - **JSON Schema Validation**: describes methods that define validation constraints. It also describes a set of keywords that can be used to specify validations. 
+  - **JSON Hyper-Schema**: an extension of the JSON Schema Specification that defines hyperlink, images, and hypermedia-related keywords. 
+
+## Example 
+Assume you have an API that requires data provided in the format below: 
+
+```
+{
+  pets: [
+    {id:1 petName: "Blaze", petType: "Canine", age: 2},
+    {id: 2, petName: "Felicia", petType: "Feline", age: 1}
+    {id: 2, petName: "Bolt", petType: "Canine", age: 3}
+    
+  ]
+}
+```
+As seen above, each object in the pets array contains the following properties: id, petName, and petType. You can create a schema definition to validate the data and ensure it is in the expected format. The schema definition is outlined below: 
+
+```
+{
+  "type":"object",
+  "properties": {
+    "pets": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "id": {"type": "number"},
+          "petName": {"type": "string", "required": true},
+          "petType": {"type": "number", "required": true},
+          "age": {"type": "number"}
+        }
+      }
+    }
+  }
+}
+```
+### Related Articles 
+- [JSON Schema](http://json-schema.org/specification.html) 

articles/modeling/how-to-create-models.md

@@ -0,0 +1,85 @@
+# Models
+
+## What 
+A model contains common reusable information that can be referenced in your endpoint definitions or other models in your API design. The resources or endpoints in your API project might contain duplicate structures and response objects. Models reduce this duplication by helping you extract and define common resources making your project easier to maintain. 
+
+## Best Practices 
+
+### Avoid Cluttered APIs
+When you have several endpoints with the same structure, objects, and properties, your API design is untidy. Ensure that you extract reusable artifacts and build them as pragmatic models referenced by other resources within your API project. 
+
+### Use a Design First Approach
+A design first approach helps create neat and consistent models. It will take longer, but it ensures you built an effective API that is easy to understand and maintain. 
+
+## How to Create Models using the Stoplight Modeling Editor
+1. Create a new API project (link on how to create a new  project goes here)
+2. For this example we will be referring to endpoints created for a fictional Pet Store as listed below
+- GET  /pets (return all pets)
+- GET /pets{petid}  (return pet with  a specified id)
+- POST / pets  (enter pet information)
+- PUT  /pets{petid}  (update pet with a specified id)
+- DELETE /pets{petid} (delete pet with a specified id)
+3. The  GET  /pets method has an array of objects in the Response body with the following properties:
+
+```
+{ 
+    id, (string),
+    name, (string),
+    date _created (string, date format),
+    date_updated (string, date format),
+    approved (Boolean),
+    approved_by (string)
+}
+```
+
+4. The  GET  /pets {petid} method duplicates the objects above  with the same properties:
+
+```
+{ 
+    id, (string),
+    name, (string),
+    date _created (string, date format),
+    date_updated (string, date format),
+    approved (Boolean),
+    approved_by (string)
+}
+```
+
+5. The PUT / pets{petid}  method duplicates the object above in the Response body with a slight difference in the Request body which has the objects and properties below:
+ 
+ ```
+{ 
+    id, string,
+    approved boolean,
+    approved_by string
+}
+```
+
+<!-- theme:  info  -->
+>Duplication of Objects: If you are required to make changes you would have to update this information in three or more endpoints. Creating a model solves this issue.
+
+6. To create a model click on the + sign next to the Model section.
+
+![](../../assets/images/create-model.png)
+
+7. Enter the details for the key, title, and description fields
+
+![](../../assets/images/editor-details.png)
+
+8. Click on the Editor Tab to create the object and specify the properties you want in the model (You can also copy and paste the JSON Schema from an endpoint into the Raw Schema section of the model)
+
+![](../../assets/images/create-object.png)
+
+![](../../assets/images/model-design.png)
+
+9. Click the Save button to save the changes you have made in the editor 
+10. Select the GET  /pets {petid} (or any endpoint)  and navigate to Responses→ Editor 
+11. To reference the model in your endpoint, click on the object and select $ref as the array item type. Select the model you created from the drop down list
+
+![](../../assets/images/ref-model.png)
+
+12. Select the Viewer section to see the changes you have made
+
+![](../../assets/images/viewer-ref-model.png)
+
+13. All changes made to the properties of the object in the model are now automatically updated in all endpoints that make a reference to the model

articles/modeling/json-introduction.md

@@ -0,0 +1,25 @@
+# Introduction to Objects in API Document Structure 
+
+- An OpenAPI document is a document that describes an API and conforms to the OpenAPI Specification. These documents can be in YAML or JSON format. 
+- Your OpenAPI document can be a single document or a combination of several associated resources which use the $ref syntax to reference the interrelated resources. 
+
+## Primitive Data Objects Supported in an OpenAPI Document
+
+- integer (int32 and int64)
+- number (float and double) 
+- string 
+- byte
+- binary 
+- boolean 
+- date
+- dateTime
+- password 
+
+## Additional OpenAPI Objects 
+
+- **Info Object**: describes the API's title, description (optional), and version metadata. It also supports other details such as contact information, license, and terms of service. 
+- **Server Object**: identifies the API server and base URL. You can identify a single server or multiple servers and describe them using a description field. All API paths are relative to the URL of the server, for example, "/pets" when fully dilineated, may describe "http://api.hostname.com/pets." 
+- **Paths Object**: outlines relative paths to individual endpoints within your API and the operations or HTTP methods supported by the endpoints. For example, "GET/pets" can be used to return a list of pets. 
+- **Parameter Object**: describes a single operation parameter. Operations can have parameters passed through by several means such as: URL path, query string, cookies, and headers. Parameters can be marked as mandatory or optional, you can also describe the format, data type, and indicate its depreciation status. 
+- **Request body object**: describes body content and media type. It is often used with insert and update operations (POST, PUT, PATCH).
+- **Response object**: describes the expected response which can be referenced using the $ref syntax or described within the document. It associates an HTTP response code to the expected response. Examples of HTTP status codes incldue the 200-OK or 404-Not Found codes. [Click here for more information on HTTP Response codes](https://en.wikipedia.org/wiki/List_of_HTTP_status_codes).

articles/modeling/modeling-introduction.md

@@ -0,0 +1,32 @@
+# Modeling Introduction 
+
+![video/gif]()
+
+## What is API Design? 
+
+Designing (also known as Modeling) your API involves describing all of the inputs and outputs across the footprint of your entire service. Your API design will answer questions like: 
+
+- What are the different resources and operations available in your API?
+- How does your API authenticate requests? 
+- What are the different data models assoicated with your service? 
+- How does your API handle errors? 
+
+## How does it fit into Stoplight? 
+
+The Stoplight design module is where you and your team will maintain the single source of truth that describes the inputs and outputs of your API. 
+
+Once you have your API described in the Stoplight design module, you can: 
+
+- Publish all or part of your API in our Documentation service 
+- Create API tests from your designs 
+- Send requests to your API to debug it 
+- ...and much more 
+
+## Getting Started 
+
+There are a few ways to get started designing your API with the Stoplight design module, depending on how developed your API is:
+
+- Create an API from scratch [Using the CRUD Builder]()
+- [Reference another API Spec]()
+- [Send HTTP Requests]() to an existing API Spec 
+- [Validate your API Spec]()

articles/modeling/object-inheritance.md

@@ -0,0 +1,143 @@
+# Object Inheritance
+
+## What
+
+* A **model** contains properties that can be reused and referenced by endpoint
+  definitions, shared objects, and other models. For more information on what
+  models are and how they can be used, please see the API model overview
+  [here](./api-models.md).
+
+* **Inheritance** is when a model derives its properties from another model.
+
+* When a model inherits properties from another model, the model being inherited from is
+  known as a **base type** (or parent). A model that is inheriting
+  properties from a base type is known as a **derived type** (or child).
+
+* When a base type inherits properties from another model, any derived types
+  will also automatically inherit the properties as well. For example, if model
+  C is a derived type of model B, and model B is a derived type of model A, then
+  model C is also a derived type of model A. In mathematics, this is known as
+  the [transitive property](https://en.wikipedia.org/wiki/Transitive_relation).
+
+* To specify that a model should inherit from a base type, use the **allOf**
+  option (under "Combination Types") when building the model. By specifying
+  allOf and referencing the base type, the model will automatically inherit all
+  of the parent model's properties. A model can also inherit from multiple base
+  types as needed.
+
+## Why
+
+* Inheritance makes your API design more compact. It helps avoid duplication of
+  common properties and fields, reducing the complexity of the specification and the chance of errors.
+
+## Best Practices
+
+<!-- theme: info -->
+
+> Avoid using contradictory declarations such as declaring properties with the
+> same name but dissimilar data type in your base model and derived model.
+
+### Example
+
+As an example, imagine you are creating an API that stores and categorizes
+different types of vehicles. To begin working on the API, you will need a base
+"car" model with a few attributes that are common across all vehicles. This
+might look similar to:
+
+```javascript
+// the car base type
+{
+  "type": "object",
+  "properties": {
+    // number of wheels
+    "wheels": {
+      "type": "integer"
+    },
+    // number of doors
+    "doors": {
+      "type": "integer"
+    },
+    // brand of car
+    "make": {
+      "type": "string"
+    },
+    // model of car
+    "model": {
+      "type": "string"
+    }
+  }
+}
+```
+
+<!--FIXME Insert image of creating model from UI -->
+
+Now that we have a base type model, we now need a derived type that extends the
+base type. Since we're dealing with cars, let's create a model that defines a
+SUV type (or a Sport Utility Vehicle):
+
+```javascript
+// the SUV model
+{
+  "allOf": [
+    // a reference to the car base type
+    {
+      "$ref": "#/definitions/car"
+    },
+    // properties that are only applied to the SUV model
+    {
+      "type": "object",
+      "properties": {
+        // whether the vehicle can go "off road"
+        "off-road": {
+          "type": "boolean"
+        },
+        // the amount of ground clearance
+        "ground-clearance": {
+          "type": "integer"
+        }
+      }
+    }
+  ]
+}
+```
+
+<!--FIXME Insert image of creating derived model in UI -->
+
+As shown above, by wrapping our SUV model inside of an `allOf` block, we are
+able to include all of the properties that are included in the car base model
+above.
+
+When fully de-referenced (the car reference is replaced with the car
+properties), the derived SUV model will have the following JSON properties:
+
+```javascript
+{
+  "type": "object",
+  "properties": {
+    // number of wheels
+    "wheels": {
+      "type": "integer"
+    },
+    // number of doors
+    "doors": {
+      "type": "integer"
+    },
+    // brand of car
+    "make": {
+      "type": "string"
+    },
+    // model of car
+    "model": {
+      "type": "string"
+    },
+    // whether the vehicle can go "off road"
+    "off-road": {
+      "type": "boolean"
+    },
+    // the amount of ground clearance
+    "ground-clearance": {
+      "type": "integer"
+    }
+  }
+}
+```

articles/modeling/open-ended-objects.md

@@ -0,0 +1 @@
+

articles/modeling/openapi-validation.md

@@ -0,0 +1,38 @@
+# OpenAPI Validation
+
+![](../../assets/gifs/file-validation-oas-spec.gif)
+
+## What
+OpenAPI validation is the process of verifying the underlying OpenAPI file syntax by making sure it conforms to the [OpenAPI Specification requirements](https://github.com/OAI/OpenAPI-Specification#the-openapi-specification) provided by the [OpenAPI Initiative](https://www.openapis.org/). Stoplight immediately validates any changes done to a spec to ensure they are in the correct format prior to being saved.
+
+<!-- theme: info -->
+> Stoplight currently supports the OpenAPI v2 specification. We are working on support for OpenAPI v3, and should have more information in the coming months.
+
+## Why 
+- Validation promotes data integrity in your data store. For example, a user making updates during a PUT operation might omit data for an important property and overwrite valid data, compromising data integrity. 
+- Validations indicates that you are engaging in good design practice and your API design is consistent. 
+
+## Best Practices 
+- All requests made to an API should be validated before processing
+- Mark all mandatory properties as **Required** to ensure that the value of the property is provided 
+- Assign a default value to optional properties or parameters with missing values. The server will use the default value when a value is missing or not provided 
+- You can use the keyword **ReadOnly** to designate a property that can be sent in a response and should not be sent in a request
+
+<!-- theme: info -->
+> Using a default value is not recommended when a property or parameter is mandatory
+
+- An API can comsume different media types, the accepted media type can be specified using the **consume** keyword at the operational level or root level to define acceptable media types. For example: 
+
+```
+consumes: 
+multipart/form-data
+or
+consumes:
+application/json
+```
+- An HTTP response containing a user friendly error description is useful when validation fails
+***
+
+**Related**
+
+* [File Validation](../editor/file-validation.md)

articles/modeling/reference-spec.md

@@ -0,0 +1 @@
+

articles/modeling/security-schemes.md

@@ -0,0 +1,54 @@
+# API Security Schemes
+API security schemes protect your API resources by authenticating apps or users that consume your API. There are a number of standard authentication protocols you can pick from and each has their own strengths and weaknesses. To help you get started, the section below outlines some common schemes in use.
+
+## Authentication Schemes
+### Basic API Authentication
+- Easy to implement
+- Entails sending encoded username and password details
+- Usually bundled with standard framework or language library
+- Used with HTTPS, TLS or SSL
+- Can be combined with other security methods
+- **Note**: this method is susceptible to hijacks and man-in-the-middle attacks
+
+### OAuth1.0 (Digest Scheme)
+- Popular, tested, secure, signature driven, protocol
+- Uses cryptographic signature, which is a mix of token secret, nonce, and other request based information.
+- Can be used with or without SSL
+
+### OAuth2 (Bearer Token Scheme)
+- The current OAuth2 specification eliminates need for cryptographic signatures, passwords, and usernames.
+- OAuth2 works with authentication scenarios called flows, these flows include:
+    - Authorization Code flow
+    - Implicit flow
+    - Resource Owner Password flow
+    - Client Credentials flow
+- The OAuth 2.0 server will distribute access tokens that a client application will use to access protected resources.
+- [Additional Information on OAuth2.0](https://tools.ietf.org/html/rfc6749)
+
+### OpenID Connect Discovery
+- OpenID Connect Discovery (OIDC) is based on the OAuth 2.0 protocol.
+- Uses a sign-in flow that permits user authentication and information access by a client app.
+- The user information is encoded via a secure JSON Web Token (JWT). 
+- [Additional Information on OpenID Connect Discovery](https://openid.net/specs/openid-connect-discovery-1_0.html) 
+
+## Best Practices 
+### Implementing IDs
+Unique User IDs should be distinctive but not easy to decipher. 
+- Example: using ‘a12bc3’ is weak when compared to an ID that reads ‘09dgf659sjf038eyr3367dhrt34j5’. Avoid using auto increment for your Unique User IDs to reduce the likelihood of a security breach. 
+### Sensitive Information in HTTP Request 
+Ensure that your API will not expose important information such as password, API keys, and security tokens in the URL. For example, this URL is bad because it contains an API key: 
+- /baseurl/<uid>q=?apiKey=2123223223 
+### API Keys 
+Reduce the likelihood of exposing your API keys by keeping them in a file or storage mechanism that is accessible by the owner. 
+- **Note**: API Keys can be duplicated or lost so it is important to use other security measures apart from API keys. Consider encryption to make your API keys more secure. 
+  
+### Validation 
+It is beneficial to validate your inputs and access to resources using robust parsers. Parsing requests can help verify the validity of user requests. API designers can perform an implicit input validation to ensure the user inputs data with permitted characters, right syntax and character length. Using regular expressions can also help validate string inputs. If a request exceeds the defined limit, you can return a ‘413 Request Entity Too Large’ response code. 
+
+### Audit log 
+Create audit logs before and after security related events. You can also log validation errors to detect patterns or potential attacks.
+### HTTP Status Codes 
+Use status codes and proper error handling techniques for incoming requests to identify probable security risks.
+- [Additional Information on HTTP Status and Error Codes](https://en.wikipedia.org/wiki/List_of_HTTP_status_codes)
+
+

articles/modeling/sending-http-requests.md

@@ -0,0 +1 @@
+

articles/modeling/shared-params-responses.md

@@ -0,0 +1,194 @@
+# Shared Parameters and Responses
+
+While designing API's in Stoplight, it is common to have multiple endpoints
+share a set of query parameters and API responses. To help reduce extra
+work (and the chance of introducing errors), it is important to: 
+
+* Identify endpoints with common parameters 
+* Use _shared components_ to reference the same property multiple times instead
+  of rewriting the properties for each individual endpoint.
+
+Shared components in Stoplight come in two forms:
+
+* __Parameters__ - These are shared parameters that can be applied to requests
+  across multiple endpoints.
+
+* __Responses__ - These are shared response objects that can be applied to
+  multiple endpoints.
+
+## Parameters
+
+Shared parameters provide a way to use request properties across multiple API
+endpoints without having to duplicate effort.
+
+![](../../assets/gifs/shared-params-responses-param.gif)
+
+Shared parameters are supported in the following request property locations:
+
+  * __path__ - The request URL path
+  * __query__ - The request URL query string
+  * __header__ - The request HTTP Header field object
+  * __body__ - The request HTTP message body
+  * __form-data__ - The request HTTP message body in the `multipart/form-data` format 
+
+<!-- theme: info -->
+> For more information the above properties, see the [OpenAPI v2 Specification](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#parameter-object)
+
+Similar to generic request parameters, restrictions on the parameter values can
+also be applied based on type, expected default value, minimum/maximum length,
+and regular expression (regex).
+
+![](../../assets/images/shared-params-responses.png)
+
+To use a shared parameter, navigate to an API endpoint's _Request_ section and
+create a reference to the shared parameter using the "chain" button as shown in
+the image above. Once the parameter has been referenced, any updates to the
+shared parameter will automatically be propagated to every endpoint using that
+parameter.
+
+![](../../assets/gifs/shared-params-responses-param2.gif)
+
+Like other references in Stoplight, shared parameters can also be shared across
+files, projects, and other external sources.
+
+### Shared Parameters Example
+
+Let's say you are creating an API to serve thousands of cooking recipes. When dealing with large volumes of
+data, you typically want to avoid sending _all_ data in a request. To help avoid
+sending more data than is necessary, most applications implement a "paging"
+feature that allows clients to retrieve a small portion of results (i.e. a single
+page).
+
+There are multiple ways to approach a paging feature. For this example, we
+want to add two query string parameters to every request:
+
+* `limit` - The number of results to return when viewing a page. For example,
+  setting `limit` to `20` means that, at most, 20 results will be returned in the
+  request.
+* `offset` - The number of results to skip before returning results. For
+  example, setting an `offset` of `20` means that the API will discard the first
+  20 results.
+
+By using the two parameters above, a client can efficiently "page" through
+results, only returning items that are within the requested bounds. To demonstrate, let's use the parameters to display the first page of our recipe
+results:
+
+```
+GET /recipes?limit=20&offset=0
+```
+
+Since the `offset` is set to `0`, the API will not discard any results. Paired
+with a `limit` of `20`, we will only see the first 20 results (1 through 20). 
+
+To view the second page of recipes, we would use:
+
+```
+GET /recipes?limit=20&offset=20
+```
+
+By setting an `offset` of `20`, the API will discard the first 20 results. Paired
+again with a `limit` of `20`, we will see the second page of results (21 through
+40).
+
+### How
+Now that we know how we want the components to behave, let's create them in
+Stoplight. To get started, create a new shared parameter for an OpenAPI file
+under the "Shared" section of the menu.
+
+![](../../assets/images/shared-params-responses2.png)
+
+As shown in the image above, set the properties for each parameter based on our
+requirements:
+
+1. Be sure to set the display names for both components properly. In our
+   example, we only have two parameters, however, if there are multiple shared
+   parameters with similar names, you may want to set a more descriptive name
+   (i.e. 'recipe-limit' instead of 'limit').
+2. Since both components are query string parameters, set the property location
+   for each as 'query'.
+3. Set the name of the parameter, which is how it will be set in HTTP requests.
+4. Optional type restrictions can be applied to the values. In our case, since
+   both parameters are integer values, we can use the 'integer' format
+   restriction.
+5. Setting a default value can be useful if you don't need the client to specify
+   each parameter for every request. For our example, it makes sense to set
+   defaults that will return the first page (limit of 20, offset of 0).
+
+![](../../assets/images/shared-params-responses3.png)
+
+Once the shared parameters are created, reference them in any API endpoint under the
+__Query Parameters__ block of the request section in the editor.
+
+## Shared Responses
+
+Shared responses provide a practical way to re-use response objects across multiple API
+endpoints without having to duplicate effort. Similar to the shared components
+discussed above, shared responses allow you to reference a single response
+multiple times without having to recreate each response manually. The added
+benefit of this approach is that updates to the shared response object are
+automatically propagated to any endpoint using that object, no extra changes
+required.
+
+![](../../assets/gifs/shared-params-responses-response.gif)
+
+Shared responses allow you to configure the following properties:
+
+* Headers - Customize the HTTP Headers returned in the response
+* Response body - Customize the HTTP message body contents using the Stoplight
+  modeling tool (or reference a pre-existing model)
+
+<!-- theme: info -->
+> For more information on the above properties, see the OpenAPI v2 Specification
+  [here](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#responseObject)
+
+![](../../assets/gifs/shared-params-responses-response2.gif)
+
+To use a shared response, navigate to an API endpoint's __Response__ section and
+create a reference to the shared response by choosing the _Type_ of the response
+as "Reference". Once the Response type is set to "Reference", you can then
+choose the shared response to use for that endpoint. Shared responses can also
+be shared across files, projects, and other external sources.
+
+### Shared Responses Example
+
+Let's say you have a set of
+API endpoints that should return the same error response when a failure occurs.
+Every time an error is returned from the API, you want to make sure the
+following properties are returned:
+
+* `error_message` - A descriptive error message about the failure in string format.
+* `error_code` - A code representing the category of the failure in integer format.
+* `tracking_id` - A tracking ID that can be used by the caller to follow-up with
+  an administrator for more information (ie, debug an issue with customer
+  support).
+
+Now that we know what should be returned, let's create a shared response in
+Stoplight. To get started, create a new shared response for an OpenAPI file
+under the "Shared" section of the menu.
+
+![](../../assets/images/shared-params-responses4.png)
+
+As shown in the image above, set the properties for each portion of the response
+based on our requirements:
+
+1. Set the name of the shared response. In our example, we only have one error
+   type, however, if there are multiple error responses with similar names, you
+   may want to set a more descriptive name (ie, 'api-tracking-error' instead of
+   'error').
+2. A short description of the error response, such as why it is needed and how
+   it is used.
+3. The contents of the shared response object based on the three required
+   properties above.
+
+![](../../assets/images/shared-params-responses5.png)
+
+Once the shared response is created, it can be referenced in any API endpoint by
+using a _Reference_ type under a response. A shared response can also be used
+multiple times under the same endpoint.
+
+***
+
+**Related**
+
+* [OpenAPI v2 Parameter Objects Reference](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#parameter-object)
+* [OpenAPI v2 Response Objects Reference](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#responseObject)

articles/organizations/create-org.md

@@ -0,0 +1,18 @@
+# Create An Organization 
+
+![](../../assets/gifs/org-create.gif)
+
+## What 
+* Organizations are great for grouping people, data, and billing together in one convenient location 
+
+## Who 
+* Only the Billing **Owner** or Organization **Administrator** can create Organizations 
+
+## How 
+1. Click on **+ New**  to the right of Organizations 
+2. Fill in **Name** 
+    * We recommend using your company’s name
+3. Choose the path for your Organization (optional)    
+4. Add member by email (optional) 
+    * Input email accounts to add other members to your organization 
+        * You can also do this later 

articles/organizations/customize-org.md

@@ -0,0 +1,22 @@
+# Customize Your Organization 
+
+![](../../assets/gifs/org-settings.gif)
+
+## What 
+* Want to modify your Organization? In Stoplight you can modify your Organization's: 
+    * Name 
+    * Org Path 
+    * Add a Description 
+    * Add an Org Image 
+    
+## Who 
+* Only an Organization **Owner** or **Administrator** can modify Organizations  
+
+## How
+1. From the homepage, select the **Organization** you would like to modify 
+2. Select the **Settings** tab 
+3. Input a **Name** 
+4. Input a **Path** 
+5. Input a quick sentence about your organization 
+6. Select an **image** file for your Org 
+

articles/organizations/delete-org.md

@@ -0,0 +1,15 @@
+# Delete an Organization 
+
+![](../../assets/gifs/org-settings.gif)
+
+## What 
+* Deleting an organization is easy peasy, but once you delete an Org, there is no going back. Please be certain. 
+## Who 
+* Only the Organization’s **Owner** 
+## How
+1. From the homepage, select the **Organization** you would like to delete 
+2. Select the **Settings** tab 
+3. Scroll to the bottom of the page to the **Danger Zone**
+4. Click on **Delete this Org**
+5. Confirm the deletion by clicking okay on the proceeding popup 
+6. Wipe the tears from your eyes and say goodbye 

articles/organizations/managing-people.md

@@ -0,0 +1,17 @@
+# Invite People to an Organization
+
+![](../../assets/gifs/people-invite.gif)
+
+## What 
+* Adding people to your Organization is the first step towards collaboration within Stoplight
+
+## Who 
+* Only an Organization **Owner** or **Administrator** can invite people to an Organization 
+
+## How
+1. From the Stoplight homepage, select the **Organization** you would like to invite people to 
+2. Select the **People** tab from the tabs bar 
+3. Click **Invite Member** 
+4. In the popup that appears input email addresses or usernames 
+5. Hit **enter** to add them to your list 
+6. Once completed, click the **Invite** button 

articles/organizations/managing-teams.md

@@ -0,0 +1,13 @@
+# Managing Organization Teams
+
+## Creating a Team
+
+## Adding People to a Team
+
+## Removing People from a Team
+
+## Member Roles
+
+## Transferring Primary Ownership
+
+## Deleting a Team

articles/organizations/mention-people.md

@@ -0,0 +1 @@
+

articles/organizations/overview.md

@@ -0,0 +1,3 @@
+# Stoplight Organizations
+
+Testing a link to [projects](../projects/overview.md).

articles/organizations/remove-people.md

@@ -0,0 +1,17 @@
+# Remove People From Your Organization 
+
+![](../../assets/gifs/org-member-remove.gif)
+
+## What 
+* Removing a person for your organization is as easy as 123...4...5...6
+
+## Who 
+* Only an Organization **Owner** or  **Administrator** can modify
+
+## How 
+1. From the homepage, select the **Organization** you would like to modify 
+2. Select the **People** tab from the tab bar 
+3. Find the person you would like to remove from the list 
+4. To the right of the person’s name, click on the **dropdown arrow** to the left of the person’s role 
+5. In the dropdown menu that appears, select **Remove Member** 
+6. Click **Okay** in the popup prompt 

articles/organizations/roles.md

@@ -0,0 +1,23 @@
+# Organization Member Roles and Permissions 
+
+![](/assets/gifs/people-invite.gif)
+
+## What 
+* Roles and Permissions for members of Organizations can be managed and modified within Stoplight to control access to the Organization's functions and features 
+    * There are 3 Roles: 
+        * **Owner** 
+            * Owners can update the org, its connections, and its members 
+            * Has access to Billing and Organization Settings
+        * **Administrator** 
+            * Admins can update the org, its connections, and its members 
+        * **Member** 
+            * Members can update the org and its connections. They can view its members 
+
+## Who
+* Only an Organization **Owner** or **Administrator** can modify roles and permissions 
+## How 
+1. From the homepage, select the **Organization** you would like to modify 
+2. Select the **People** tab from the tab bar 
+3. Find the person you would like modify 
+4. To the right of their name click on the **down carrot** button to the left of the person’s role 
+5. In the dropdown menu select the desired role with accompanying permissions 

articles/organizations/transferring-ownership.md

@@ -0,0 +1,17 @@
+# Transfer Primary Ownership of Your Organization
+
+![](/assets/gifs/org-transfer.gif)
+ 
+## What 
+* You can promote another Member of your Organization to the role of Owner
+    * You can only transfer ownership to a Member of the Organization
+## Who 
+* Only the Organization **Owner** can transfer ownership of an Organization 
+## How
+1. From the homepage select the **Organization** you wish to modify 
+2. Select **People** from the tabs bar 
+3. Find the Member you would like to modify from the list 
+4. To the right of the Member’s name, click on the **down carrot** next to the Member’s current role 
+5. From the dropdown menu that expands, select **Owner** 
+6. You will then be asked to confirm your selection in a popup window
+7. Click **Ok** 

articles/prism/overview.md

@@ -0,0 +1,62 @@
+# Prism Introduction 
+
+Prism is a performant, dependency free server, built specifically to work with web APIs. 
+
+### Features 
+- Act as a mock server, routing incoming requests to example repsonses, or dynamically generating examples on the fly. 
+- Act as a transformation layer, manipulating incoming requests and outgoing responses. 
+- Act as a validation layer, validating incoming requests and outgoing responses. 
+- Contract test your APIs, given an OAS(Swagger 2) file. 
+- Log all or a subset of traffic to configurable locations. 
+- Extend existing APIs with new endpoints or capabilites. 
+- Act as a system-wide proxy, blocking traffic to particular websites or endpoints. 
+
+### Simplicity Redefined 
+Run it anywhere. It runs on OS X, Windows, and Linux, with no external dependencies. It is a single, self-contained binary file, that you can easily run from your terminal with a single command.  
+
+## Getting Started 
+
+#### macOS and Linux 
+
+```# Install Prism 
+curl https://raw.githubusercontent.com/stoplightio/prism/master.install.sh | sh
+```
+
+#### Windows 
+Download the appropriate binary from [here](https://github.com/stoplightio/prism/releases). Unzip the binary file, then navigate in your terminal to the folder where you extracted Prism. 
+
+### Run a Simple Mock Server 
+Prism understands OAS(Swagger 2), so let's get started by spinning up a quick mock server for the popular Petstore API. To do this, run the following command in your terminal: 
+
+```# os x / linux
+prism run --mock --list --spec http://petstore.swagger.io/v2/swagger.json
+
+# windows 
+path/to/prism.exe run --mock --list --spec http://petstore.swagger.io/v2/swagger.json
+```
+
+Here, you are using the "run" command to run a server based on the spec file passed in via the --spec argument. The spec location can be the filepath to a file on your computer, or the URL to a publicly hosted file. The --mock argument tells Prism to mock all incoming requests, instead of forwarding them to the API host described in the spec file. The --list argument is a convenience, and tells Prism to print out the endpoints in the spec on startup. 
+
+Prism starts on port 4010 by default - try visiting ```http://localhost:4010/v2/pet/findByStatus``` in your browser. This is one of the endpoints described in the petstore spec you passed in. You'll notice that it returns an error about a required query string parameter "status". This is the automatic request validation at work! The swagger spec specifies that a query string parameter names "status" is required for this endpoint so Prism simulates a 400 response for you. Reload the page with a query string parameter, and you will see the dynamically generated mock response ```http://localhost:4010/v2/pet/findByStatus?status=available```.
+
+Tada! With a single command you have started a validating, dynamically mocking version of the Swagger petstore API. 
+
+### Run some Contract Tests
+
+Prism consumes OAS(Swagger 2) files. OAS provides the contract for your API. If your OAS file contains the x-tests extension (generated automatically if you use the Stoplight app to manage your OAS and tests) then you can run tests with Prism.
+
+Check out [this specification](https://goo.gl/jniYmw). If you scroll past all the regular OAS properties, you will notice a ```x-tests``` extension near the bottom of the file. Inside of that property, we have a few test cases defined. This OAS file, along with its tests, is managed in the Stoplight app (we export our API from within the app to produce this file). 
+
+#### To Run the Contract Tests 
+```
+# os x / linux 
+prism test --spec https://goo.gl/jniYmw
+
+# windows
+path/to/prism.exe test --spec https://goo.gl/jniYmw
+```
+
+You should see some nice output to your terminal detailing the tests and assertions that are run. These tests take our OAS contract and apply it to your API. They act as a sort of sync manager. 
+
+<!-- theme: info -->
+> If a test fails, it means one of two things - your API is broken or, our OAS contract is out of date / incorrect 

articles/prism/run-prism-local.md

@@ -0,0 +1 @@
+

articles/prism/runtime.md

@@ -0,0 +1 @@
+

articles/prism/specification.md

@@ -0,0 +1 @@
+

articles/prism/validation.md

@@ -0,0 +1,4 @@
+
+<!--stackedit_data:
+eyJoaXN0b3J5IjpbLTE5Mzc0MDU2MjJdfQ==
+-->

articles/projects/change-member-role.md

@@ -0,0 +1,30 @@
+# Change a Project Member's Role
+
+![](/assets/gifs/project-member-invite.gif)
+ 
+## What 
+* You can invite people to a Project to grant them read or read/write permissions 
+* There are three tiers of read/write permissions 
+    * **Admin Access**: Upper level permissions that allow you to:
+        * Read/Write
+        * Invite and Manage Members and Teams
+        * Manage Project Settings
+        * Delete the project 
+    * **Write Access**: Mid-level permissions that allow you to: 
+        * Read/Write 
+    * **Read Access**: Low-level permissions that allow you to: 
+        * Read
+      
+   
+## 	 Who 
+* Only the Organization **Owner** and Org and/or Project **Administrators** can modify member roles
+
+## How
+1. From the Stoplight homepage select the **Project** you wish to modify 
+2. By deafult, all members of the Organization the Project is associated with will have Read permission 
+3. To invite a single member, select the **Member icon** from the far left sidebar
+    * Input their username in the search bar at the top of the Member sidebar
+    * Once located, press enter 
+4. To invite a team, select the **Team icon** from the far left sidebar
+    * Input the Team name in the search bar at the top of the Team sidebar 
+    * Once located, press enter 

articles/projects/collaboration.md

@@ -0,0 +1,7 @@
+# Project Collaboration
+
+## Roles
+
+## Inviting People & Teams to Projects
+
+## Changing People & Team Project Roles

articles/projects/create-project.md

@@ -0,0 +1,34 @@
+# Creating a Project  
+
+![](../../assets/gifs/project-create-personal.gif)
+
+## What 
+Projects are the workspace of the Stoplight Platform. Projects contain: 
+* File Explorer 
+* Project Governance 
+* Documentation Editor (Hubs)
+* Modeling Editor 
+* Testing (Scenarios) 
+* Mocking (Prism) 
+* Markdown Editor 
+
+<callout>Single Point of Truth All editors are now contained within a Project </>
+
+## Who 
+Individual users can create Personal Projects. Organizations can create Org Projects. 
+
+## How 
+
+### Personal Project
+1. From the homepage select the **Personal Project** tab 
+
+### Organization Project 
+1. From the homepage select the **Organization** you want to create a Project within
+	* By default you will land on Organization Projects 
+
+### Create a Project
+2. Input a **Project Name**
+3. Input a custom **Project Path** (optional)
+4. Input a **Project Description** (optional)
+5. Select **Public** or **Private** 
+6. Select **Create Project** once complete 

articles/projects/invite-people-team.md

@@ -0,0 +1,31 @@
+# Invite People & Teams to a Project
+
+![](../../assets/gifs/project-member-invite.gif)
+ 
+## What 
+* You can invite people to a Project to grant them read or read/write permissions 
+* There are three tiers of read/write permissions 
+    * **Admin Access**: Upper level permissions that allow you to:
+        * Read/Write
+        * Invite and Manage Members and Teams
+        * Manage Project Settings
+        * Delete the project 
+    * **Write Access**: Mid-level permissions that allow you to: 
+        * Read/Write 
+    * **Read Access**: Low-level permissions that allow you to: 
+        * Read
+      
+<callout>You can only invite people and Teams to a Project associated with an Organization</>
+   
+## 	 Who 
+* Only the Organization **Owner** and Org and/or Project **Administrators** have invite privileges 
+
+## How
+1. From your Organization's homepage, select the **Project** you wish to modify 
+2. By deafult, all members of the Organization the Project is associated with will have Read permission 
+3. To invite a single member, select the **Member icon** from the far left sidebar
+    * Input their username in the search bar at the top of the Member sidebar
+    * Once located, press enter 
+4. To invite a team, select the **Team icon** from the far left sidebar
+    * Input the Team name in the search bar at the top of the Team sidebar 
+    * Once located, press enter 

articles/projects/visibility.md

@@ -0,0 +1,14 @@
+## Making Your Project Private & Public
+
+![](../../assets/gifs/project-privacy.gif)
+
+## What 
+* You can choose to make your Project Public or Private 
+    * **Private**: Only designated collaborators will be able to read it. Additionally, connections from ALL dependent entities outside of this Organization will be removed 
+    * **Public**: Anyone can read it 
+## Who
+* Only the Organization **Owner** and Org and/or Project **Administrator** can modify
+## How
+1. Select the **Project** you wish to modify 
+2. Select the **gear icon** on the left hand sidebar 
+3. Under **Danger Zone** Select **Public** or **Private** 

articles/teams/add-people.md

@@ -0,0 +1,21 @@
+# Add People to a Team 
+
+![](../../assets/gifs/team-member-remove.gif)
+
+## What 
+
+* Adding people to a team lets you collaborate on projects while allowing an additional level of control over permissions.
+
+## Who 
+
+* Team **Owners**, **Administrators**, and **Members** can add people to a team 
+
+## How
+
+1. From the homepage select the **Organization** associated with the team 
+2. Select **Teams** on the tab bar
+3. Select the team that you would like to add people to.
+4. Click the **Invite Members** button
+5. Input the person’s email or Stoplight username in the textarea and press enter 
+    * Note: you can add more than one person at a time
+6. Once completed, click on the **Invite** button

articles/teams/create-team.md

@@ -0,0 +1,21 @@
+# Create a Team 
+
+![](../../assets/gifs/team-create.gif)
+
+## What 
+* Teams makes it easier for Organization Members to collaborate and allows additional control over permissions 
+
+## Who
+* Only an Organization **Owner** or **Administrator** can create a Team
+
+## How
+1. From the homepage, select the **Organization** you would like to make a team for 
+2. Select the **Teams** tab from the tabs bar 
+3. Create Your First Team 
+    * Input a **Team Name**(A department, project group, etc.)  
+    * Input a **Description** (What does this team do?) 
+    * Input **Members** (email or username)
+        * Send email notifications to invited members? (optional) 
+        * If the invited member does not already have a Stoplight account, an email will be sent with instructions on how to complete the account creation process 
+4. Click **Create Team** once finished 
+

articles/teams/customize-team.md

@@ -0,0 +1,21 @@
+# Customize a Team 
+
+![](../../assets/gifs/teamcustom.gif)
+
+## What 
+
+* You can customize the Team Name, Path, and Team Description 
+
+## Who 
+
+* Only Team **Owner** or **Administrator** can customize a Team
+
+## How
+
+1. From the homepage select the **Organization** associated with the Team you wish to modify 
+2. Select **Teams** from the tab bar 
+3. From the Teams homepage select the Team you wish to customize
+      * Then select **Team Settings** from the tab bar 
+          * Input a new Team Name in the textarea under **Team Name**
+          * Input a new Team URL in the textarea under **Path**
+          * Input a new Team Description in the textarea under **Description**   

articles/teams/delete-team.md

@@ -0,0 +1,14 @@
+# Delete a Team 
+
+![](../../assets/gifs/teamcustom.gif)
+
+## What 
+* Want to disband your team? Here's how: 
+## Who 
+* Only the Organization **Owner** or a Team **Owner** or **Administrator** can delete a team 
+## How 
+1. Select the **Organization** associated with the team you wish to modify 
+2. Select **Teams** from the tab bar 
+3. Click on the **red X icon** located to the right of the team you wish to delete 
+4. A popup will appear asking if you are sure you want to delete this team 
+5. Click **Ok** 

articles/teams/member-roles.md

@@ -0,0 +1,24 @@
+# Team Member Roles and Permissions
+
+![](/assets/gifs/team-member-remove.gif)
+
+ ## What 
+* Roles and Permissions for Team members can be managed and modified within Stoplight to control access to the Team’s functions and features 
+    * There are 3 Roles: 
+        * **Owner** 
+            * Owners can update the Team, its connections, and its collaborators. They can also update the team's settings and delete the team.
+        * **Administrator** 
+            * Admins can update the Team, its connections, and its collaborators. 
+        * **Member** 
+            * Members can view and create projects. They can view the Team's members.
+           
+## Who
+* Only the Team **Owner** or **Administrator** can modify Roles and Permissions 
+
+## How 
+1. From the homepage, select the **Organization** associated with the Team you would like to modify 
+2. Select the **Teams** tab from the tab bar 
+3. Select the Team you would like modify 
+4. To the right of the member’s name click on the **down carrot** button to the left of the person’s role 
+5. In the dropdown menu select the desired role with accompanying permissions 
+

articles/teams/remove-people.md

@@ -0,0 +1,22 @@
+# Remove People from a Team
+
+![](../../assets/gifs/team-member-remove.gif)
+ 
+## What 
+
+* Want to bench a member of your team? Here's how: 
+
+## Who 
+
+* Only the Team **Owner** or **Administrator** can remove people from a Team 
+
+## How 
+
+1. From the homepage select the **Organization** associated with the Team you wish to modify
+2. Select **Teams** from the tab bar 
+3. Select the Team you wish to modify from the list 
+4. Find the member of the team you wish to remove 
+5. To the right the member’s name click the **down carrot** 
+6. In the dropdown menu select **Remove Member** 
+7. A popup window will ask you to confirm your removal 
+    * Click Ok  

articles/teams/transfer-ownership.md

@@ -0,0 +1,16 @@
+# Transfer Primary Ownership of a Team 
+
+![](../../assets/gifs/team-transfer.gif)
+
+## What 
+* You can transfer Ownership of a Team to another member of the Team 
+## Who 
+* Only the Team **Owner** can transfer Ownership of a Team
+## How 
+1. From the homepage select the **Organization** that is associated with the Team you wish to modify 
+2. Select **Teams** from the tab bar 
+3. Select the Team you wish to modify 
+4. Find the Member of the Team you wish to transfer ownership to 
+5. Click on the **down carrot** to the right of the Member’s name 
+6. Select **Owner** from the dropdown menu 
+7. Click **Ok** in the proceeding popup 

articles/testing/adding-validations.md

@@ -0,0 +1 @@
+