Ed-Fi RFC 16 - Open API Spec

This page contains the full Open API spec listing for the proposed ED-FI RFC 16 - CORE STUDENT DATA API

Core Student Data API

{
  "swagger": "2.0",
  "info": {
    "version": "rfc16",
    "title": "Ed-Fi Core Student Data API",
    "description": "The Core Student Data API standard describes a REST API surface that covers the core data domains typically managed by student information systems in K–12 education. These standards can be used to drive analysis of student performance, both alone and in combination with data from other systems."
  },
  "basePath": "/",
  "consumes": [ "application/json" ],
  "produces": [ "application/json" ],
  "paths": {
    "/ed-fi/bellSchedules": {
      "get": {
        "tags": [ "bellSchedules" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getBellSchedules",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "bellScheduleName",
            "in": "query",
            "description": "Name or title of the BellSchedule.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 60
          },
          {
            "name": "schoolId",
            "in": "query",
            "description": "The identifier assigned to a school.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_bellSchedule" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "bellSchedules" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postBellSchedule",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "bellSchedule",
            "in": "body",
            "description": "The JSON representation of the \"bellSchedule\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_bellSchedule" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/bellSchedules/{id}": {
      "get": {
        "tags": [ "bellSchedules" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getBellSchedulesById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_bellSchedule" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "bellSchedules" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putBellSchedule",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "bellSchedule",
            "in": "body",
            "description": "The JSON representation of the \"bellSchedule\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_bellSchedule" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "bellSchedules" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteBellScheduleById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/calendars": {
      "get": {
        "tags": [ "calendars" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getCalendars",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "calendarCode",
            "in": "query",
            "description": "The identifier for the Calendar.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 60
          },
          {
            "name": "schoolId",
            "in": "query",
            "description": "The identifier assigned to a school.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "schoolYear",
            "in": "query",
            "description": "The identifier for the school year associated with the Calendar.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_calendar" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "calendars" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postCalendar",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "calendar",
            "in": "body",
            "description": "The JSON representation of the \"calendar\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_calendar" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/calendars/{id}": {
      "get": {
        "tags": [ "calendars" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getCalendarsById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_calendar" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "calendars" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putCalendar",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "calendar",
            "in": "body",
            "description": "The JSON representation of the \"calendar\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_calendar" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "calendars" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteCalendarById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/calendarDates": {
      "get": {
        "tags": [ "calendarDates" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getCalendarDates",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "date",
            "in": "query",
            "description": "The month, day, and year of the CalendarEvent.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "format": "date-time"
          },
          {
            "name": "calendarCode",
            "in": "query",
            "description": "The identifier for the Calendar.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 60
          },
          {
            "name": "schoolId",
            "in": "query",
            "description": "The identifier assigned to a school.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "schoolYear",
            "in": "query",
            "description": "The identifier for the school year associated with the Calendar.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_calendarDate" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "calendarDates" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postCalendarDate",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "calendarDate",
            "in": "body",
            "description": "The JSON representation of the \"calendarDate\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_calendarDate" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/calendarDates/{id}": {
      "get": {
        "tags": [ "calendarDates" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getCalendarDatesById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_calendarDate" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "calendarDates" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putCalendarDate",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "calendarDate",
            "in": "body",
            "description": "The JSON representation of the \"calendarDate\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_calendarDate" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "calendarDates" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteCalendarDateById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/classPeriods": {
      "get": {
        "tags": [ "classPeriods" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getClassPeriods",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "classPeriodName",
            "in": "query",
            "description": "An indication of the portion of a typical daily session in which students receive instruction in a specified subject (e.g., morning, sixth period, block period, or AB schedules).",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 60
          },
          {
            "name": "schoolId",
            "in": "query",
            "description": "The identifier assigned to a school.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_classPeriod" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "classPeriods" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postClassPeriod",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "classPeriod",
            "in": "body",
            "description": "The JSON representation of the \"classPeriod\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_classPeriod" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/classPeriods/{id}": {
      "get": {
        "tags": [ "classPeriods" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getClassPeriodsById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_classPeriod" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "classPeriods" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putClassPeriod",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "classPeriod",
            "in": "body",
            "description": "The JSON representation of the \"classPeriod\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_classPeriod" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "classPeriods" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteClassPeriodById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/cohorts": {
      "get": {
        "tags": [ "cohorts" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getCohorts",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "cohortIdentifier",
            "in": "query",
            "description": "The name or ID for the Cohort.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 20
          },
          {
            "name": "educationOrganizationId",
            "in": "query",
            "description": "The identifier assigned to an education organization.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_cohort" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "cohorts" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postCohort",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "cohort",
            "in": "body",
            "description": "The JSON representation of the \"cohort\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_cohort" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/cohorts/{id}": {
      "get": {
        "tags": [ "cohorts" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getCohortsById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_cohort" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "cohorts" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putCohort",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "cohort",
            "in": "body",
            "description": "The JSON representation of the \"cohort\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_cohort" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "cohorts" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteCohortById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/courses": {
      "get": {
        "tags": [ "courses" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getCourses",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "courseCode",
            "in": "query",
            "description": "A unique alphanumeric code assigned to a course.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 60
          },
          {
            "name": "educationOrganizationId",
            "in": "query",
            "description": "The identifier assigned to an education organization.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_course" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "courses" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postCourse",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "course",
            "in": "body",
            "description": "The JSON representation of the \"course\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_course" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/courses/{id}": {
      "get": {
        "tags": [ "courses" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getCoursesById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_course" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "courses" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putCourse",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "course",
            "in": "body",
            "description": "The JSON representation of the \"course\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_course" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "courses" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteCourseById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/courseOfferings": {
      "get": {
        "tags": [ "courseOfferings" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getCourseOfferings",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "localCourseCode",
            "in": "query",
            "description": "The local code assigned by the School that identifies the course offering provided for the instruction of students.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 60
          },
          {
            "name": "schoolId",
            "in": "query",
            "description": "The identifier assigned to a school.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "schoolYear",
            "in": "query",
            "description": "The identifier for the school year.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "sessionName",
            "in": "query",
            "description": "The identifier for the calendar for the academic session (e.g., 2010/11, 2011 Summer).",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 60
          },
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_courseOffering" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "courseOfferings" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postCourseOffering",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "courseOffering",
            "in": "body",
            "description": "The JSON representation of the \"courseOffering\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_courseOffering" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/courseOfferings/{id}": {
      "get": {
        "tags": [ "courseOfferings" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getCourseOfferingsById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_courseOffering" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "courseOfferings" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putCourseOffering",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "courseOffering",
            "in": "body",
            "description": "The JSON representation of the \"courseOffering\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_courseOffering" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "courseOfferings" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteCourseOfferingById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/courseTranscripts": {
      "get": {
        "tags": [ "courseTranscripts" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getCourseTranscripts",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "courseAttemptResultDescriptor",
            "in": "query",
            "description": "The result from the student's attempt to take the course, for example:          Pass          Fail          Incomplete          Withdrawn.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 306
          },
          {
            "name": "courseCode",
            "in": "query",
            "description": "A unique alphanumeric code assigned to a course.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 60
          },
          {
            "name": "courseEducationOrganizationId",
            "in": "query",
            "description": "The identifier assigned to an education organization.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "educationOrganizationId",
            "in": "query",
            "description": "The identifier assigned to an education organization.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "schoolYear",
            "in": "query",
            "description": "The identifier for the school year.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "studentUniqueId",
            "in": "query",
            "description": "A unique alphanumeric code assigned to a student.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 32
          },
          {
            "name": "termDescriptor",
            "in": "query",
            "description": "The term for the session during the school year.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 306
          },
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_courseTranscript" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "courseTranscripts" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postCourseTranscript",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "courseTranscript",
            "in": "body",
            "description": "The JSON representation of the \"courseTranscript\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_courseTranscript" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/courseTranscripts/{id}": {
      "get": {
        "tags": [ "courseTranscripts" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getCourseTranscriptsById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_courseTranscript" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "courseTranscripts" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putCourseTranscript",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "courseTranscript",
            "in": "body",
            "description": "The JSON representation of the \"courseTranscript\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_courseTranscript" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "courseTranscripts" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteCourseTranscriptById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/disciplineActions": {
      "get": {
        "tags": [ "disciplineActions" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getDisciplineActions",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "disciplineActionIdentifier",
            "in": "query",
            "description": "Identifier assigned by the education organization to the DisciplineAction.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 20
          },
          {
            "name": "disciplineDate",
            "in": "query",
            "description": "The date of the DisciplineAction.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "format": "date-time"
          },
          {
            "name": "studentUniqueId",
            "in": "query",
            "description": "A unique alphanumeric code assigned to a student.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 32
          }, 
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_disciplineAction" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "disciplineActions" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postDisciplineAction",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "disciplineAction",
            "in": "body",
            "description": "The JSON representation of the \"disciplineAction\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_disciplineAction" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/disciplineActions/{id}": {
      "get": {
        "tags": [ "disciplineActions" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getDisciplineActionsById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_disciplineAction" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "disciplineActions" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putDisciplineAction",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "disciplineAction",
            "in": "body",
            "description": "The JSON representation of the \"disciplineAction\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_disciplineAction" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "disciplineActions" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteDisciplineActionById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/disciplineIncidents": {
      "get": {
        "tags": [ "disciplineIncidents" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getDisciplineIncidents",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "incidentIdentifier",
            "in": "query",
            "description": "A locally assigned unique identifier (within the school or school district) to identify each specific DisciplineIncident or occurrence. The same identifier should be used to document the entire DisciplineIncident even if it included multiple offenses and multiple offenders.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 20
          },
          {
            "name": "schoolId",
            "in": "query",
            "description": "The identifier assigned to a school.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_disciplineIncident" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "disciplineIncidents" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postDisciplineIncident",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "disciplineIncident",
            "in": "body",
            "description": "The JSON representation of the \"disciplineIncident\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_disciplineIncident" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/disciplineIncidents/{id}": {
      "get": {
        "tags": [ "disciplineIncidents" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getDisciplineIncidentsById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_disciplineIncident" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "disciplineIncidents" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putDisciplineIncident",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "disciplineIncident",
            "in": "body",
            "description": "The JSON representation of the \"disciplineIncident\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_disciplineIncident" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "disciplineIncidents" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteDisciplineIncidentById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/grades": {
      "get": {
        "tags": [ "grades" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getGrades",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "gradeTypeDescriptor",
            "in": "query",
            "description": "The type of grade reported (e.g., Exam, Final, Grading Period).",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 306
          },
          {
            "name": "gradingPeriodDescriptor",
            "in": "query",
            "description": "The name of the period for which grades are reported.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 306
          },
          {
            "name": "gradingPeriodSequence",
            "in": "query",
            "description": "The sequential order of this period relative to other periods.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "schoolId",
            "in": "query",
            "description": "The identifier assigned to a school.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "gradingPeriodSchoolYear",
            "in": "query",
            "description": "The identifier for the grading period school year.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "beginDate",
            "in": "query",
            "description": "Month, day, and year of the Student's entry or assignment to the Section.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "format": "date-time"
          },
          {
            "name": "localCourseCode",
            "in": "query",
            "description": "The local code assigned by the School that identifies the course offering provided for the instruction of students.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 60
          },
          {
            "name": "schoolYear",
            "in": "query",
            "description": "The identifier for the school year.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "sectionIdentifier",
            "in": "query",
            "description": "The local identifier assigned to a section.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 255
          },
          {
            "name": "sessionName",
            "in": "query",
            "description": "The identifier for the calendar for the academic session (e.g., 2010/11, 2011 Summer).",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 60
          },
          {
            "name": "studentUniqueId",
            "in": "query",
            "description": "A unique alphanumeric code assigned to a student.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 32
          },
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_grade" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "grades" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postGrade",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "grade",
            "in": "body",
            "description": "The JSON representation of the \"grade\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_grade" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/grades/{id}": {
      "get": {
        "tags": [ "grades" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getGradesById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_grade" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "grades" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putGrade",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "grade",
            "in": "body",
            "description": "The JSON representation of the \"grade\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_grade" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "grades" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteGradeById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/gradingPeriods": {
      "get": {
        "tags": [ "gradingPeriods" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getGradingPeriods",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "gradingPeriodDescriptor",
            "in": "query",
            "description": "The name of the period for which grades are reported.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 306
          },
          {
            "name": "periodSequence",
            "in": "query",
            "description": "The sequential order of this period relative to other periods.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "schoolId",
            "in": "query",
            "description": "The identifier assigned to a school.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "schoolYear",
            "in": "query",
            "description": "The identifier for the grading period school year.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_gradingPeriod" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "gradingPeriods" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postGradingPeriod",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "gradingPeriod",
            "in": "body",
            "description": "The JSON representation of the \"gradingPeriod\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_gradingPeriod" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/gradingPeriods/{id}": {
      "get": {
        "tags": [ "gradingPeriods" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getGradingPeriodsById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_gradingPeriod" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "gradingPeriods" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putGradingPeriod",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "gradingPeriod",
            "in": "body",
            "description": "The JSON representation of the \"gradingPeriod\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_gradingPeriod" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "gradingPeriods" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteGradingPeriodById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/graduationPlans": {
      "get": {
        "tags": [ "graduationPlans" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getGraduationPlans",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "graduationPlanTypeDescriptor",
            "in": "query",
            "description": "The type of academic plan the student is following for graduation: for example, Minimum, Recommended, Distinguished, or Standard.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 306
          },
          {
            "name": "educationOrganizationId",
            "in": "query",
            "description": "The identifier assigned to an education organization.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "graduationSchoolYear",
            "in": "query",
            "description": "The school year the student is expected to graduate.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_graduationPlan" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "graduationPlans" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postGraduationPlan",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "graduationPlan",
            "in": "body",
            "description": "The JSON representation of the \"graduationPlan\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_graduationPlan" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/graduationPlans/{id}": {
      "get": {
        "tags": [ "graduationPlans" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getGraduationPlansById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_graduationPlan" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "graduationPlans" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putGraduationPlan",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "graduationPlan",
            "in": "body",
            "description": "The JSON representation of the \"graduationPlan\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_graduationPlan" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "graduationPlans" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteGraduationPlanById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/localEducationAgencies": {
      "get": {
        "tags": [ "localEducationAgencies" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getLocalEducationAgencies",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "localEducationAgencyId",
            "in": "query",
            "description": "The identifier assigned to a local education agency.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_localEducationAgency" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "localEducationAgencies" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postLocalEducationAgency",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "localEducationAgency",
            "in": "body",
            "description": "The JSON representation of the \"localEducationAgency\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_localEducationAgency" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/localEducationAgencies/{id}": {
      "get": {
        "tags": [ "localEducationAgencies" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getLocalEducationAgenciesById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_localEducationAgency" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "localEducationAgencies" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putLocalEducationAgency",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "localEducationAgency",
            "in": "body",
            "description": "The JSON representation of the \"localEducationAgency\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_localEducationAgency" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "localEducationAgencies" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteLocalEducationAgencyById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/locations": {
      "get": {
        "tags": [ "locations" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getLocations",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "classroomIdentificationCode",
            "in": "query",
            "description": "A unique number or alphanumeric code assigned to a room by a school, school system, state, or other agency or entity.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 20
          },
          {
            "name": "schoolId",
            "in": "query",
            "description": "The identifier assigned to a school.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_location" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "locations" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postLocation",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "location",
            "in": "body",
            "description": "The JSON representation of the \"location\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_location" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/locations/{id}": {
      "get": {
        "tags": [ "locations" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getLocationsById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_location" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "locations" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putLocation",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "location",
            "in": "body",
            "description": "The JSON representation of the \"location\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_location" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "locations" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteLocationById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/parents": {
      "get": {
        "tags": [ "parents" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getParents",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "parentUniqueId",
            "in": "query",
            "description": "A unique alphanumeric code assigned to a parent.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 32
          },
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_parent" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "parents" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postParent",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "parent",
            "in": "body",
            "description": "The JSON representation of the \"parent\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_parent" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/parents/{id}": {
      "get": {
        "tags": [ "parents" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getParentsById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_parent" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "parents" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putParent",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "parent",
            "in": "body",
            "description": "The JSON representation of the \"parent\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_parent" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "parents" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteParentById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/programs": {
      "get": {
        "tags": [ "programs" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getPrograms",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "programTypeDescriptor",
            "in": "query",
            "description": "The type of program.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 306
          },
          {
            "name": "programName",
            "in": "query",
            "description": "The formal name of the Program of instruction, training, services, or benefits available through federal, state, or local agencies.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 60
          },
          {
            "name": "educationOrganizationId",
            "in": "query",
            "description": "The identifier assigned to an education organization.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_program" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "programs" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postProgram",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "program",
            "in": "body",
            "description": "The JSON representation of the \"program\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_program" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/programs/{id}": {
      "get": {
        "tags": [ "programs" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getProgramsById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_program" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "programs" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putProgram",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "program",
            "in": "body",
            "description": "The JSON representation of the \"program\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_program" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "programs" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteProgramById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/schools": {
      "get": {
        "tags": [ "schools" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getSchools",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "schoolId",
            "in": "query",
            "description": "The identifier assigned to a school.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_school" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "schools" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postSchool",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "school",
            "in": "body",
            "description": "The JSON representation of the \"school\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_school" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/schools/{id}": {
      "get": {
        "tags": [ "schools" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getSchoolsById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_school" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "schools" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putSchool",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "school",
            "in": "body",
            "description": "The JSON representation of the \"school\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_school" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "schools" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteSchoolById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/schoolYearTypes": {
      "get": {
        "tags": [ "schoolYearTypes" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getSchoolYearTypes",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "schoolYear",
            "in": "query",
            "description": "Key for School Year",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_schoolYearType" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "schoolYearTypes" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postSchoolYearType",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "schoolYearType",
            "in": "body",
            "description": "The JSON representation of the \"schoolYearType\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_schoolYearType" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/schoolYearTypes/{id}": {
      "get": {
        "tags": [ "schoolYearTypes" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getSchoolYearTypesById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_schoolYearType" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "schoolYearTypes" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putSchoolYearType",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "schoolYearType",
            "in": "body",
            "description": "The JSON representation of the \"schoolYearType\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_schoolYearType" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "schoolYearTypes" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteSchoolYearTypeById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/sections": {
      "get": {
        "tags": [ "sections" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getSections",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "sectionIdentifier",
            "in": "query",
            "description": "The local identifier assigned to a section.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 255
          },
          {
            "name": "localCourseCode",
            "in": "query",
            "description": "The local code assigned by the School that identifies the course offering provided for the instruction of students.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 60
          },
          {
            "name": "schoolId",
            "in": "query",
            "description": "The identifier assigned to a school.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "schoolYear",
            "in": "query",
            "description": "The identifier for the school year.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "sessionName",
            "in": "query",
            "description": "The identifier for the calendar for the academic session (e.g., 2010/11, 2011 Summer).",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 60
          },
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_section" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "sections" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postSection",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "section",
            "in": "body",
            "description": "The JSON representation of the \"section\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_section" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/sections/{id}": {
      "get": {
        "tags": [ "sections" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getSectionsById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_section" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "sections" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putSection",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "section",
            "in": "body",
            "description": "The JSON representation of the \"section\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_section" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "sections" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteSectionById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/sessions": {
      "get": {
        "tags": [ "sessions" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getSessions",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "sessionName",
            "in": "query",
            "description": "The identifier for the calendar for the academic session (e.g., 2010/11, 2011 Summer).",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 60
          },
          {
            "name": "schoolId",
            "in": "query",
            "description": "The identifier assigned to a school.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "schoolYear",
            "in": "query",
            "description": "The identifier for the school year.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_session" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "sessions" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postSession",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "session",
            "in": "body",
            "description": "The JSON representation of the \"session\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_session" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/sessions/{id}": {
      "get": {
        "tags": [ "sessions" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getSessionsById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_session" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "sessions" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putSession",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "session",
            "in": "body",
            "description": "The JSON representation of the \"session\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_session" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "sessions" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteSessionById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/staffs": {
      "get": {
        "tags": [ "staffs" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getStaffs",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "staffUniqueId",
            "in": "query",
            "description": "A unique alphanumeric code assigned to a staff.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 32
          },
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_staff" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "staffs" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postStaff",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "staff",
            "in": "body",
            "description": "The JSON representation of the \"staff\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_staff" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/staffs/{id}": {
      "get": {
        "tags": [ "staffs" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getStaffsById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_staff" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "staffs" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putStaff",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "staff",
            "in": "body",
            "description": "The JSON representation of the \"staff\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_staff" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "staffs" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteStaffById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/staffCohortAssociations": {
      "get": {
        "tags": [ "staffCohortAssociations" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getStaffCohortAssociations",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "beginDate",
            "in": "query",
            "description": "Start date for the association of staff to this cohort.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "format": "date-time"
          },
          {
            "name": "cohortIdentifier",
            "in": "query",
            "description": "The name or ID for the Cohort.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 20
          },
          {
            "name": "educationOrganizationId",
            "in": "query",
            "description": "The identifier assigned to an education organization.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "staffUniqueId",
            "in": "query",
            "description": "A unique alphanumeric code assigned to a staff.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 32
          },
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_staffCohortAssociation" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "staffCohortAssociations" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postStaffCohortAssociation",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "staffCohortAssociation",
            "in": "body",
            "description": "The JSON representation of the \"staffCohortAssociation\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_staffCohortAssociation" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/staffCohortAssociations/{id}": {
      "get": {
        "tags": [ "staffCohortAssociations" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getStaffCohortAssociationsById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_staffCohortAssociation" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "staffCohortAssociations" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putStaffCohortAssociation",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "staffCohortAssociation",
            "in": "body",
            "description": "The JSON representation of the \"staffCohortAssociation\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_staffCohortAssociation" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "staffCohortAssociations" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteStaffCohortAssociationById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/staffEducationOrganizationAssignmentAssociations": {
      "get": {
        "tags": [ "staffEducationOrganizationAssignmentAssociations" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getStaffEducationOrganizationAssignmentAssociations",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "staffClassificationDescriptor",
            "in": "query",
            "description": "The titles of employment, official status, or rank of education staff.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 306
          },
          {
            "name": "beginDate",
            "in": "query",
            "description": "Month, day, and year of the start or effective date of a staff member's employment, contract, or relationship with the LEA.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "format": "date-time"
          },
          {
            "name": "educationOrganizationId",
            "in": "query",
            "description": "The identifier assigned to an education organization.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "staffUniqueId",
            "in": "query",
            "description": "A unique alphanumeric code assigned to a staff.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 32
          },
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_staffEducationOrganizationAssignmentAssociation" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "staffEducationOrganizationAssignmentAssociations" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postStaffEducationOrganizationAssignmentAssociation",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "staffEducationOrganizationAssignmentAssociation",
            "in": "body",
            "description": "The JSON representation of the \"staffEducationOrganizationAssignmentAssociation\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_staffEducationOrganizationAssignmentAssociation" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/staffEducationOrganizationAssignmentAssociations/{id}": {
      "get": {
        "tags": [ "staffEducationOrganizationAssignmentAssociations" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getStaffEducationOrganizationAssignmentAssociationsById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_staffEducationOrganizationAssignmentAssociation" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "staffEducationOrganizationAssignmentAssociations" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putStaffEducationOrganizationAssignmentAssociation",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "staffEducationOrganizationAssignmentAssociation",
            "in": "body",
            "description": "The JSON representation of the \"staffEducationOrganizationAssignmentAssociation\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_staffEducationOrganizationAssignmentAssociation" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "staffEducationOrganizationAssignmentAssociations" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteStaffEducationOrganizationAssignmentAssociationById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/staffSchoolAssociations": {
      "get": {
        "tags": [ "staffSchoolAssociations" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getStaffSchoolAssociations",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "programAssignmentDescriptor",
            "in": "query",
            "description": "The name of the program for which the individual is assigned; for example:          Regular education          Title I-Academic          Title I-Non-Academic          Special Education          Bilingual/English as a Second Language.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 306
          },
          {
            "name": "schoolId",
            "in": "query",
            "description": "The identifier assigned to a school.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "staffUniqueId",
            "in": "query",
            "description": "A unique alphanumeric code assigned to a staff.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 32
          },
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_staffSchoolAssociation" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "staffSchoolAssociations" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postStaffSchoolAssociation",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "staffSchoolAssociation",
            "in": "body",
            "description": "The JSON representation of the \"staffSchoolAssociation\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_staffSchoolAssociation" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/staffSchoolAssociations/{id}": {
      "get": {
        "tags": [ "staffSchoolAssociations" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getStaffSchoolAssociationsById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_staffSchoolAssociation" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "staffSchoolAssociations" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putStaffSchoolAssociation",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "staffSchoolAssociation",
            "in": "body",
            "description": "The JSON representation of the \"staffSchoolAssociation\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_staffSchoolAssociation" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "staffSchoolAssociations" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteStaffSchoolAssociationById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/staffSectionAssociations": {
      "get": {
        "tags": [ "staffSectionAssociations" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getStaffSectionAssociations",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "localCourseCode",
            "in": "query",
            "description": "The local code assigned by the School that identifies the course offering provided for the instruction of students.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 60
          },
          {
            "name": "schoolId",
            "in": "query",
            "description": "The identifier assigned to a school.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "schoolYear",
            "in": "query",
            "description": "The identifier for the school year.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "sectionIdentifier",
            "in": "query",
            "description": "The local identifier assigned to a section.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 255
          },
          {
            "name": "sessionName",
            "in": "query",
            "description": "The identifier for the calendar for the academic session (e.g., 2010/11, 2011 Summer).",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 60
          },
          {
            "name": "staffUniqueId",
            "in": "query",
            "description": "A unique alphanumeric code assigned to a staff.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 32
          },
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_staffSectionAssociation" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "staffSectionAssociations" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postStaffSectionAssociation",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "staffSectionAssociation",
            "in": "body",
            "description": "The JSON representation of the \"staffSectionAssociation\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_staffSectionAssociation" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/staffSectionAssociations/{id}": {
      "get": {
        "tags": [ "staffSectionAssociations" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getStaffSectionAssociationsById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_staffSectionAssociation" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "staffSectionAssociations" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putStaffSectionAssociation",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "staffSectionAssociation",
            "in": "body",
            "description": "The JSON representation of the \"staffSectionAssociation\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_staffSectionAssociation" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "staffSectionAssociations" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteStaffSectionAssociationById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/students": {
      "get": {
        "tags": [ "students" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getStudents",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "studentUniqueId",
            "in": "query",
            "description": "A unique alphanumeric code assigned to a student.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 32
          },
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_student" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "students" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postStudent",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "student",
            "in": "body",
            "description": "The JSON representation of the \"student\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_student" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/students/{id}": {
      "get": {
        "tags": [ "students" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getStudentsById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_student" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "students" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putStudent",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "student",
            "in": "body",
            "description": "The JSON representation of the \"student\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_student" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "students" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteStudentById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/studentAcademicRecords": {
      "get": {
        "tags": [ "studentAcademicRecords" ],
        "summary": "Retrieves specific resources using the resource's property values (using the \"Get\" pattern).",
        "description": "This GET operation provides access to resources using the \"Get\" search pattern.  The values of any properties of the resource that are specified will be used to return all matching results (if it exists).",
        "operationId": "getStudentAcademicRecords",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/offset" },
          { "$ref": "#/parameters/limit" },
          {
            "name": "termDescriptor",
            "in": "query",
            "description": "The term for the session during the school year.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 306
          },
          {
            "name": "educationOrganizationId",
            "in": "query",
            "description": "The identifier assigned to an education organization.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "schoolYear",
            "in": "query",
            "description": "The identifier for the school year.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "studentUniqueId",
            "in": "query",
            "description": "A unique alphanumeric code assigned to a student.",
            "required": false,
            "x-Ed-Fi-isIdentity": true,
            "type": "string",
            "maxLength": 32
          },
          {
            "name": "id",
            "in": "query",
            "description": "",
            "required": false,
            "type": "string"
          }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/edFi_studentAcademicRecord" }
            }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "post": {
        "tags": [ "studentAcademicRecords" ],
        "summary": "Creates or updates resources based on the natural key values of the supplied resource.",
        "description": "The POST operation can be used to create or update resources. In database terms, this is often referred to as an \"upsert\" operation (insert + update). Clients should NOT include the resource \"id\" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by \"id\"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.",
        "operationId": "postStudentAcademicRecord",
        "consumes": [ "application/json" ],
        "parameters": [
          {
            "name": "studentAcademicRecord",
            "in": "body",
            "description": "The JSON representation of the \"studentAcademicRecord\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_studentAcademicRecord" }
          }
        ],
        "responses": {
          "201": { "$ref": "#/responses/Created" },
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      }
    },
    "/ed-fi/studentAcademicRecords/{id}": {
      "get": {
        "tags": [ "studentAcademicRecords" ],
        "summary": "Retrieves a specific resource using the resource's identifier (using the \"Get By Id\" pattern).",
        "description": "This GET operation retrieves a resource by the specified resource identifier.",
        "operationId": "getStudentAcademicRecordsById",
        "produces": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          { "$ref": "#/parameters/If-None-Match" }
        ],
        "responses": {
          "200": {
            "description": "The requested resource was successfully retrieved.",
            "schema": { "$ref": "#/definitions/edFi_studentAcademicRecord" }
          },
          "304": { "$ref": "#/responses/NotModified" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "put": {
        "tags": [ "studentAcademicRecords" ],
        "summary": "Updates or creates a resource based on the resource identifier.",
        "description": "The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database.  If the resource \"id\" is provided in the JSON body, it will be ignored as well.",
        "operationId": "putStudentAcademicRecord",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the PUT from updating a resource modified by another consumer.",
            "type": "string"
          },
          {
            "name": "studentAcademicRecord",
            "in": "body",
            "description": "The JSON representation of the \"studentAcademicRecord\" resource to be created or updated.",
            "required": true,
            "schema": { "$ref": "#/definitions/edFi_studentAcademicRecord" }
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Updated" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { "$ref": "#/responses/Unauthorized" },
          "403": { "$ref": "#/responses/Forbidden" },
          "404": { "$ref": "#/responses/NotFound" },
          "409": { "$ref": "#/responses/Conflict" },
          "412": { "$ref": "#/responses/PreconditionFailed" },
          "500": { "$ref": "#/responses/Error" }
        }
      },
      "delete": {
        "tags": [ "studentAcademicRecords" ],
        "summary": "Deletes an existing resource using the resource identifier.",
        "description": "The DELETE operation is used to delete an existing resource by identifier. If the resource doesn't exist, an error will result (the resource will not be found).",
        "operationId": "deleteStudentAcademicRecordById",
        "consumes": [ "application/json" ],
        "parameters": [
          { "$ref": "#/parameters/id" },
          {
            "name": "If-Match",
            "in": "header",
            "description": "The ETag header value used to prevent the DELETE from removing a resource modified by another consumer.",
            "type": "string"
          }
        ],
        "responses": {
          "204": { "$ref": "#/responses/Deleted" },
          "400": { "$ref": "#/responses/BadRequest" },
          "401": { &