api.electiontonight.d.ts

Filename	Percent	Threshold	Total	Covered	Uncovered
src/api.electiontonight.d.ts	100.00%	80%	2457	2457	0

/**
 * [OpenAPI](https://www.openapis.org/) definition for the ElectionTonight API, converted to TypeScript types via [OpenAPI TypeScript](https://openapi-ts.pages.dev/).
 *
 * Gets the OpenAPI schema from the `open-api` endpoint:
 *
 * ```console
 * curl -X GET "https://api.electiontonight.com/v1/open-api" -H "x-api-key: <API_Key>"
 * ```
 *
 * @module
 */

export interface paths {
  '/events': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * Event list
     * @description Returns a list of events and initialization versions for which there is data in the /events/* endpoints.
     */
    get: {
      parameters: {
        query?: {
          /** @description The event id. */
          eventId?: string;
          /** @description Token identifiying the next page of results. Used when paging through data. */
          nextPage?: string;
          /** @description The number of records to return. */
          numRecords?: number;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/events/absentee-method': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * absentee-method doc(s).
     * @description Returns the absentee-method document(s).
     *
     *     Provides information on absentee reporting methods.
     */
    get: {
      parameters: {
        query: {
          /** @description The event id. */
          eventId: string;
          /** @description The initialization version of the events data. If no initversion is passed in the latest version will be returned. A list of initializations versions for events can be retrieved from the events/ endpoint. */
          initversion?: string;
          /** @description Token identifiying the next page of results. Used when paging through data. */
          nextPage?: string;
          /** @description The number of records to return. */
          numRecords?: number;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['absentee-method'][];
              /** @description A token identifying the next page. Pass this as the nextPage parameter into subsequent requests to page through a result set. */
              NextPage?: string;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/events/county-by-elec': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * county-by-elec doc(s).
     * @description Returns the county-by-elec document(s).
     *
     *     Contains information on the counties and county pieces covered in one election, whether that is a statewide election, an election in a Congressional District or other jurisdiction. Note that the total precincts given in this document are advisory only.  In rare cases, the total precincts may change on election night.
     */
    get: {
      parameters: {
        query: {
          /** @description Election type. Can be found in the events/election document */
          eType?: string;
          /** @description The event id. */
          eventId: string;
          /** @description The initialization version of the events data. If no initversion is passed in the latest version will be returned. A list of initializations versions for events can be retrieved from the events/ endpoint. */
          initversion?: string;
          /** @description Jurisdiction code. Can be found in the events/election document */
          jCde?: number;
          /** @description Jurisdiction type. Can be found in the events/election document */
          jType?: string;
          /** @description Token identifiying the next page of results. Used when paging through data. */
          nextPage?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['county-by-elec'][];
              /** @description A token identifying the next page. Pass this as the nextPage parameter into subsequent requests to page through a result set. */
              NextPage?: string;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/events/county-by-state': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * county-by-state doc(s).
     * @description Returns the county-by-state document(s).
     *
     *     Contains county data for a state.  Information on which counties or pieces of counties are in a particular election is contained in the county-by-elect document. The term pseudo county is used to define a piece of a county.  They may be used in some metropolitan areas where a county is split for reporting purposes (e.g. IL Cook county suburbs vs. City of Chicago). Note that the total precincts given in this document are advisory only.  In rare cases, the total precincts may change on election night.
     */
    get: {
      parameters: {
        query: {
          /** @description Election type. Can be found in the events/election document */
          eType?: string;
          /** @description The event id. */
          eventId: string;
          /** @description The initialization version of the events data. If no initversion is passed in the latest version will be returned. A list of initializations versions for events can be retrieved from the events/ endpoint. */
          initversion?: string;
          /** @description Token identifiying the next page of results. Used when paging through data. */
          nextPage?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['county-by-state'][];
              /** @description A token identifying the next page. Pass this as the nextPage parameter into subsequent requests to page through a result set. */
              NextPage?: string;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/events/delegate-district': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * delegate-district doc(s).
     * @description Returns the delegate-district document(s).
     *
     *     delegate-district document.
     *
     *     Describes districts used to report on a particular election. Districts will be linked to races through the race element of the election document
     */
    get: {
      parameters: {
        query: {
          /** @description Election type. Can be found in the events/election document */
          eType?: string;
          /** @description The event id. */
          eventId: string;
          /** @description The initialization version of the events data. If no initversion is passed in the latest version will be returned. A list of initializations versions for events can be retrieved from the events/ endpoint. */
          initversion?: string;
          /** @description Jurisdiction code. Can be found in the events/election document */
          jCde?: number;
          /** @description Jurisdiction type. Can be found in the events/election document */
          jType?: string;
          /** @description Token identifiying the next page of results. Used when paging through data. */
          nextPage?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['delegate-district'][];
              /** @description A token identifying the next page. Pass this as the nextPage parameter into subsequent requests to page through a result set. */
              NextPage?: string;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/events/delegate-district-type': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * delegate-district-type doc(s).
     * @description Returns the delegate-district-type document(s).
     *
     *     delegate-district-type document.
     *
     *     Describes districts used to report on a particular election.
     *     Districts will be linked to races through the race element of the election document
     */
    get: {
      parameters: {
        query: {
          /** @description The event id. */
          eventId: string;
          /** @description The initialization version of the events data. If no initversion is passed in the latest version will be returned. A list of initializations versions for events can be retrieved from the events/ endpoint. */
          initversion?: string;
          /** @description Token identifiying the next page of results. Used when paging through data. */
          nextPage?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['delegate-district-type'][];
              /** @description A token identifying the next page. Pass this as the nextPage parameter into subsequent requests to page through a result set. */
              NextPage?: string;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/events/election': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * election doc(s).
     * @description Returns the election document(s).
     *
     *     Contains research information on one election. It specifies past races of a specific election type for a given election date, state, and jurisdiction.
     */
    get: {
      parameters: {
        query: {
          /** @description Election type. Can be found in the events/election document */
          eType?: string;
          /** @description The event id. */
          eventId: string;
          /** @description The initialization version of the events data. If no initversion is passed in the latest version will be returned. A list of initializations versions for events can be retrieved from the events/ endpoint. */
          initversion?: string;
          /** @description Jurisdiction code. Can be found in the events/election document */
          jCde?: number;
          /** @description Jurisdiction type. Can be found in the events/election document */
          jType?: string;
          /** @description Token identifiying the next page of results. Used when paging through data. */
          nextPage?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['election'][];
              /** @description A token identifying the next page. Pass this as the nextPage parameter into subsequent requests to page through a result set. */
              NextPage?: string;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/events/election/race': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * election/race doc(s).
     * @description Returns the election/race document(s).
     *
     *     Contains information about races such as candidates and their parties.
     */
    get: {
      parameters: {
        query: {
          /** @description Election type. Can be found in the events/election document */
          eType?: string;
          /** @description The event id. */
          eventId: string;
          /** @description The initialization version of the events data. If no initversion is passed in the latest version will be returned. A list of initializations versions for events can be retrieved from the events/ endpoint. */
          initversion?: string;
          /** @description Jurisdiction code. Can be found in the events/election document */
          jCde?: number;
          /** @description Jurisdiction type. Can be found in the events/election document */
          jType?: string;
          /** @description Token identifiying the next page of results. Used when paging through data. */
          nextPage?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description Office code. Can be found in the events/election document */
          ofc?: string;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['election-race'][];
              /** @description A token identifying the next page. Pass this as the nextPage parameter into subsequent requests to page through a result set. */
              NextPage?: string;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/events/party-by-office': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * party-by-office doc(s).
     * @description Returns the party-by-office document(s).
     *
     *     Provides information needed to calculate change in power between the major parties for a given office.  This will be produced for the U.S. Senate, Governor, and U.S. House.
     */
    get: {
      parameters: {
        query: {
          /** @description The event id. */
          eventId: string;
          /** @description The initialization version of the events data. If no initversion is passed in the latest version will be returned. A list of initializations versions for events can be retrieved from the events/ endpoint. */
          initversion?: string;
          /** @description Token identifiying the next page of results. Used when paging through data. */
          nextPage?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description Office code. Can be found in the events/election document */
          ofc?: string;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['party-by-office'][];
              /** @description A token identifying the next page. Pass this as the nextPage parameter into subsequent requests to page through a result set. */
              NextPage?: string;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/events/party-lookup': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * party-lookup doc(s).
     * @description Returns the party-lookup document(s).
     *
     *     Provides information on the political parties.
     */
    get: {
      parameters: {
        query: {
          /** @description The event id. */
          eventId: string;
          /** @description The initialization version of the events data. If no initversion is passed in the latest version will be returned. A list of initializations versions for events can be retrieved from the events/ endpoint. */
          initversion?: string;
          /** @description Token identifiying the next page of results. Used when paging through data. */
          nextPage?: string;
          /** @description The number of records to return. */
          numRecords?: number;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['party-lookup'][];
              /** @description A token identifying the next page. Pass this as the nextPage parameter into subsequent requests to page through a result set. */
              NextPage?: string;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/events/past-county-data': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * past-county-data doc(s).
     * @description Returns the past-county-data document(s).
     *
     *     Provides historical vote counts by county.
     */
    get: {
      parameters: {
        query: {
          /** @description Election type. Can be found in the events/election document */
          eType?: string;
          /** @description The event id. */
          eventId: string;
          /** @description The initialization version of the events data. If no initversion is passed in the latest version will be returned. A list of initializations versions for events can be retrieved from the events/ endpoint. */
          initversion?: string;
          /** @description Jurisdiction code. Can be found in the events/election document */
          jCde?: number;
          /** @description Jurisdiction type. Can be found in the events/election document */
          jType?: string;
          /** @description Token identifiying the next page of results. Used when paging through data. */
          nextPage?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['past-county-data'][];
              /** @description A token identifying the next page. Pass this as the nextPage parameter into subsequent requests to page through a result set. */
              NextPage?: string;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/events/xtab-setup': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * xtab-setup doc(s).
     * @description Returns the xtab-setup document(s).
     *
     *     Each of these documents describes one xTab document that will be available on election day.  One xtab-setup document deals with a pre-defined set of exit poll cross tabulations for one race.  The optional subsets are for sending filtered data such as "Male Only", "Female Only", "New England", etc.
     */
    get: {
      parameters: {
        query: {
          /** @description Election type. Can be found in the events/election document */
          eType?: string;
          /** @description The event id. */
          eventId: string;
          /** @description The initialization version of the events data. If no initversion is passed in the latest version will be returned. A list of initializations versions for events can be retrieved from the events/ endpoint. */
          initversion?: string;
          /** @description Jurisdiction code. Can be found in the events/election document */
          jCde?: number;
          /** @description Jurisdiction type. Can be found in the events/election document */
          jType?: string;
          /** @description Token identifiying the next page of results. Used when paging through data. */
          nextPage?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description Office code. Can be found in the events/election document */
          ofc?: string;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['xtab-setup'][];
              /** @description A token identifying the next page. Pass this as the nextPage parameter into subsequent requests to page through a result set. */
              NextPage?: string;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/open-api': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * OpenAPI definition
     * @description Returns the OpenAPI definition of this API.
     */
    get: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/results/county-vote': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * Latest county-vote
     * @description Returns the latest county-vote documents for each document key.
     *
     *     Election day county vote documents. A vote document sends vote results for a single, unique contest. It can accommodate results at any level of granularity. Granularity is determined by the scp tag. Race-wide summaries are scp=S, county votes are scp=C.
     */
    get: {
      parameters: {
        query: {
          /** @description County number. Can be found in events/county-by-elec and events/county-by-state documents */
          cnty?: number;
          /** @description Election type. Can be found in the events/election document */
          eType?: string;
          /** @description The event id. */
          eventId: string;
          /** @description Jurisdiction code. Can be found in the events/election document */
          jCde?: number;
          /** @description Jurisdiction type. Can be found in the events/election document */
          jType?: string;
          /** @description The maximum document date time to return. Useful for viewing the state of an event at a particular time using the results endpoints or running compressed simulations using the streams endpoints.  */
          maxDateTime?: string;
          /** @description Token identifiying the next page of results. Used when paging through data. */
          nextPage?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description Office code. Can be found in the events/election document */
          ofc?: string;
          /** @description Scope of vote report. C=County, S=Summary */
          scp?: string;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['county-vote'][];
              /** @description A token identifying the next page. Pass this as the nextPage parameter into subsequent requests to page through a result set. */
              NextPage?: string;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/results/delegate-allocation': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * Latest delegate-allocation
     * @description Returns the latest delegate-allocation documents for each document key.
     *
     *     Election day delegate allocations
     */
    get: {
      parameters: {
        query: {
          /** @description District number. */
          dId?: number;
          /** @description Election type. Can be found in the events/election document */
          eType?: string;
          /** @description The event id. */
          eventId: string;
          /** @description Jurisdiction code. Can be found in the events/election document */
          jCde?: number;
          /** @description Jurisdiction type. Can be found in the events/election document */
          jType?: string;
          /** @description The maximum document date time to return. Useful for viewing the state of an event at a particular time using the results endpoints or running compressed simulations using the streams endpoints.  */
          maxDateTime?: string;
          /** @description Token identifiying the next page of results. Used when paging through data. */
          nextPage?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description Scope of vote report. C=County, S=Summary */
          scp?: string;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['delegate-allocation'][];
              /** @description A token identifying the next page. Pass this as the nextPage parameter into subsequent requests to page through a result set. */
              NextPage?: string;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/results/delegate-vote': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * Latest delegate-vote
     * @description Returns the latest delegate-vote documents for each document key.
     *
     *     Election day district vote documents.
     */
    get: {
      parameters: {
        query: {
          /** @description County number. Can be found in events/county-by-elec and events/county-by-state documents */
          cnty?: number;
          /** @description District number. */
          dId?: number;
          /** @description Election type. Can be found in the events/election document */
          eType?: string;
          /** @description The event id. */
          eventId: string;
          /** @description Jurisdiction code. Can be found in the events/election document */
          jCde?: number;
          /** @description Jurisdiction type. Can be found in the events/election document */
          jType?: string;
          /** @description The maximum document date time to return. Useful for viewing the state of an event at a particular time using the results endpoints or running compressed simulations using the streams endpoints.  */
          maxDateTime?: string;
          /** @description Token identifiying the next page of results. Used when paging through data. */
          nextPage?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['delegate-vote'][];
              /** @description A token identifying the next page. Pass this as the nextPage parameter into subsequent requests to page through a result set. */
              NextPage?: string;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/results/editorial-turnout': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * Latest editorial-turnout
     * @description Returns the latest editorial-turnout documents for each document key.
     *
     *     Contains the voting eligible population and optionally turnout as a percentage of the voting age population.
     */
    get: {
      parameters: {
        query: {
          /** @description Election type. Can be found in the events/election document */
          eType?: string;
          /** @description The event id. */
          eventId: string;
          /** @description Jurisdiction code. Can be found in the events/election document */
          jCde?: number;
          /** @description Jurisdiction type. Can be found in the events/election document */
          jType?: string;
          /** @description The maximum document date time to return. Useful for viewing the state of an event at a particular time using the results endpoints or running compressed simulations using the streams endpoints.  */
          maxDateTime?: string;
          /** @description Token identifiying the next page of results. Used when paging through data. */
          nextPage?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['editorial-turnout'][];
              /** @description A token identifying the next page. Pass this as the nextPage parameter into subsequent requests to page through a result set. */
              NextPage?: string;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/results/electoral-vote': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * Latest electoral-vote
     * @description Returns the latest electoral-vote documents for each document key.
     *
     *     Contains electoral vote allocations by candidate for a single, unique contest.
     */
    get: {
      parameters: {
        query: {
          /** @description Election type. Can be found in the events/election document */
          eType?: string;
          /** @description The event id. */
          eventId: string;
          /** @description Jurisdiction code. Can be found in the events/election document */
          jCde?: number;
          /** @description Jurisdiction type. Can be found in the events/election document */
          jType?: string;
          /** @description The maximum document date time to return. Useful for viewing the state of an event at a particular time using the results endpoints or running compressed simulations using the streams endpoints.  */
          maxDateTime?: string;
          /** @description Token identifiying the next page of results. Used when paging through data. */
          nextPage?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description Office code. Can be found in the events/election document */
          ofc?: string;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['electoral-vote'][];
              /** @description A token identifying the next page. Pass this as the nextPage parameter into subsequent requests to page through a result set. */
              NextPage?: string;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/results/est': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * Latest est
     * @description Returns the latest est documents for each document key.
     *
     *     An Estimate document contains ENS race calls for a single, unique contest. Within this document the cStat field will be set to either W for winner, R for reversal, or V for advances-to-runoff.
     */
    get: {
      parameters: {
        query: {
          /** @description Election type. Can be found in the events/election document */
          eType?: string;
          /** @description The event id. */
          eventId: string;
          /** @description Jurisdiction code. Can be found in the events/election document */
          jCde?: number;
          /** @description Jurisdiction type. Can be found in the events/election document */
          jType?: string;
          /** @description The maximum document date time to return. Useful for viewing the state of an event at a particular time using the results endpoints or running compressed simulations using the streams endpoints.  */
          maxDateTime?: string;
          /** @description Token identifiying the next page of results. Used when paging through data. */
          nextPage?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description Office code. Can be found in the events/election document */
          ofc?: string;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['est'][];
              /** @description A token identifying the next page. Pass this as the nextPage parameter into subsequent requests to page through a result set. */
              NextPage?: string;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/results/msg': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * Latest msg
     * @description Returns the latest msg documents for each document key.
     *
     *     Contains an election message from the EAS. Used to commumicate important information such as an increase in total expected vote or a weather problem that is delaying vote count collection.
     */
    get: {
      parameters: {
        query: {
          /** @description The event id. */
          eventId: string;
          /** @description The maximum document date time to return. Useful for viewing the state of an event at a particular time using the results endpoints or running compressed simulations using the streams endpoints.  */
          maxDateTime?: string;
          /** @description Token identifiying the next page of results. Used when paging through data. */
          nextPage?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['msg'][];
              /** @description A token identifying the next page. Pass this as the nextPage parameter into subsequent requests to page through a result set. */
              NextPage?: string;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/results/national-delegate-summary': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * Latest national-delegate-summary
     * @description Returns the latest national-delegate-summary documents for each document key.
     *
     *     National delegeate summary document. A summary of the delegate allocations for the current primary cycle.
     */
    get: {
      parameters: {
        query: {
          /** @description The event id. */
          eventId: string;
          /** @description The maximum document date time to return. Useful for viewing the state of an event at a particular time using the results endpoints or running compressed simulations using the streams endpoints.  */
          maxDateTime?: string;
          /** @description Token identifiying the next page of results. Used when paging through data. */
          nextPage?: string;
          /** @description The number of records to return. */
          numRecords?: number;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['national-delegate-summary'][];
              /** @description A token identifying the next page. Pass this as the nextPage parameter into subsequent requests to page through a result set. */
              NextPage?: string;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/results/total-expected-vote': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * Latest total-expected-vote
     * @description Returns the latest total-expected-vote documents for each document key.
     *
     *     Contains total expected vote estimate for a county and election. Also contains other information regarding the status of that counties total vote count.
     */
    get: {
      parameters: {
        query: {
          /** @description County number. Can be found in events/county-by-elec and events/county-by-state documents */
          cnty?: number;
          /** @description Election type. Can be found in the events/election document */
          eType?: string;
          /** @description The event id. */
          eventId: string;
          /** @description Jurisdiction code. Can be found in the events/election document */
          jCde?: number;
          /** @description Jurisdiction type. Can be found in the events/election document */
          jType?: string;
          /** @description The maximum document date time to return. Useful for viewing the state of an event at a particular time using the results endpoints or running compressed simulations using the streams endpoints.  */
          maxDateTime?: string;
          /** @description Token identifiying the next page of results. Used when paging through data. */
          nextPage?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['total-expected-vote'][];
              /** @description A token identifying the next page. Pass this as the nextPage parameter into subsequent requests to page through a result set. */
              NextPage?: string;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/results/xtab': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * Latest xtab
     * @description Returns the latest xtab documents for each document key.
     *
     *     This document contains the horizontal and vertical cross tabulation data for the voters in one of the contests covered by one survey. One survey, such as the survey for the Ohio Democratic Primary, may cover multiple contests (Pres and Gov), and therefore have multiple instances of this document
     */
    get: {
      parameters: {
        query: {
          /** @description Election type. Can be found in the events/election document */
          eType?: string;
          /** @description The event id. */
          eventId: string;
          /** @description Jurisdiction code. Can be found in the events/election document */
          jCde?: number;
          /** @description Jurisdiction type. Can be found in the events/election document */
          jType?: string;
          /** @description The maximum document date time to return. Useful for viewing the state of an event at a particular time using the results endpoints or running compressed simulations using the streams endpoints.  */
          maxDateTime?: string;
          /** @description Token identifiying the next page of results. Used when paging through data. */
          nextPage?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description Office code. Can be found in the events/election document */
          ofc?: string;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['xtab'][];
              /** @description A token identifying the next page. Pass this as the nextPage parameter into subsequent requests to page through a result set. */
              NextPage?: string;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/streams': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * Stream information
     * @description Returns a list of all the streams endpoints and their current max position.
     */
    get: {
      parameters: {
        query: {
          /** @description The event id. */
          eventId: string;
          /** @description The maximum document date time to return. Useful for viewing the state of an event at a particular time using the results endpoints or running compressed simulations using the streams endpoints.  */
          maxDateTime?: string;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['streams'][];
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/streams/county-vote': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * Stream of county-vote
     * @description Returns a stream of all of the county-vote documents. The position parameter is the stream pointer.
     *
     *     Election day county vote documents. A vote document sends vote results for a single, unique contest. It can accommodate results at any level of granularity. Granularity is determined by the scp tag. Race-wide summaries are scp=S, county votes are scp=C.
     */
    get: {
      parameters: {
        query: {
          /** @description County number. Can be found in events/county-by-elec and events/county-by-state documents */
          cnty?: number;
          /** @description Election type. Can be found in the events/election document */
          eType?: string;
          /** @description The event id. */
          eventId: string;
          /** @description Jurisdiction code. Can be found in the events/election document */
          jCde?: number;
          /** @description Jurisdiction type. Can be found in the events/election document */
          jType?: string;
          /** @description The maximum document date time to return. Useful for viewing the state of an event at a particular time using the results endpoints or running compressed simulations using the streams endpoints.  */
          maxDateTime?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description Office code. Can be found in the events/election document */
          ofc?: string;
          /** @description The stream pointer. Used to navigate a streams endpoint starting at position 0. The NextPosition is returned in the response. */
          position?: number;
          /** @description Scope of vote report. C=County, S=Summary */
          scp?: string;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['county-vote'][];
              /**
               * Format: int64
               * @description The stream pointer. To consume a stream, start at position 0 and pass in NextPosition as the position parameter to subsequent stream requests. When the end of stream has been reached, 0 documents will be returned and the NextPosition will be unchanged.
               */
              NextPosition?: number;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/streams/delegate-allocation': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * Stream of delegate-allocation
     * @description Returns a stream of all of the delegate-allocation documents. The position parameter is the stream pointer.
     *
     *     Election day delegate allocations
     */
    get: {
      parameters: {
        query: {
          /** @description District number. */
          dId?: number;
          /** @description Election type. Can be found in the events/election document */
          eType?: string;
          /** @description The event id. */
          eventId: string;
          /** @description Jurisdiction code. Can be found in the events/election document */
          jCde?: number;
          /** @description Jurisdiction type. Can be found in the events/election document */
          jType?: string;
          /** @description The maximum document date time to return. Useful for viewing the state of an event at a particular time using the results endpoints or running compressed simulations using the streams endpoints.  */
          maxDateTime?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description The stream pointer. Used to navigate a streams endpoint starting at position 0. The NextPosition is returned in the response. */
          position?: number;
          /** @description Scope of vote report. C=County, S=Summary */
          scp?: string;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['delegate-allocation'][];
              /**
               * Format: int64
               * @description The stream pointer. To consume a stream, start at position 0 and pass in NextPosition as the position parameter to subsequent stream requests. When the end of stream has been reached, 0 documents will be returned and the NextPosition will be unchanged.
               */
              NextPosition?: number;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/streams/delegate-vote': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * Stream of delegate-vote
     * @description Returns a stream of all of the delegate-vote documents. The position parameter is the stream pointer.
     *
     *     Election day district vote documents.
     */
    get: {
      parameters: {
        query: {
          /** @description County number. Can be found in events/county-by-elec and events/county-by-state documents */
          cnty?: number;
          /** @description District number. */
          dId?: number;
          /** @description Election type. Can be found in the events/election document */
          eType?: string;
          /** @description The event id. */
          eventId: string;
          /** @description Jurisdiction code. Can be found in the events/election document */
          jCde?: number;
          /** @description Jurisdiction type. Can be found in the events/election document */
          jType?: string;
          /** @description The maximum document date time to return. Useful for viewing the state of an event at a particular time using the results endpoints or running compressed simulations using the streams endpoints.  */
          maxDateTime?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description The stream pointer. Used to navigate a streams endpoint starting at position 0. The NextPosition is returned in the response. */
          position?: number;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['delegate-vote'][];
              /**
               * Format: int64
               * @description The stream pointer. To consume a stream, start at position 0 and pass in NextPosition as the position parameter to subsequent stream requests. When the end of stream has been reached, 0 documents will be returned and the NextPosition will be unchanged.
               */
              NextPosition?: number;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/streams/editorial-turnout': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * Stream of editorial-turnout
     * @description Returns a stream of all of the editorial-turnout documents. The position parameter is the stream pointer.
     *
     *     Contains the voting eligible population and optionally turnout as a percentage of the voting age population.
     */
    get: {
      parameters: {
        query: {
          /** @description Election type. Can be found in the events/election document */
          eType?: string;
          /** @description The event id. */
          eventId: string;
          /** @description Jurisdiction code. Can be found in the events/election document */
          jCde?: number;
          /** @description Jurisdiction type. Can be found in the events/election document */
          jType?: string;
          /** @description The maximum document date time to return. Useful for viewing the state of an event at a particular time using the results endpoints or running compressed simulations using the streams endpoints.  */
          maxDateTime?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description The stream pointer. Used to navigate a streams endpoint starting at position 0. The NextPosition is returned in the response. */
          position?: number;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['editorial-turnout'][];
              /**
               * Format: int64
               * @description The stream pointer. To consume a stream, start at position 0 and pass in NextPosition as the position parameter to subsequent stream requests. When the end of stream has been reached, 0 documents will be returned and the NextPosition will be unchanged.
               */
              NextPosition?: number;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/streams/electoral-vote': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * Stream of electoral-vote
     * @description Returns a stream of all of the electoral-vote documents. The position parameter is the stream pointer.
     *
     *     Contains electoral vote allocations by candidate for a single, unique contest.
     */
    get: {
      parameters: {
        query: {
          /** @description Election type. Can be found in the events/election document */
          eType?: string;
          /** @description The event id. */
          eventId: string;
          /** @description Jurisdiction code. Can be found in the events/election document */
          jCde?: number;
          /** @description Jurisdiction type. Can be found in the events/election document */
          jType?: string;
          /** @description The maximum document date time to return. Useful for viewing the state of an event at a particular time using the results endpoints or running compressed simulations using the streams endpoints.  */
          maxDateTime?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description Office code. Can be found in the events/election document */
          ofc?: string;
          /** @description The stream pointer. Used to navigate a streams endpoint starting at position 0. The NextPosition is returned in the response. */
          position?: number;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['electoral-vote'][];
              /**
               * Format: int64
               * @description The stream pointer. To consume a stream, start at position 0 and pass in NextPosition as the position parameter to subsequent stream requests. When the end of stream has been reached, 0 documents will be returned and the NextPosition will be unchanged.
               */
              NextPosition?: number;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/streams/est': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * Stream of est
     * @description Returns a stream of all of the est documents. The position parameter is the stream pointer.
     *
     *     An Estimate document contains ENS race calls for a single, unique contest. Within this document the cStat field will be set to either W for winner, R for reversal, or V for advances-to-runoff.
     */
    get: {
      parameters: {
        query: {
          /** @description Election type. Can be found in the events/election document */
          eType?: string;
          /** @description The event id. */
          eventId: string;
          /** @description Jurisdiction code. Can be found in the events/election document */
          jCde?: number;
          /** @description Jurisdiction type. Can be found in the events/election document */
          jType?: string;
          /** @description The maximum document date time to return. Useful for viewing the state of an event at a particular time using the results endpoints or running compressed simulations using the streams endpoints.  */
          maxDateTime?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description Office code. Can be found in the events/election document */
          ofc?: string;
          /** @description The stream pointer. Used to navigate a streams endpoint starting at position 0. The NextPosition is returned in the response. */
          position?: number;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['est'][];
              /**
               * Format: int64
               * @description The stream pointer. To consume a stream, start at position 0 and pass in NextPosition as the position parameter to subsequent stream requests. When the end of stream has been reached, 0 documents will be returned and the NextPosition will be unchanged.
               */
              NextPosition?: number;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/streams/msg': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * Stream of msg
     * @description Returns a stream of all of the msg documents. The position parameter is the stream pointer.
     *
     *     Contains an election message from the EAS. Used to commumicate important information such as an increase in total expected vote or a weather problem that is delaying vote count collection.
     */
    get: {
      parameters: {
        query: {
          /** @description The event id. */
          eventId: string;
          /** @description The maximum document date time to return. Useful for viewing the state of an event at a particular time using the results endpoints or running compressed simulations using the streams endpoints.  */
          maxDateTime?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description The stream pointer. Used to navigate a streams endpoint starting at position 0. The NextPosition is returned in the response. */
          position?: number;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['msg'][];
              /**
               * Format: int64
               * @description The stream pointer. To consume a stream, start at position 0 and pass in NextPosition as the position parameter to subsequent stream requests. When the end of stream has been reached, 0 documents will be returned and the NextPosition will be unchanged.
               */
              NextPosition?: number;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/streams/national-delegate-summary': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * Stream of national-delegate-summary
     * @description Returns a stream of all of the national-delegate-summary documents. The position parameter is the stream pointer.
     *
     *     National delegeate summary document. A summary of the delegate allocations for the current primary cycle.
     */
    get: {
      parameters: {
        query: {
          /** @description The event id. */
          eventId: string;
          /** @description The maximum document date time to return. Useful for viewing the state of an event at a particular time using the results endpoints or running compressed simulations using the streams endpoints.  */
          maxDateTime?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description The stream pointer. Used to navigate a streams endpoint starting at position 0. The NextPosition is returned in the response. */
          position?: number;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['national-delegate-summary'][];
              /**
               * Format: int64
               * @description The stream pointer. To consume a stream, start at position 0 and pass in NextPosition as the position parameter to subsequent stream requests. When the end of stream has been reached, 0 documents will be returned and the NextPosition will be unchanged.
               */
              NextPosition?: number;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/streams/total-expected-vote': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * Stream of total-expected-vote
     * @description Returns a stream of all of the total-expected-vote documents. The position parameter is the stream pointer.
     *
     *     Contains total expected vote estimate for a county and election. Also contains other information regarding the status of that counties total vote count.
     */
    get: {
      parameters: {
        query: {
          /** @description County number. Can be found in events/county-by-elec and events/county-by-state documents */
          cnty?: number;
          /** @description Election type. Can be found in the events/election document */
          eType?: string;
          /** @description The event id. */
          eventId: string;
          /** @description Jurisdiction code. Can be found in the events/election document */
          jCde?: number;
          /** @description Jurisdiction type. Can be found in the events/election document */
          jType?: string;
          /** @description The maximum document date time to return. Useful for viewing the state of an event at a particular time using the results endpoints or running compressed simulations using the streams endpoints.  */
          maxDateTime?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description The stream pointer. Used to navigate a streams endpoint starting at position 0. The NextPosition is returned in the response. */
          position?: number;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['total-expected-vote'][];
              /**
               * Format: int64
               * @description The stream pointer. To consume a stream, start at position 0 and pass in NextPosition as the position parameter to subsequent stream requests. When the end of stream has been reached, 0 documents will be returned and the NextPosition will be unchanged.
               */
              NextPosition?: number;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  '/streams/xtab': {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /**
     * Stream of xtab
     * @description Returns a stream of all of the xtab documents. The position parameter is the stream pointer.
     *
     *     This document contains the horizontal and vertical cross tabulation data for the voters in one of the contests covered by one survey. One survey, such as the survey for the Ohio Democratic Primary, may cover multiple contests (Pres and Gov), and therefore have multiple instances of this document
     */
    get: {
      parameters: {
        query: {
          /** @description Election type. Can be found in the events/election document */
          eType?: string;
          /** @description The event id. */
          eventId: string;
          /** @description Jurisdiction code. Can be found in the events/election document */
          jCde?: number;
          /** @description Jurisdiction type. Can be found in the events/election document */
          jType?: string;
          /** @description The maximum document date time to return. Useful for viewing the state of an event at a particular time using the results endpoints or running compressed simulations using the streams endpoints.  */
          maxDateTime?: string;
          /** @description The number of records to return. */
          numRecords?: number;
          /** @description Office code. Can be found in the events/election document */
          ofc?: string;
          /** @description The stream pointer. Used to navigate a streams endpoint starting at position 0. The NextPosition is returned in the response. */
          position?: number;
          /** @description Comma seperated list of state numbers */
          st?: number[];
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successful response */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            'application/json': {
              Documents?: components['schemas']['xtab'][];
              /**
               * Format: int64
               * @description The stream pointer. To consume a stream, start at position 0 and pass in NextPosition as the position parameter to subsequent stream requests. When the end of stream has been reached, 0 documents will be returned and the NextPosition will be unchanged.
               */
              NextPosition?: number;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
}
export type webhooks = Record<string, never>;
export interface components {
  schemas: {
    /**
     * @description Defines a strata type.
     *           P - Party
     *           G - Geographic
     *
     * @enum {string}
     */
    ENSStrataType: 'P' | 'G';
    /** @description Calculations from computations with OVN attributes */
    ENSCompCalcWithOVN: components['schemas']['ENSOVNCounts'] &
      components['schemas']['ENSCompCalc'] &
      components['schemas']['ENSTabCounts'];
    ENSEstimatorKeyTypeJson: {
      estType: components['schemas']['ENSEstimatorType'];
      model: components['schemas']['ENSCompModelType'];
      strataType: components['schemas']['ENSStrataType'];
      pastRace?: components['schemas']['ENSRaceKeyTypeJson'];
    };
    /** @description Jurisdiction-type and jurisdiction-code, along with state code, specify a unique jurisdiction for a contest. Sample codes to the left may not document all possible types. Some, but not all, possible codes are NR (national region), SW (statewide), CD (congressional district), CI (city) */
    ENSJurisdictionTypeType: string;
    /**
     * @description Reporting source (E=EMR, S=Sec. of State, O=Other)
     * @enum {string}
     */
    ENSReportingSourceType: 'E' | 'S' | 'O';
    /** @description Used to represent values between 0-99999999999 */
    ENSHugeNumberTypeJson: number | null;
    /** @description Total expected vote values */
    ENSTotalExpectedVote: {
      /**
       * Format: integer
       * @description Total expected vote
       */
      totalExpVote?: number;
      /**
       * Format: integer
       * @description Percent of reported vote based on TEV(total expected vote)
       */
      totalExpVotePct?: number;
    };
    /**
     * @description Male, Female, or blank if not set in database
     * @enum {string}
     */
    ENSCandGenderType: 'M' | 'F' | '';
    /** @description Vote method model output for per-stratum calculations */
    ENSVMMStrataInfoType: {
      /** @description stratum level counts and estimates */
      candidates?: components['schemas']['ENSCandidateEstForVoteMethodModel'];
      /** @description Collapse strata (when there is collapsing) */
      clpse?: string;
      /**
       * Format: float
       * @description Curr size percentage
       */
      currSize?: number;
      eday?: components['schemas']['ENSInAndOfCMCounts'] &
        components['schemas']['ENSCompCalcWithOVN'];
      /**
       * Format: float
       * @description Past size percentage
       */
      pastSize?: number;
      earlyInPerson?: components['schemas']['ENSInAndOfCMCounts'] &
        components['schemas']['ENSCompCalcWithOVN'];
      total?: components['schemas']['ENSInAndOfCMCounts'] &
        components['schemas']['ENSCompCalcWithOVN'];
      earlyByMail?: components['schemas']['ENSInAndOfCMCounts'] &
        components['schemas']['ENSCompCalcWithOVN'];
      totalEarly?: components['schemas']['ENSInAndOfCMCounts'] &
        components['schemas']['ENSCompCalcWithOVN'];
      strmCde?: components['schemas']['ENSSmallNumberType'];
      /** @description Total counties reporting in stratum */
      numCntys?: components['schemas']['ENSNumberType'];
    };
    ENSPctNumberType: number;
    /** @description County Precinct Model Strata definition */
    ENSCPMStrataInfoType: {
      /** @description Total precincts in stratum */
      totPcts?: components['schemas']['ENSNumberType'];
      /** @description Total counties reporting in stratum */
      cntyOf?: components['schemas']['ENSNumberType'];
      /** @description stratum level counts and estimates */
      candidates?: components['schemas']['ENSCandidateForCPM'];
      /** @description Collapse strata (when there is collapsing) */
      clpse?: string;
      /**
       * Format: float
       * @description Percent Precincts Reporting
       */
      pcntRepPcnt?: number;
      /**
       * Format: float
       * @description Curr size percentage
       */
      currSize?: number;
      /**
       * Format: integer
       * @description County precinct model only
       */
      pctsRep?: number;
      /**
       * Format: float
       * @description Past size percentage
       */
      pastSize?: number;
      total?: components['schemas']['ENSInAndOfCMCounts'] &
        components['schemas']['ENSCompCalcWithOVN'];
      /**
       * Format: integer
       * @description stratum
       */
      strmCde?: number;
      /**
       * Format: integer
       * @description Total Counties Reporting
       */
      countiesIn?: number;
      /**
       * Format: integer
       * @description Total precincts unmatched
       */
      pctsUnmatched?: number;
    };
    /**
     * @description Suspend/Stop indicator
     * @enum {string}
     */
    ENSShutdownStatusType: 'Suspend' | 'Stop';
    /**
     * @description Defines the process status of Exit Poll Call.
     *           ALL (New Completed Call Document)
     *           BEG (New Document of Data Entry In Progress)
     *           MID (Continuation of Document of Data Entry In Progress)
     *           SPD (Call as been temporarily suspended)
     *           END (Completion of Data Entry in Progress Document)
     *
     * @enum {string}
     */
    CallStatusType: 'ALL' | 'BEG' | 'MID' | 'SPD' | 'END';
    /** @description Candidate id - unique number, within election year, for each candidate.  Note that the same candidate running in two different races will have the same cId */
    ENSCandidateIdType: number;
    /** @description Tabulated vote counts (not estimated) */
    ENSTabCountsWithOVN: {
      /**
       * Format: integer
       * @description Reported votes (not estimated)
       */
      tabVote?: number;
      /**
       * Format: float
       * @description Percent of Reported votes (not estimated)
       */
      tabVotePct?: number;
      /**
       * Format: float
       * @description Estimated Percent of vote
       */
      estVotePct?: number;
      /**
       * Format: integer
       * @description Estimated oustanding vote count
       */
      estVoteOut?: number;
      /**
       * Format: float
       * @description Relative size of outstanding vote
       */
      estVoteOutSize?: number;
    };
    /** Format: date-time */
    ENSDateTimeType: string;
    /** @description Counts and estimates for counties and precincts in. */
    ENSInAndOfCMCounts: components['schemas']['ENSPrecinctCounts'] & {
      /**
       * Format: integer
       * @description Reported votes (not estimated)
       */
      cntyIn?: number;
    };
    /** @description The number of units that are not yet decided. */
    ENSnUndType: number;
    /** @description Used to represent values between 0-999999999 */
    ENSBigNumberType: number;
    /** @description key for a race */
    ENSRaceKeyTypeJson: {
      eDate: components['schemas']['ENSDateType'];
      eType: components['schemas']['ENSElectionTypeType'];
      jCde: components['schemas']['ENSJurisdictionCodeType'];
      jType: components['schemas']['ENSJurisdictionTypeType'];
      ofc: components['schemas']['ENSOfficeDesignationType'];
      st: components['schemas']['ENSStateCodeTypeJson'];
    };
    ENSxpStage: number;
    /** @description Precinct report type. For Exit Poll reports, the number following the E indicates the Call (1, 2 or 3).  Present only for scp=P. Possible values: [C P E1 E2 E3] */
    ENSPrecinctReportTypeJson: string | null;
    /**
     * @description Defines a computational model.
     *           SPM (Sample precinct model)
     *           CM (County Model)
     *           IM (Integrated Model)
     *
     * @enum {string}
     */
    ENSCompModelType: 'SPM' | 'CM' | 'IM';
    /** @description Used to represent strings of 1 - 3 characters */
    ENSThreeCharCodeType: string;
    /** @description Calculations from computations */
    ENSCompCalc: {
      /**
       * Format: integer
       * @description Reported votes (not estimated)
       */
      tabVote?: number;
      /**
       * Format: float
       * @description Percent of Reported votes (not estimated)
       */
      tabVotePct?: number;
      /**
       * Format: integer
       * @description Estimated vote count
       */
      estVote?: number;
      /**
       * Format: float
       * @description Estimated Percent of vote
       */
      estVotePct?: number;
    };
    /**
     * @description Defines an estimator type.
     *           R (Ratio) S (Simple)
     *
     * @enum {string}
     */
    ENSEstimatorType: 'R' | 'S';
    Q: {
      IsDemograph?: components['schemas']['ENSYesNoType'];
      MxId: components['schemas']['ENSHugeNumberType'];
      fullMxLabel: string;
      numRows: components['schemas']['ENSTinyNumberType'];
      qSeq: components['schemas']['ENSSmallNumberType'];
      /** @enum {integer} */
      qType: 1 | 2;
      shortMxLabel: string;
      /** @description Collection of matrix rows */
      MxRows: {
        row: components['schemas']['ENSTinyNumberType'];
        rowLabel: string;
        rowText: string;
      }[];
    };
    ENSCandidateEstForCountyClassicModel: {
      cId?: components['schemas']['ENSCandidateIdType'];
      /**
       * Format: integer
       * @description Order of the candidate in the results
       */
      order?: number;
      /** @description For debugging purposes only. Short description to distinguish candidate */
      candidateDescription?: string;
      /**
       * Format: float
       * @description The standard error on the difference for any pair of candidates from the prior estimate for racewide total vote
       */
      sedf?: number;
      total?: components['schemas']['ENSCompCalc'] & {
        /**
         * Format: float
         * @description Needed is the critical value to win over the SEDF
         */
        need?: number;
        /** Format: float */
        crit?: number;
        /**
         * Format: float
         * @description The Ratio is the critical value over the T-Needed (critical value to win)
         */
        ratio?: number;
        /**
         * Format: float
         * @description The difference between the estimates of the top pair of candidates
         */
        diff?: number;
      };
    }[];
    /**
     * @description Defines the editorial status of a candidate.
     *           Y = ENS wll be providing estimates
     *           N = No estimates coverage for this candidate
     *
     * @enum {string}
     */
    EditorialStatusType: 'Y' | 'N';
    /** @description Generic type for stratum codes in the range of 0-99 */
    ENSStratumCodeType: number;
    /** @description Party code.  (e.g., Dem = Democratic Party, GOP = Republican Party, Grn = Green party)  */
    ENSPartyCodeType: string;
    /** @description Numeric state code. Reflects alphabetic order of full state names.
     *           00 (Nationwide)
     *           01-51 (States, alphabetical by full state name)
     *            */
    ENSStateCodeType: string;
    /** @description The total number of units that have been won. */
    ENSnWonType: number;
    /**
     * @description Defines the process status of a Cancelation and possible override.
     *           N (Document Not Cancelled)
     *           Y (Document Cancelled)
     *           O (Operational Overide)
     *
     * @enum {string}
     */
    CancelStatusType: 'N' | 'Y' | 'O';
    /** @description Used to represent values between 0-99999 */
    ENSNumberType: number;
    candVoteType: {
      cId: components['schemas']['ENSCandidateIdType'];
      /** @description The candidate’s vote count. */
      cVote: components['schemas']['ENSVoteCountType'];
      /** @description The candidate’s early by mail vote count. */
      earlyByMailVote?: components['schemas']['ENSVoteCountType'];
      /** @description The candidate’s early in person vote count. */
      earlyInPersonVote?: components['schemas']['ENSVoteCountType'];
      /** @description The candidate’s election day vote count. */
      edayVote?: components['schemas']['ENSVoteCountType'];
      /** @description The candidate’s absentee vote count. */
      aVote?: components['schemas']['ENSVoteCountType'];
      /** @description The candidate’s other vote count. */
      otherVote?: components['schemas']['ENSVoteCountType'];
    };
    /** @description seq=sequence number in retransmission for messages originally sent on the specified topic.  For strat it is the first, for stop it is the last
     *           st=state
     *           rpt=report topic letter
     *            */
    ENSRetranType: {
      rpt?: components['schemas']['ENSReportTopicType'];
      seq?: components['schemas']['ENSSequenceNumberType'];
      st?: components['schemas']['ENSStateCodeType'];
    };
    /** @description Sub-code for the jurisdiction, within jurisdiction type 0-999 */
    ENSJurisdictionCodeType: number;
    /** @description Exit poll call number: 1-3 represents Call-1, call-2 and call-3.  4 represents final weighting. */
    ENSxpCall: number;
    /**
     * @description Start/Resume indicator
     * @enum {string}
     */
    ENSStartupStatusType: 'Start' | 'Resume';
    ENSPercentTypeWithMinus1: number;
    /**
     * @description Total Expected Vote Mode (C=Calculate, M=Maintain Value, T=Use Total Vote)
     * @enum {string}
     */
    TEVVoteModeType: 'C' | 'M' | 'T';
    /**
     * @description Call status.
     *           N (no status yet)
     *           C (too close to call)
     *           B (winner before poll closing)
     *           W (winner after poll closing)
     *           R (reversal)
     *           V (advances to runoff)
     *
     * @enum {string}
     */
    ENSCallStatusType: 'N' | 'C' | 'B' | 'R' | 'W' | 'V';
    /** @description key for a race */
    ENSElectionKeyType: {
      eDate: components['schemas']['ENSDateType'];
      eType: components['schemas']['ENSElectionTypeType'];
      jCde: components['schemas']['ENSJurisdictionCodeType'];
      jType: components['schemas']['ENSJurisdictionTypeType'];
      st: components['schemas']['ENSStateCodeType'];
    };
    /** @description Office designation.  An issue number will follow the "I" for issues.  For example, I1, I2, I3, etc.  The maximum number of issues covered for a given election in a given state is 9.
     *           Other ofc values may be added.
     *           0 (zero) EMR-MI precinct level reporting.
     *           G (Governor)
     *           G2 (Governor)
     *           H (U.S. House)
     *           I (Issue)
     *           P (President)
     *           Q (Delegates)
     *           S (U.S. Senate)
     *           S2 (2nd Senate seat)
     *           PV(Pres-pre-viability)
     *           AGC(Agricultural Comm)
     *           SS(Secretary of State)
     *           RR (Railroad Commissioner)
     *           0 (reserved)
     *            */
    ENSOfficeDesignationType: string;
    /** @description District ID.  This will be unique within a district type */
    ENSDistrictIdType: number;
    /** @description County Model Classic Strata definition */
    ENSCMCStrataInfoType: {
      /** @description Collapse strata (when there is collapsing) */
      clpse?: string;
      /**
       * Format: float
       * @description Curr size percentage
       */
      currSize?: number;
      /** @description Stratum code */
      strmCde?: number;
      /**
       * Format: float
       * @description Past size percentage
       */
      pastSize?: number;
      /** @description Total counties reporting in stratum */
      cntyOf?: components['schemas']['ENSNumberType'];
      /** @description Total precincts in stratum */
      totPcts?: components['schemas']['ENSNumberType'];
      total?: components['schemas']['ENSInAndOfCMCounts'] &
        components['schemas']['ENSCompCalcWithOVN'];
      /** @description stratum level counts and estimates */
      candidates?: components['schemas']['ENSCandidateEstForCountyClassicModel'];
    };
    /** @description Vote results value for a candidate. */
    ENSVoteCountType: number;
    /**
     * @description Report topic within state being retransmitted.
     * @enum {string}
     */
    ENSReportTopicType: 'S' | 'C' | 'E' | 'M' | 'X';
    ENSCandidateForCPM: {
      eday?: components['schemas']['ENSVoteByMethodCPM'];
      /** @description For debugging purposes only. Short description to distinguish candidate */
      candidateDescription?: string;
      earlyInPerson?: components['schemas']['ENSVoteByMethodCPM'];
      total?: components['schemas']['ENSCountsWithTEVCPM'];
      earlyByMail?: components['schemas']['ENSVoteByMethodCPM'];
      /**
       * Format: float
       * @description The standard error on the difference of the candidate and the succeeding candidate
       */
      sedf?: number;
      /** Format: integer */
      pastVar?: number;
      /**
       * Format: integer
       * @description Order of the candidate in the results
       */
      order?: number;
      cId?: components['schemas']['ENSCandidateIdType'];
    }[];
    /** @description District type code.
     *           CD = Congressional District
     *           DD = Delegate District
     *           AL = At Large District
     *           AO = Add On District
     *
     *           Additional district types may be added later to support other regions.
     *            */
    ENSDistrictTypeType: string;
    /** @description Used to represent values between 0-99999999999 */
    ENSHugeNumberType: number;
    ENSPercentageDecimal2Type: number;
    /** @description Vote counts by method */
    ENSVoteByMethodCPM: {
      /**
       * Format: integer
       * @description Reported votes (not estimated)
       */
      tabVote?: number;
      /**
       * Format: float
       * @description Percent of Reported votes (not estimated)
       */
      tabVotePct?: number;
      /**
       * Format: integer
       * @description Estimated vote
       */
      estVote?: number;
      /**
       * Format: float
       * @description Estimated vote Percent
       */
      estVotePct?: number;
      /**
       * Format: integer
       * @description Estimated vote count
       */
      estVoteCount?: number;
      /**
       * Format: float
       * @description Total number of counties reporting
       */
      cntyIn?: number;
    };
    ENSCandidateEstForVoteMethodModel: {
      cId?: components['schemas']['ENSCandidateIdType'];
      /**
       * Format: integer
       * @description Order of the candidate in the results
       */
      order?: number;
      /** @description For debugging purposes only. Short description to distinguish candidate */
      candidateDescription?: string;
      /**
       * Format: float
       * @description The standard error on the difference for any pair of candidates from the prior estimate for racewide total vote
       */
      sedf?: number;
      earlyByMail?: components['schemas']['ENSVoteByMethodCPM'];
      earlyInPerson?: components['schemas']['ENSVoteByMethodCPM'];
      eday?: components['schemas']['ENSVoteByMethodCPM'];
      total?: components['schemas']['ENSCountsWithTEVCPM'];
    }[];
    /** @description Calculations from computations */
    ENSCountsWithTEV: {
      /**
       * Format: integer
       * @description Reported votes (not estimated)
       */
      tabVote?: number;
      /**
       * Format: float
       * @description Percent of Reported votes (not estimated)
       */
      tabVotePct?: number;
      /**
       * Format: integer
       * @description Total expected vote
       */
      totalExpVote?: number;
      /**
       * Format: float
       * @description Percent of reported vote based on TEV(total expected vote)
       */
      totalExpVotePct?: number;
    };
    /** @description The total number of units that have been decided. */
    ENSnDecType: number;
    ENSPercentageDecimal1Type: number;
    /** @description Used to establish an order (sequencing) - Ascending by state and scope */
    ENSSequenceNumberType: number;
    /**
     * @description Generic type used to represent Yes/No values in the form of Y or N
     * @enum {string}
     */
    ENSYesNoType: 'Y' | 'N';
    /**
     * @description Confirmed, Ghost, or Assumptive
     * @enum {string}
     */
    ENSCandStatusType: 'C' | 'G' | 'A' | '';
    /** @description Used to represent percentage value */
    ENSPercentType: number;
    ENSEstimatorKeyType: {
      estType: components['schemas']['ENSEstimatorType'];
      model: components['schemas']['ENSCompModelType'];
      strataType: components['schemas']['ENSStrataType'];
      pastRace?: components['schemas']['ENSRaceKeyType'];
    };
    /**
     * @description Indicates progress of the vote tabulation:
     *           N = none (default)
     *           S = some
     *           A = all
     *           U = unknown
     *           M = most
     *
     * @enum {string}
     */
    ENSVoteTurnoutType: 'N' | 'S' | 'A' | 'U' | 'M';
    /** @description Generic type used to represent a four character abbreviation */
    ENSAbbv4: string;
    /**
     * @description
     *               Call status.
     *               N (no status yet)
     *               T (too close to call)
     *               L (one candidate leading)
     *               C (call status)
     *               R (reversal)
     *
     * @enum {string}
     */
    ENSCompStatusType: 'N' | 'T' | 'L' | 'C' | 'R';
    /** Format: date */
    ENSDateType: string;
    /** @description County ID value - (0 - 999) */
    ENSCountyIdType: number;
    /** @description Numeric state code. Reflects alphabetic order of full state names.
     *           00 (Nationwide)
     *           01-51 (States, alphabetical by full state name)
     *            */
    ENSStateCodeTypeJson: number;
    /** @description The cand element provides information on a single candidate. */
    cand: {
      cId: components['schemas']['ENSCandidateIdType'];
      /** @description The candidate’s vote. */
      cVote: components['schemas']['ENSVoteCountType'];
      /** @description Candidate last name */
      candLastName: string;
      /** @description Indicates if this candidate is in the editorial list */
      edListFlg: components['schemas']['ENSYesNoType'];
      /** @description Is the past candidate going to be used in the computations? */
      isResearchFlg?: components['schemas']['ENSYesNoType'];
      /** @description Major party ID. Party code. E.g., Dem = Democratic Party, GOP = Republican Party, Grn = Green Party. */
      majorPtyId: components['schemas']['ENSPartyCodeType'];
    };
    /**
     * @description Defines the runoff status of a race.
     *     N = There will Never be a runoff for this race
     *     A = There will Always be a runoff for this race
     *     P = There will Possibly be a runoff for this race
     *
     * @enum {string}
     */
    RunoffCoverageType: 'Y' | 'A' | 'E' | 'N' | 'P';
    /** @description Date/time that the item was added to the document queue for a member, not the time the item was transmitted.
     *           Format is RFC3339 yyyy-mm-ddThh:mm:ssZ
     *            */
    RFC3339DateTime: string;
    strmSchType: {
      strmSchAbbv4: components['schemas']['ENSAbbv4'];
      strmSchCde: components['schemas']['ENSHugeNumberType'];
      strmSchName: string;
      /** @description Collection of stratum */
      stratum: {
        isBlk?: components['schemas']['ENSYesNoType'];
        strmAbbv4: components['schemas']['ENSAbbv4'];
        strmCde: components['schemas']['ENSSmallNumberType'];
        strmName: string;
        totalPrecincts?: components['schemas']['ENSHugeNumberType'];
      }[];
    };
    /** @description Outstanding vote attributes */
    ENSOVNCounts: {
      /**
       * Format: float
       * @description Estimated Percent of vote
       */
      estVotePct?: number;
      /**
       * Format: integer
       * @description Estimated oustanding vote count
       */
      estVoteOut?: number;
      /**
       * Format: float
       * @description Relative size of outstanding vote
       */
      estVoteOutSize?: number;
    };
    /** @description Calculations from computations */
    ENSCountsWithTEVCPM: {
      /**
       * Format: float
       * @description Percent of Reported votes (not estimated)
       */
      tabVotePct?: number;
      /** Format: float */
      need?: number;
      /**
       * Format: integer
       * @description Estimated vote
       */
      estVote?: number;
      crit?: unknown;
      /**
       * Format: integer
       * @description Total number of counties reporting
       */
      cntyIn?: number;
      /**
       * Format: float
       * @description County model classic estimate vote Percent
       */
      cmClassicEstVotePct?: number;
      /** Format: float */
      ratio?: number;
      /**
       * Format: float
       * @description Estimated vote Percent
       */
      estVotePct?: number;
      /**
       * Format: float
       * @description The standard error on the difference for any pair of candidates from the prior estimate for racewide total vote
       */
      sedf?: number;
      /**
       * Format: integer
       * @description County model classic estimated vote count
       */
      cmClassicEstVC?: number;
      /**
       * Format: integer
       * @description Estimated vote count
       */
      estVoteCount?: number;
      /**
       * Format: integer
       * @description Reported votes (not estimated)
       */
      tabVote?: number;
    };
    /** @description Size of a strata */
    ENSStrataSize: number;
    /**
     * @description Precinct report type. For Exit Poll reports, the number following the E indicates the Call (1, 2 or 3).  Present only for scp=P
     * @enum {string}
     */
    ENSPrecinctReportType: 'C' | 'P' | 'E1' | 'E2' | 'E3';
    /**
     * @description Indicates the type of transmission:
     *            T (Transmission Test)
     *            R (Rehearsal)
     *            L (Live event)
     *
     * @enum {string}
     */
    ENSEventType: 'T' | 'R' | 'L';
    /** @description Used to represent values between 0-999 */
    ENSSmallNumberType: number;
    /** @description key for a race */
    ENSElectionKeyTypeJson: {
      eDate: components['schemas']['ENSDateType'];
      eType: components['schemas']['ENSElectionTypeType'];
      jCde: components['schemas']['ENSJurisdictionCodeType'];
      jType: components['schemas']['ENSJurisdictionTypeType'];
      st: components['schemas']['ENSStateCodeTypeJson'];
    };
    /** @description Used to represent strings of 1 or 2 characters */
    ENSTwoCharCodeType: string;
    /** @description Generic type used to represent Yes/No values in the form of Y or N */
    ENSYesNoTypeJson: string | null;
    /** @description
     *             Election Type.  Some documented values.
     *             G (General election)
     *             D (Democratic Primary)
     *             R (Republican Primary)
     *             C (Conservative Primary)
     *             T (Right to Life Primary)
     *             E (Democratic Caucus)
     *             S (Republican Caucus)
     *            */
    ENSElectionTypeType: string;
    /** @description key for a race */
    ENSRaceKeyType: {
      eDate: components['schemas']['ENSDateType'];
      eType: components['schemas']['ENSElectionTypeType'];
      jCde: components['schemas']['ENSJurisdictionCodeType'];
      jType: components['schemas']['ENSJurisdictionTypeType'];
      ofc: components['schemas']['ENSOfficeDesignationType'];
      st: components['schemas']['ENSStateCodeType'];
    };
    /**
     * @description Source of transmission (E=EMR-MI, O=Other)
     * @enum {string}
     */
    ENSTransmissionSourceType: 'E' | 'O' | 'A';
    /** @description Tabulated vote counts (not estimated) */
    ENSTabCounts: {
      /**
       * Format: integer
       * @description Reported votes (not estimated)
       */
      tabVote?: number;
      /**
       * Format: float
       * @description Percent of Reported votes (not estimated)
       */
      tabVotePct?: number;
    };
    /** @description Counts and estimates for precincts within counties and strata */
    ENSPrecinctCounts: {
      /**
       * Format: float
       * @description Percent of Reported votes (not estimated)
       */
      pctsRep?: number;
      /**
       * Format: intege
       * @description Estimated vote count
       */
      actualReportingPcts?: number;
      /**
       * Format: integer
       * @description County precinct model only
       */
      numOfPctsNotReported?: number;
    };
    /**
     * Format: date-time
     * @description Date/time that the item was added to the document queue for a member, not the time the item was transmitted.
     *
     */
    ENSTimestampType: string;
    /**
     * @description Defines scope of the document.
     *           S (Race-wide)
     *           C (One county or jurisdiction piece of a county, all voters)
     *           A (One county or jurisdiction piece of a county, absentees only)
     *           R (Full breakdown jurisdiction)
     *           Z  (One county piece of a breakdown jurisdiction, all voters)
     *           B (One county piece of a breakdown jurisdiction, absentees only)
     *           P (Precinct level reporting)
     *
     * @enum {string}
     */
    ENSScpType: 'S' | 'C' | 'A' | 'R' | 'Z' | 'B' | 'P';
    /** @description The total number of units included in the summary. */
    ENSnUpType: number;
    /** @description Used to represent values between 0-99 */
    ENSTinyNumberType: number;
    ENSRegionType: number;
    /** @description District type code.
     *           CD = Congressional District
     *           DD = Delegate District
     *           AL = At Large District
     *           AO = Add On District
     *
     *           Additional district types may be added later to support other regions.
     *            */
    ENSDistrictTypeTypeJson: string | null;
    /** @description Provides information needed to calculate change in power between the major parties for a given office.  This will be produced for the U.S. Senate, Governor, and U.S. House. */
    'party-by-office': {
      /** @description Collection of counts of incumbents and holdovers by party. */
      partyCnts: {
        /** @description Number of holdovers for a given party. */
        holdoverCnt: components['schemas']['ENSSmallNumberType'];
        /** @description Number of incumbents for a given party. */
        incCnt: components['schemas']['ENSSmallNumberType'];
        pId: components['schemas']['ENSPartyCodeType'];
        /** @description Number of uncontested races where the only candidate is in this party. */
        uncontestedCnt: components['schemas']['ENSSmallNumberType'];
      }[];
      /** @description Tag for document key. */
      key: {
        eDate: components['schemas']['ENSDateType'];
        ofc: components['schemas']['ENSOfficeDesignationType'];
      };
    };
    /** @description Contains an election message from the EAS. Used to commumicate important information such as an increase in total expected vote or a weather problem that is delaying vote count collection. */
    msg: {
      /** Format: date */
      eDate: string;
      jType?: components['schemas']['ENSJurisdictionTypeType'];
      /** @description Tag for document key */
      key: {
        /** Format: date */
        eDate: string;
        st: components['schemas']['ENSStateCodeTypeJson'];
      };
      /** @description Actual message text.  String(256) */
      content: string;
      /** @description Message security level (0 - 9). 0 indicates all users.
       *
       *     There following security levels are assigned to the message types:
       *
       *         R (Race Status) = 6
       *         I (Input Management) = 8
       *         D (Decision Desk) = 9
       *         S (Survey Desk) = 7 */
      mLvl: number;
      jCde?: components['schemas']['ENSJurisdictionCodeType'];
      transSrc: components['schemas']['ENSTransmissionSourceType'];
      ts: components['schemas']['RFC3339DateTime'];
      st: components['schemas']['ENSStateCodeTypeJson'];
      /** @description Message priority (0 - 9). 0 is highest priority */
      mPrio: number;
      ofc?: components['schemas']['ENSOfficeDesignationType'];
      eType?: components['schemas']['ENSElectionTypeType'];
      seq: components['schemas']['ENSSequenceNumberType'];
      /** @description Message type code. Different message types may be added in the future.
       *
       *         B (Bulletin)
       *         R (Race Status)
       *         I (Input Management)
       *         D (Decision Desk)
       *         S (Survey Desk) */
      mType: string;
    };
    /** @description Each of these documents describes one xTab document that will be available on election day.  One xtab-setup document deals with a pre-defined set of exit poll cross tabulations for one race.  The optional subsets are for sending filtered data such as "Male Only", "Female Only", "New England", etc. */
    'xtab-setup': {
      /** @description Number of editorial candidates + 1 for the 'All' column. */
      numCol?: components['schemas']['ENSTinyNumberType'];
      /** @description Number of questions */
      numQ?: components['schemas']['ENSSmallNumberType'];
      /** @description Number of subset repeating tags. */
      numSubsets?: components['schemas']['ENSTinyNumberType'];
      /** @description Optional tag for past comparison race element */
      pastCompRace?: {
        /** @description Past comparison race election year */
        pcrElYr: components['schemas']['ENSTinyNumberType'];
        /** @description Past comparison race office */
        pcrOfcAbbv4: string;
        /** @description Party code of the trend candidate. */
        trendPartyCd: components['schemas']['ENSThreeCharCodeType'];
      };
      /** @description Collection of questions */
      q: components['schemas']['Q'][];
      subsets?: {
        /** @description Subset ID - This number will be the same for matching filters across all surveys.  For example, the ‘Males Only’ will have the same subset ID for any static cross tab. */
        sub: components['schemas']['ENSHugeNumberType'];
        /** @description Subset long name. */
        subLongName: string;
        /** @description Subset short name. */
        subShortName: string;
      }[];
      /** @description Tag for document key */
      key: {
        eDate: components['schemas']['ENSDateType'];
        eType: components['schemas']['ENSElectionTypeType'];
        jCde: components['schemas']['ENSJurisdictionCodeType'];
        jType: components['schemas']['ENSJurisdictionTypeType'];
        ofc: components['schemas']['ENSOfficeDesignationType'];
        st: components['schemas']['ENSStateCodeTypeJson'];
      };
    };
    /** @description Election day district vote documents. */
    'delegate-vote': {
      /** Format: date */
      eDate: string;
      totPcts: components['schemas']['ENSPctNumberType'];
      scp: components['schemas']['ENSScpType'];
      jType: components['schemas']['ENSJurisdictionTypeType'];
      totVote?: components['schemas']['ENSHugeNumberType'];
      /** @description Tag for document key */
      key: {
        /** Format: date */
        eDate: string;
        eType: components['schemas']['ENSElectionTypeType'];
        jCde: components['schemas']['ENSJurisdictionCodeType'];
        jType: components['schemas']['ENSJurisdictionTypeType'];
        st: components['schemas']['ENSStateCodeTypeJson'];
        cnty: components['schemas']['ENSSmallNumberType'];
        ofc: components['schemas']['ENSOfficeDesignationType'];
      };
      totEdayVote?: components['schemas']['ENSHugeNumberType'];
      /** @description Optional tag for district level (instead of county of statewide level) votes */
      dist?: {
        dId: components['schemas']['ENSDistrictIdType'];
        dType: components['schemas']['ENSDistrictTypeType'];
      };
      /** @description Collection of candidate’s vote/delegate results. There is one instance per candidate.   */
      candidates: {
        aVote?: components['schemas']['ENSVoteCountType'];
        cId: components['schemas']['ENSCandidateIdType'];
        cVote: components['schemas']['ENSVoteCountType'];
        /** @description The candidate's election day vote, if it is available. */
        edayVote?: components['schemas']['ENSVoteCountType'];
        /** @description The candidate's early by mail vote, if it is available. */
        earlyByMailVote?: components['schemas']['ENSVoteCountType'];
        /** @description The candidate's early in person vote, if it is available. */
        earlyInPersonVote?: components['schemas']['ENSVoteCountType'];
        /** @description The candidate's provisional vote, if it is available. */
        provisionalVote?: components['schemas']['ENSVoteCountType'];
        /** @description Optional, collection of the party-line vote for a single candidate/party combination. There is one instance per un-fused party-line vote count in the contest. */
        party?: {
          pId: components['schemas']['ENSPartyCodeType'];
          unfusedCVote: components['schemas']['ENSVoteCountType'];
        }[];
      }[];
      pcnt?: components['schemas']['ENSSmallNumberType'];
      absOut?: components['schemas']['ENSHugeNumberType'];
      pctsRep: components['schemas']['ENSPctNumberType'];
      totalblts?: components['schemas']['ENSHugeNumberType'];
      proOut?: components['schemas']['ENSHugeNumberType'];
      jCde: components['schemas']['ENSJurisdictionCodeType'];
      transSrc: components['schemas']['ENSTransmissionSourceType'];
      totEarlyInPersonVote?: components['schemas']['ENSHugeNumberType'];
      ts: components['schemas']['RFC3339DateTime'];
      totEarlyByMailVote?: components['schemas']['ENSHugeNumberType'];
      st: components['schemas']['ENSStateCodeTypeJson'];
      totProvisionalVote?: components['schemas']['ENSHugeNumberType'];
      /** @description Optional tag present at race wide or county level. */
      flgs?: {
        absVotes?: components['schemas']['ENSVoteTurnoutType'];
        canceled?: components['schemas']['ENSYesNoType'];
        complete?: components['schemas']['ENSYesNoType'];
        final?: components['schemas']['ENSYesNoType'];
        proVotes?: components['schemas']['ENSVoteTurnoutType'];
        repSrc: components['schemas']['ENSReportingSourceType'];
        verified?: components['schemas']['ENSYesNoType'];
      };
      ofc: components['schemas']['ENSOfficeDesignationType'];
      eType: components['schemas']['ENSElectionTypeType'];
      maxAbs?: components['schemas']['ENSHugeNumberType'];
      seq: components['schemas']['ENSSequenceNumberType'];
      cnty?: components['schemas']['ENSSmallNumberType'];
      totAVote?: components['schemas']['ENSHugeNumberType'];
    };
    /** @description National delegeate summary document. A summary of the delegate allocations for the current primary cycle. */
    'national-delegate-summary': {
      /** Format: date */
      eDate: string;
      scp: components['schemas']['ENSScpType'];
      jType: components['schemas']['ENSJurisdictionTypeType'];
      /** @description Tag for document key */
      key: {
        /** Format: date */
        eDate: string;
        eType: components['schemas']['ENSElectionTypeType'];
        jCde: components['schemas']['ENSJurisdictionCodeType'];
        jType: components['schemas']['ENSJurisdictionTypeType'];
        st: components['schemas']['ENSStateCodeTypeJson'];
        ofc: components['schemas']['ENSOfficeDesignationType'];
      };
      parties: {
        pId: components['schemas']['ENSPartyCodeType'];
        /** @description Delegates needed to win */
        dNeed: number;
        /** @description Number of total delegates allocated */
        dVotes: number;
        states: {
          st: components['schemas']['ENSStateCodeTypeJson'];
          candidates: {
            cId: components['schemas']['ENSCandidateIdType'];
            /** @description Total delegates */
            dTot: number;
            /** @description Total super delegates */
            sdTot: number;
          }[];
        }[];
      }[];
      jCde: components['schemas']['ENSJurisdictionCodeType'];
      ts: components['schemas']['RFC3339DateTime'];
      st: components['schemas']['ENSStateCodeTypeJson'];
      ofc: components['schemas']['ENSOfficeDesignationType'];
      seq: components['schemas']['ENSSequenceNumberType'];
    };
    /** @description Provides historical vote counts by county. */
    'past-county-data': {
      races: {
        ofc: components['schemas']['ENSOfficeDesignationType'];
        cand?: components['schemas']['cand'][];
        counties: {
          cnty: components['schemas']['ENSCountyIdType'];
          /** @description Total vote for all candidates (including non-editorial candidates) in this race in the specified county or state. */
          totVote: components['schemas']['ENSHugeNumberType'];
          candVotes: components['schemas']['candVoteType'][];
        }[];
      }[];
      key: {
        eDate: components['schemas']['ENSDateType'];
        eType: components['schemas']['ENSElectionTypeType'];
        jCde: components['schemas']['ENSJurisdictionCodeType'];
        jType: components['schemas']['ENSJurisdictionTypeType'];
        st: components['schemas']['ENSStateCodeTypeJson'];
      };
    };
    /** @description Contains information on the counties and county pieces covered in one election, whether that is a statewide election, an election in a Congressional District or other jurisdiction. Note that the total precincts given in this document are advisory only.  In rare cases, the total precincts may change on election night. */
    'county-by-elec': {
      /** @description Tag for document key. */
      key: {
        eDate: components['schemas']['ENSDateType'];
        eType: components['schemas']['ENSElectionTypeType'];
        jCde: components['schemas']['ENSJurisdictionCodeType'];
        jType: components['schemas']['ENSJurisdictionTypeType'];
        st: components['schemas']['ENSStateCodeTypeJson'];
      };
      /** @description The total expected vote strata scheme */
      countyExpVoteStrataScheme?: {
        /** @description Tag for stratification scheme element */
        strmSch: components['schemas']['strmSchType'];
      };
      /** @description Number of expected early by mail votes for the state */
      totExpEarlyByMailVote?: components['schemas']['ENSHugeNumberType'];
      /** @description Number of expected election day votes for the state */
      totExpEdayVote?: components['schemas']['ENSHugeNumberType'];
      /** @description Number of expected early in person votes for the state */
      totExpEarlyInPersonVote?: components['schemas']['ENSHugeNumberType'];
      /** @description Tag for the party strata scheme */
      countyPartyStrataScheme: {
        strmSch: components['schemas']['strmSchType'][];
      };
      counties: {
        /** @description Indicates whether this is the entire county (or pseudo county). */
        entireEntityFlg: components['schemas']['ENSYesNoType'];
        /** @description Total precincts in this county or county piece. */
        totPcts: components['schemas']['ENSNumberType'];
        /** @description Party stratum code */
        partyStratum: components['schemas']['ENSStratumCodeType'];
        /** @description Number of polling locations */
        pollingLocations?: number;
        /** @description Geographic stratum code */
        geoStratum: components['schemas']['ENSStratumCodeType'];
        /** @description Initial estimated total expected early by mail vote */
        totExpEarlyByMailVote?: number;
        /**
         * Format: float
         * @description Percent democratic base race
         */
        percentDemBaseRace?: number;
        /** @description Initial estimated total expected election day vote */
        totExpEdayVote?: number;
        /** @description Initial estimated total expected early in person vote */
        totExpEarlyInPersonVote?: number;
        expectedVoteStratum?: components['schemas']['ENSStratumCodeType'];
        /** @description Initial estimated total expected absentee vote */
        totExpAVote?: number;
        /**
         * Format: float
         * @description Median age
         */
        medianAge?: number;
        /** @description Population */
        population?: number;
        /**
         * Format: float
         * @description Population density
         */
        populationDensity?: number;
        /** @description Initial estimated total expected vote */
        totExpVote?: number;
        /**
         * Format: float
         * @description Percent 4 year degree
         */
        percentEducation?: number;
        /**
         * Format: float
         * @description Percent hispanic population
         */
        percentHispanic?: number;
        cnty: components['schemas']['ENSCountyIdType'];
        /**
         * Format: float
         * @description Percent black population
         */
        percentBlack?: number;
        /** @description Registration for the county within the context of the election.  For example, a closed democratic primary will have just the democratic registration. A general election will have all the registered voters across all parties. */
        eligibleVoterReg: components['schemas']['ENSHugeNumberType'];
      }[];
      /** @description Number of expected absentee votes for the state */
      totExpAVote?: components['schemas']['ENSHugeNumberType'];
      /** @description Number of expected votes for the state */
      totExpVote: components['schemas']['ENSHugeNumberType'];
      /** @description Tag for the geo strata scheme */
      countyGeoStrataScheme: {
        strmSch: components['schemas']['strmSchType'][];
      };
      /** @description Number of pseudo counties in this document. */
      numPseudoCntys: components['schemas']['ENSSmallNumberType'];
      /** @description Number of counties or county pieces in this election, including pseudo counties. The number of county elements in this document. */
      numCntys: components['schemas']['ENSSmallNumberType'];
    };
    /** @description delegate-district document.
     *
     *     Describes districts used to report on a particular election. Districts will be linked to races through the race element of the election document */
    'delegate-district': {
      eDate: components['schemas']['ENSDateType'];
      eType: components['schemas']['ENSElectionTypeType'];
      jCde: components['schemas']['ENSJurisdictionCodeType'];
      jType: components['schemas']['ENSJurisdictionTypeType'];
      st: components['schemas']['ENSStateCodeTypeJson'];
      /** @description Tag for document key. */
      key?: {
        eDate: components['schemas']['ENSDateType'];
        eType: components['schemas']['ENSElectionTypeType'];
        jCde: components['schemas']['ENSJurisdictionCodeType'];
        jType: components['schemas']['ENSJurisdictionTypeType'];
        st: components['schemas']['ENSStateCodeTypeJson'];
      };
      'district-types': {
        dType: string;
        dTot: components['schemas']['ENSSmallNumberType'];
        districts: {
          dId: components['schemas']['ENSSmallNumberType'];
          districtName: string;
          districtAbbrev: string;
          totPcts: components['schemas']['ENSHugeNumberType'];
          statewideFlg: boolean;
          counties?: {
            cnty: components['schemas']['ENSSmallNumberType'];
            cntyTotPcts: components['schemas']['ENSHugeNumberType'];
          }[];
        }[];
      }[];
    };
    /** @description Election day county vote documents. A vote document sends vote results for a single, unique contest. It can accommodate results at any level of granularity. Granularity is determined by the scp tag. Race-wide summaries are scp=S, county votes are scp=C. */
    'county-vote': {
      /** Format: date */
      eDate: string;
      /** @description Total precincts covered by the document. */
      totPcts: components['schemas']['ENSPctNumberType'];
      scp: components['schemas']['ENSScpType'];
      jType: components['schemas']['ENSJurisdictionTypeType'];
      /** @description Total vote for all candidates (including non-editorial candidates) in this race in the specified county or state. May not be set in races like the CA Recall short race where votes are only tabulated for a subset of the candidates. */
      totVote?: components['schemas']['ENSHugeNumberType'];
      /**
       * Format: float
       * @description Percent reporting Absentee votes
       */
      pctReportingTotAVote?: number;
      /** @description Tag for document key */
      key: {
        /** Format: date */
        eDate: string;
        eType: components['schemas']['ENSElectionTypeType'];
        jCde: components['schemas']['ENSJurisdictionCodeType'];
        jType: components['schemas']['ENSJurisdictionTypeType'];
        st: components['schemas']['ENSStateCodeTypeJson'];
        cnty: components['schemas']['ENSSmallNumberType'];
        ofc: components['schemas']['ENSOfficeDesignationType'];
      };
      /**
       * Format: float
       * @description Percent reporting Early By Mail votes
       */
      pctReportingTotEarlyByMailVote?: number;
      /** @description Percent of expected vote */
      pctExpVote?: number | null;
      totEdayVote?: components['schemas']['ENSHugeNumberType'];
      /** @description Optional tag for district level (instead of county of statewide level) votes */
      dist?: {
        dId: components['schemas']['ENSDistrictIdType'];
        dType: components['schemas']['ENSDistrictTypeTypeJson'];
      };
      /** @description Collection of candidate’s vote/delegate results. There is one instance per candidate.   */
      candidates: {
        /** @description The candidate’s absentee vote count.  Optional - This data is not available for all races and counties.
         *
         *     Absentee vote information will only be sent when scp=S or scp=C */
        aVote?: components['schemas']['ENSVoteCountType'];
        cId: components['schemas']['ENSCandidateIdType'];
        /** @description The candidate’s vote or delegate count. Delegates are transmitted only for office type Q. Documents for all other office types are votes.
         *
         *     Within a bounding tag, it represents the votes for the candidate under that party line.
         *
         *     In states where fusion is an issue, will transmit both fused and unfused votes. */
        cVote: components['schemas']['ENSVoteCountType'];
        /** @description The candidate's election day vote, if it is available. */
        edayVote?: components['schemas']['ENSVoteCountType'];
        /** @description The candidate's early by mail vote, if it is available. */
        earlyByMailVote?: components['schemas']['ENSVoteCountType'];
        /** @description The candidate's early in person vote, if it is available. */
        earlyInPersonVote?: components['schemas']['ENSVoteCountType'];
        /** @description The candidate's provisional vote, if it is available. */
        provisionalVote?: components['schemas']['ENSVoteCountType'];
        party?: {
          /** @description Party code associated with a candidate’s votes reported under a particular party line. E.g., Dem = Democratic Party, GOP = Republican Party, Grn = Green Party */
          pId: components['schemas']['ENSPartyCodeType'];
          /** @description Represents the votes for the candidate under that party line.
           *
           *     In states where fusion is an issue, will transmit both fused and unfused votes. */
          unfusedCVote: components['schemas']['ENSVoteCountType'];
        }[];
      }[];
      /** @description Precinct identifier.  Present only for documents that reflect data at the precinct level (scope P). */
      pcnt?: components['schemas']['ENSSmallNumberType'];
      /** @description Absentee votes outstanding left to be counted.  Optional.  May not be set for all counties and all races.  Will usually only be set after the final flag is set. */
      absOut?: components['schemas']['ENSHugeNumberType'];
      /** @description Total precincts reporting so far. */
      pctsRep: components['schemas']['ENSPctNumberType'];
      /** @description Total ballots for a precinct.  Only present when scp=’P’ and ofc=’0’. */
      totalblts?: components['schemas']['ENSHugeNumberType'];
      /** @description Source of votes. Source of 'EAS' is manual data entry, programmtic feeds will start with state prefix, e.g. AL1 for Alabama feed 1 */
      source?: string;
      /**
       * Format: float
       * @description Percent reporting Election Day votes
       */
      pctReportingTotEdayVote?: number;
      /** @description Provisional votes outstanding left to be counted.  Optional.  May not be set for all counties and all races.  Will usually only be set after the final flag is set. */
      proOut?: components['schemas']['ENSHugeNumberType'];
      jCde: components['schemas']['ENSJurisdictionCodeType'];
      transSrc: components['schemas']['ENSTransmissionSourceType'];
      totEarlyInPersonVote?: components['schemas']['ENSHugeNumberType'];
      ts: components['schemas']['RFC3339DateTime'];
      /** @description The name of the user or program that added the data */
      lastUpdUser?: string;
      totEarlyByMailVote?: components['schemas']['ENSHugeNumberType'];
      st: components['schemas']['ENSStateCodeTypeJson'];
      /**
       * Format: float
       * @description Percent of vote based on the total expected vote estimate
       */
      estVotePct?: number;
      totProvisionalVote?: components['schemas']['ENSHugeNumberType'];
      /** @description Number of counties */
      numCounties?: number | null;
      /** @description Optional tag present at race wide or county level. */
      flgs?: {
        /** @description Absentee votes.
         *     Indicates progress of the vote tabulation:
         *           N = none (default)
         *           S = some
         *           A = all
         *           U = unknown
         *           M = most
         *            */
        absVotes?: components['schemas']['ENSVoteTurnoutType'];
        /**
         * @description Y if this report has been canceled.
         * @default N
         */
        canceled: components['schemas']['ENSYesNoType'];
        /**
         * @description Indicates that there is a problem in this county. Y if this county has a problem.  The complete flag will be set in the county level only.
         * @default N
         */
        complete: components['schemas']['ENSYesNoType'];
        /**
         * @description Y if this is the last report for the night. The final flag will be set in the county and statewide levels only.
         * @default N
         */
        final: components['schemas']['ENSYesNoType'];
        pcntRepType?: components['schemas']['ENSPrecinctReportType'];
        /**
         * @description Provisional votes. Provisionals will only be sent for statewide and county scopes.
         *     Indicates progress of the vote tabulation:
         *           N = none (default)
         *           S = some
         *           A = all
         *           U = unknown
         *           M = most
         *
         * @default N
         */
        proVotes: components['schemas']['ENSVoteTurnoutType'];
        repSrc: components['schemas']['ENSReportingSourceType'];
        /**
         * @description Indicates that the current report has been confirmed with the appropriate election official. Y if this report has been confirmed. The verified flag will be set in the county level only.
         * @default N
         */
        verified: components['schemas']['ENSYesNoType'];
      };
      /** @description Number of counties with absentee votes */
      numCntyAbs?: number | null;
      ofc: components['schemas']['ENSOfficeDesignationType'];
      /** @description Total expected vote */
      totExpVote?: number | null;
      eType: components['schemas']['ENSElectionTypeType'];
      /** @description Maximum number of absentee ballots expected. */
      maxAbs?: components['schemas']['ENSHugeNumberType'];
      seq: components['schemas']['ENSSequenceNumberType'];
      /**
       * Format: float
       * @description Percent reporting Early In Person votes
       */
      pctReportingTotEarlyInPersonVote?: number;
      /** @description Number of counties with votes */
      numCntyVotes?: number | null;
      /** @description County identifier.  Present only for documents that reflect data at the county level (scopes A, B, C, and Z). */
      cnty?: components['schemas']['ENSSmallNumberType'];
      /** @description Total A-votes for all candidates (including non-editorial candidates) in this race in the specified county or state. */
      totAVote?: components['schemas']['ENSHugeNumberType'];
    };
    /** @description Provides initialization version information about an event. Indicates event availability via the events endpoints. */
    events: {
      eventId: string;
      /** @description The initialization version. Can be used in the events endpoints for retrieiving previous versions of meta data. */
      initversion: string;
      /** Format: date-time */
      inittimestamp: string;
    };
    /** @description This document contains the horizontal and vertical cross tabulation data for the voters in one of the contests covered by one survey. One survey, such as the survey for the Ohio Democratic Primary, may cover multiple contests (Pres and Gov), and therefore have multiple instances of this document */
    xtab: {
      /** Format: date */
      eDate: string;
      /** @description Collection of questions. There is one instance per question */
      q: {
        MxId: components['schemas']['ENSHugeNumberType'];
        qSeq: components['schemas']['ENSSmallNumberType'];
        /** @enum {integer} */
        qType: 1 | 2;
        sampleSize: components['schemas']['ENSHugeNumberType'];
        /** @description Collection of matrix rows. */
        mxRow: {
          pChg?: number;
          row: components['schemas']['ENSTinyNumberType'];
          /** @description Collection of information about a single column/row intersection (cell) in the question matrix. There is one instance per cell. */
          cell: {
            cId: components['schemas']['ENSCandidateIdType'];
            hPct: components['schemas']['ENSPercentTypeWithMinus1'];
            vPct: components['schemas']['ENSPercentTypeWithMinus1'];
          }[];
        }[];
      }[];
      jType: components['schemas']['ENSJurisdictionTypeType'];
      /** @description Tag for document key */
      key?: {
        /** Format: date */
        eDate: string;
        eType: components['schemas']['ENSElectionTypeType'];
        jCde: components['schemas']['ENSJurisdictionCodeType'];
        jType: components['schemas']['ENSJurisdictionTypeType'];
        st: components['schemas']['ENSStateCodeTypeJson'];
        ofc: components['schemas']['ENSOfficeDesignationType'];
        sub: components['schemas']['ENSHugeNumberTypeJson'];
      };
      sub?: components['schemas']['ENSHugeNumberTypeJson'];
      resp: components['schemas']['ENSDistrictIdType'];
      /** Format: date-time */
      postingDateTime: string;
      jCde: components['schemas']['ENSJurisdictionCodeType'];
      transSrc: components['schemas']['ENSTransmissionSourceType'];
      ts: components['schemas']['RFC3339DateTime'];
      st: components['schemas']['ENSStateCodeTypeJson'];
      ofc: components['schemas']['ENSOfficeDesignationType'];
      eType: components['schemas']['ENSElectionTypeType'];
      /** @description Collection of the best estimate at the time that the cross tab was generated. */
      cand: {
        cId: components['schemas']['ENSCandidateIdType'];
        /** @description Current estimated vote percent used in forcing */
        cPct: components['schemas']['ENSPercentType'];
      }[];
      xpCall?: components['schemas']['ENSxpCall'];
      seq: components['schemas']['ENSSequenceNumberType'];
      xpStage?: components['schemas']['ENSxpStage'];
    };
    /** @description Contains total expected vote estimate for a county and election. Also contains other information regarding the status of that counties total vote count. */
    'total-expected-vote': {
      /** @description The total expected early vote in person . */
      totExpEarlyInPersonVoteEst?: number;
      /** Format: date */
      eDate?: string;
      jType?: components['schemas']['ENSJurisdictionTypeType'];
      /** @description The estimated total expected vote. This can change based on certain conditions on election night */
      totExpVoteEst?: number;
      /** @description The stage of the county in this election. Stages are as follows:
       *     0 – No vote data in EAS (automated; editable by Edison)
       *
       *     2 – We have vote data from reporter/source (automated; editable)
       *
       *     4 – Last report for Election night.  This indicates that there could be additional votes counted later.  No other information.  (automated; editable by Edison)
       *
       *     6 – Last report and the county has indicated that there is no additional vote to count with the exception of provisional ballots.  (automated; editable by Edison)
       *
       *     8 – Last report and the county has indicated that there is no additional vote to count and Edison has verified this information. (Set by Edison)
       *
       *     10 – Vote has been certified by the Secretary of State. (Set by Edison)  */
      turnoutStage?: number;
      /** @description The total expected early vote by mail. */
      totExpEarlyByMailVoteEst?: number;
      /**
       * @description Y if this is the last report for the night. The final flag will be set in the county and statewide levels only.
       * @default N
       */
      final: components['schemas']['ENSYesNoType'];
      repSrc?: components['schemas']['ENSReportingSourceType'];
      jCde?: components['schemas']['ENSJurisdictionCodeType'];
      ts?: components['schemas']['RFC3339DateTime'];
      /**
       * @description Y if this report has been canceled.
       * @default N
       */
      canceled: components['schemas']['ENSYesNoType'];
      /** @description The total expected aVotes. */
      totExpAVoteEst?: number;
      /** @description List of outstanding vote types: ElectionDay, Absentee, EarlyInPerson, Provisional, ByMail */
      outstandingVoteType?: string[];
      /**
       * @description Provisional votes. Provisionals will only be sent for statewide and county scopes.
       *     Indicates progress of the vote tabulation:
       *           N = none (default)
       *           S = some
       *           A = all
       *           U = unknown
       *           M = most
       *
       * @default N
       */
      proVotes: components['schemas']['ENSVoteTurnoutType'];
      pcntRepType?: components['schemas']['ENSPrecinctReportType'];
      st?: components['schemas']['ENSStateCodeTypeJson'];
      /** @description The total expected election day vote. */
      totExpEdayVoteEst?: number;
      eType?: components['schemas']['ENSElectionTypeType'];
      /** @default C */
      totalExpectedVoteMode: components['schemas']['TEVVoteModeType'];
      /**
       * @description Indicates that there is a problem in this county. Y if this county has a problem.  The complete flag will be set in the county level only.
       * @default N
       */
      complete: components['schemas']['ENSYesNoType'];
      seq?: components['schemas']['ENSSequenceNumberType'];
      /** @description The number of ballots the county estimates remain uncounted */
      countyOutstandingBallot?: number;
      /** @description Absentee votes.
       *     Indicates progress of the vote tabulation:
       *           N = none (default)
       *           S = some
       *           A = all
       *           U = unknown
       *           M = most
       *            */
      absVotes?: components['schemas']['ENSVoteTurnoutType'];
      /**
       * @description Indicates that the current report has been confirmed with the appropriate election official. Y if this report has been confirmed. The verified flag will be set in the county level only.
       * @default N
       */
      verified: components['schemas']['ENSYesNoType'];
      cnty?: components['schemas']['ENSSmallNumberType'];
    };
    /** @description Contains electoral vote allocations by candidate for a single, unique contest. */
    'electoral-vote': {
      /** @description Total number of electoral votes at stake in the contest */
      nUp: number;
      /** Format: date */
      eDate: string;
      jType: components['schemas']['ENSJurisdictionTypeType'];
      /** @description Tag for document key */
      key: {
        /** Format: date */
        eDate: string;
        eType: components['schemas']['ENSElectionTypeType'];
        jCde: components['schemas']['ENSJurisdictionCodeType'];
        jType: components['schemas']['ENSJurisdictionTypeType'];
        st: components['schemas']['ENSStateCodeTypeJson'];
        ofc: components['schemas']['ENSOfficeDesignationType'];
      };
      /** @description Number of electoral votes allocated so far */
      nDec: number;
      cStat: components['schemas']['ENSCallStatusType'];
      candidates?: {
        cId: components['schemas']['ENSCandidateIdType'];
        /** @description In this document type, represents the candidate’s electoral vote count. */
        cVote: components['schemas']['ENSVoteCountType'];
      }[];
      jCde: components['schemas']['ENSJurisdictionCodeType'];
      transSrc?: components['schemas']['ENSTransmissionSourceType'];
      ts: components['schemas']['RFC3339DateTime'];
      st: components['schemas']['ENSStateCodeTypeJson'];
      ofc: components['schemas']['ENSOfficeDesignationType'];
      eType: components['schemas']['ENSElectionTypeType'];
      seq: components['schemas']['ENSSequenceNumberType'];
    };
    /** @description Provides information on absentee reporting methods. */
    'absentee-method': {
      /** @description Collection of absentee reporting methods. */
      absMethods: {
        absMethodDesc: string;
        absMethodId: components['schemas']['ENSSmallNumberType'];
      }[];
      /** @description Tag for document key. */
      key?: {
        eDate: components['schemas']['ENSDateType'];
      };
    };
    /** @description Contains county data for a state.  Information on which counties or pieces of counties are in a particular election is contained in the county-by-elect document. The term pseudo county is used to define a piece of a county.  They may be used in some metropolitan areas where a county is split for reporting purposes (e.g. IL Cook county suburbs vs. City of Chicago). Note that the total precincts given in this document are advisory only.  In rare cases, the total precincts may change on election night. */
    'county-by-state': {
      /** @description Number of counties in this state, including pseudo counties. This is the number of county elements in the document. */
      numCntys?: components['schemas']['ENSSmallNumberType'];
      /** @description Number of pseudo counties */
      numPseudoCntys?: components['schemas']['ENSSmallNumberType'];
      /** @description Number of expected votes for the state */
      totExpVote?: components['schemas']['ENSHugeNumberType'];
      /** @description Collection of county element. */
      county?: {
        partyReg?: {
          pId: components['schemas']['ENSPartyCodeType'];
          /** @description Total number of registered voters for a particular party pId in this county */
          regVoters: components['schemas']['ENSHugeNumberType'];
        }[];
        /** @description County ID (cnty value) of the containing county if this is a pseudo county piece of a real county.  Zero if this is not a pseudo county */
        mainCnty: components['schemas']['ENSSmallNumberType'];
        /** @description Method by which ENS expects this county to send absentee data.  The description for each method is in the absenteeMethod document. */
        absMethodId?: components['schemas']['ENSSmallNumberType'];
        /** @description Total number of registered voters in this county */
        cntyTotReg: components['schemas']['ENSHugeNumberType'];
        /** @description County name */
        cntyName: string;
        /** @description County name abbreviation */
        cntyAbbv: string;
        /** @description Maximum number of absentee ballots expected for this county */
        maxAbs?: components['schemas']['ENSHugeNumberType'];
        cnty: components['schemas']['ENSCountyIdType'];
        /** @description FIPS code for this county or for containing county.  The first two digits of the FIPS code will be the state FIPS code.  The last three digits will be the county FIPS code.  For pseudo-counties or for the New England towns, the FIPS code will correspond to the containing county. */
        fips?: components['schemas']['ENSNumberType'];
      }[];
      /** @description Tag for the geo strata scheme */
      countyGeoStrataScheme?: {
        strmSch: components['schemas']['strmSchType'][];
      };
      /** @description Tag for the party strata scheme */
      countyPartyStrataScheme?: {
        strmSch: components['schemas']['strmSchType'][];
      };
      /** @description Tag for document key. */
      key?: {
        eDate: components['schemas']['ENSDateType'];
        st: components['schemas']['ENSStateCodeTypeJson'];
      };
    };
    /** @description Contains information about races such as candidates and their parties. */
    'election-race': {
      ofc: components['schemas']['ENSOfficeDesignationType'];
      /** @description Office Name */
      ofcName: string;
      /** @description Total number of candidates in race. */
      totNumCand: components['schemas']['ENSSmallNumberType'];
      cand: {
        /** @description Tag for prior info element. */
        priorEstimate?: {
          /**
           * Format: float
           * @description The proportion of vote estimate for each candidate in the prior estimate based upon pre-election surveys.
           */
          estimate: number;
          /**
           * Format: float
           * @description The standard error on the difference for any pair of candidates from the prior estimate.
           */
          sedf: number;
          /**
           * Format: float
           * @description The standard error on the vote estimate for each candidate in the prior estimate.
           */
          stdError: number;
          /**
           * Format: float
           * @description The expected WPE for each candidate that is determined prior to an election. A positive value signifies that the exit poll is expected understate and a negative value signifies that the exit poll is expected to be overstated.
           */
          wpe: number;
        };
        party?: {
          /** @description Major party flag – Y for candidate’s major party.  This will only be set once per candidate. */
          majorPtyFlg: components['schemas']['ENSYesNoType'];
          pId: components['schemas']['ENSPartyCodeType'];
        }[];
        /** @description Tag for incumbency element. */
        incumb: {
          /** @description Is in incumbent party? */
          inIncPtyFlg: components['schemas']['ENSYesNoType'];
          /** @description Is the incumbent? */
          isIncFlg: components['schemas']['ENSYesNoType'];
        };
        /** @description Suffix on candidate name (e.g., “Jr”, or “III”) */
        candNameSuffix: string;
        /** @description Full name of candidate */
        candFullName: string;
        /** @description 4-char candidate name abbreviation */
        candAbbv4: components['schemas']['ENSAbbv4'];
        /** @description First name of candidate */
        candFirstName: string;
        /** @description Major party ID. Party code. E.g., Dem = Democratic Party, GOP = Republican Party, Grn = Green Party. */
        majorPtyId: components['schemas']['ENSPartyCodeType'];
        /** @description Middle name of candidate */
        candMiddleName: string;
        /** @description Candidate name abbreviation */
        candAbbv: string;
        /** @description Tag for editorial list and candidate output order. */
        listInfo: {
          edListFlg: components['schemas']['EditorialStatusType'];
          /** @description Indicates the output order of this candidate.  Generally, major party candidates are first, followed alphabetically by minor parties.  Numbers are not necessarily sequential, particularly when there is fusion. */
          outputOrder: components['schemas']['ENSSmallNumberType'];
          /** @description Indicates the output order of this candidate with an exit poll. */
          xpOrder?: components['schemas']['ENSSmallNumberType'];
        };
        /** @description Set to Y if using this suffix in reports */
        candUseSuffixFlg: components['schemas']['ENSYesNoType'];
        status: components['schemas']['ENSCandStatusType'];
        /** @description Last name of candidate */
        candLastName: string;
        /** @description Number of parties under which candidate is running.  Is “1” for each candidate when unfusedCovFlg=N for the race, and “1” or  greater for each candidate when unfusedCovFlg=Y.  In latter case gives the number of party elements for the candidate */
        numPtyLines: components['schemas']['ENSTinyNumberType'];
        gender: components['schemas']['ENSCandGenderType'];
        /** @description Tag for absentee info element. */
        absenteeEstimate?: {
          /**
           * Format: float
           * @description The candidate proportion of vote estimate among absentee voters.
           */
          estimate: number;
          /**
           * Format: float
           * @description The standard error on the difference for any pair of candidates from the absentee vote estimate.
           */
          sedf: number;
          /**
           * Format: float
           * @description The proportion of vote among absentees minus the proportion among Election Day voters for each candidate.
           */
          shift: number;
          /**
           * Format: float
           * @description The standard error of the proportion of the absentee vote for each candidate.
           */
          stdError: number;
        };
        cId: components['schemas']['ENSCandidateIdType'];
      }[];
      /** @description Tag for coverage flags element. */
      covFlags: {
        /** @description Tabulated vote reported by district described by the districtCov element */
        districtCovFlg: components['schemas']['ENSYesNoType'];
        /** @description Are EAS estimates generated for the race? */
        estEASCovFlg: components['schemas']['ENSYesNoType'];
        /** @description Is there precinct vote coverage for this race? */
        pctCovFlg: components['schemas']['ENSYesNoType'];
        runoffCoverage?: components['schemas']['RunoffCoverageType'];
        /** @description Tabulated vote collected for this race. */
        tabCovFlg: components['schemas']['ENSYesNoType'];
        /** @description Unfused vote coverage flag */
        unfusedCovFlg: components['schemas']['ENSYesNoType'];
        /** @description Is there exit poll coverage for this race? */
        xpaCovFlg: components['schemas']['ENSYesNoType'];
      };
      /** @description Tag for data final flags element.  */
      dataFinalFlgs: {
        /** @description Indicates if the candidate list is final. */
        candListFinalFlg: components['schemas']['ENSYesNoType'];
        /** @description Indicates if the exit poll descriptions are final. */
        xpDescFinalFlg: components['schemas']['ENSYesNoType'];
      };
      districtCov?: {
        dType: components['schemas']['ENSDistrictTypeType'];
      }[];
      /** @description Tag for document key */
      key: {
        eDate: components['schemas']['ENSDateType'];
        eType: components['schemas']['ENSElectionTypeType'];
        jCde: components['schemas']['ENSJurisdictionCodeType'];
        jType: components['schemas']['ENSJurisdictionTypeType'];
        st: components['schemas']['ENSStateCodeTypeJson'];
        ofc: components['schemas']['ENSOfficeDesignationType'];
      };
    };
    /** @description Provides information on the political parties. */
    'party-lookup': {
      /** @description Collection of parties. */
      parties: {
        pId: components['schemas']['ENSPartyCodeType'];
        /** @description Party name abbreviation */
        ptyAbbv: string;
        /** @description Party name */
        ptyName: string;
      }[];
      /** @description Tag for document key. */
      key?: {
        eDate: components['schemas']['ENSDateType'];
      };
    };
    /** @description Contains the voting eligible population and optionally turnout as a percentage of the voting age population. */
    'editorial-turnout': {
      /** Format: date */
      eDate: string;
      jType: components['schemas']['ENSJurisdictionTypeType'];
      turnout?: {
        /** @description Turnout as a percentage of the voting age population. */
        vapTurnout?: components['schemas']['ENSPercentType'];
        /** @description Number of expected early by mail votes for the state */
        totExpEarlyByMailVote?: components['schemas']['ENSHugeNumberType'];
        /** @description Number of expected election day votes for the state */
        totExpEdayVote?: components['schemas']['ENSHugeNumberType'];
        /** @description Number of expected early in person votes for the state */
        totExpEarlyInPersonVote?: components['schemas']['ENSHugeNumberType'];
        /** @description Whether or not the contents the document are editorial. */
        isEdFlg?: components['schemas']['ENSYesNoType'];
        /** @description Number of expected absentee votes for the state */
        totExpAVote?: components['schemas']['ENSHugeNumberType'];
        /** @description Number of expected votes for the state */
        totExpVote?: components['schemas']['ENSHugeNumberType'];
        /** @description The proportion of the absentee vote expected out of the total vote in the state */
        sizeOfAbsentee?: number;
        /** @description Turnout as a percentage of the voting eligable population */
        vepTurnout?: components['schemas']['ENSPercentType'];
        /** @description Time that the turnout element data was approved. */
        timeOfApproval?: components['schemas']['RFC3339DateTime'];
      };
      /** @description Tag for document key */
      key: {
        /** Format: date */
        eDate: string;
        eType: components['schemas']['ENSElectionTypeType'];
        jCde: components['schemas']['ENSJurisdictionCodeType'];
        jType: components['schemas']['ENSJurisdictionTypeType'];
        st: components['schemas']['ENSStateCodeTypeJson'];
      };
      jCde: components['schemas']['ENSJurisdictionCodeType'];
      transSrc?: components['schemas']['ENSTransmissionSourceType'];
      ts: components['schemas']['RFC3339DateTime'];
      st: components['schemas']['ENSStateCodeTypeJson'];
      eType: components['schemas']['ENSElectionTypeType'];
      seq: components['schemas']['ENSSequenceNumberType'];
    };
    /** @description Contains research information on one election. It specifies past races of a specific election type for a given election date, state, and jurisdiction. */
    election: {
      /** @description Jurisdiction name abbreviation */
      jAbbv: string;
      /**
       * Format: float
       * @description Upper limit of the calculated turnout ratio for each county in the state.
       */
      maxCountyQa?: number;
      /** @description Tag for document key */
      key: {
        eDate: components['schemas']['ENSDateType'];
        eType: components['schemas']['ENSElectionTypeType'];
        jCde: components['schemas']['ENSJurisdictionCodeType'];
        jType: components['schemas']['ENSJurisdictionTypeType'];
        st: components['schemas']['ENSStateCodeTypeJson'];
      };
      /**
       * Format: float
       * @description The expected turnout ratio that is determined for each state/jurisdiction prior to an election.
       */
      turnoutRatio?: number;
      /** @description Number of electoral votes. Optional attribute, present only for statewide jurisdiction in a presidential general election. */
      numEVotes?: components['schemas']['ENSSmallNumberType'];
      /**
       * Format: float
       * @description Lower limit of the calculated turnout ratio for each county in the state.
       */
      minCountyQa?: number;
      /** @description Number of races in this election. */
      numRaces: components['schemas']['ENSTinyNumberType'];
      /** @description Date/time of polls opening */
      pollOpeningTime?: components['schemas']['ENSDateTimeType'];
      pastRace?: {
        eDate?: components['schemas']['ENSDateType'];
        jType?: components['schemas']['ENSJurisdictionTypeType'];
        isBaseRaceFlg?: components['schemas']['ENSYesNoType'];
        jCde?: components['schemas']['ENSJurisdictionCodeType'];
        isSizeRaceFlg?: components['schemas']['ENSYesNoType'];
        isComparisonRaceFlg?: components['schemas']['ENSYesNoType'];
        st?: components['schemas']['ENSStateCodeTypeJson'];
        ofc?: components['schemas']['ENSOfficeDesignationType'];
        eType?: components['schemas']['ENSElectionTypeType'];
      }[];
      /** @description Full election type name */
      eTypeName: string;
      /** @description Expected Vote Breakouts */
      expectedVoteBreakouts?: {
        edayVoteBreakoutFlg?: components['schemas']['ENSYesNoType'];
        earlyByMailVoteBreakoutFlg?: components['schemas']['ENSYesNoType'];
        earlyInPersonVoteBreakoutFlg?: components['schemas']['ENSYesNoType'];
        provisionalVoteBreakoutFlg?: components['schemas']['ENSYesNoType'];
      };
      /** @description The latest date and time when polls close. Date/time after which calls will be shown.
       *     Format is yyyymmddhhmm. */
      majorPollCloseTime: components['schemas']['ENSDateTimeType'];
      /**
       * Format: float
       * @description The proportion of the absentee vote expected out of the total vote in the state.
       */
      sizeOfAbsentee?: number;
      /** @description Number of national convention delegates. Optional attribute, present only for statewide jurisdictions in a presidential primary or caucus */
      numNatConvDelg?: components['schemas']['ENSSmallNumberType'];
      /** @description Full jurisdiction name. */
      jName: string;
    };
    /** @description An Estimate document contains ENS race calls for a single, unique contest. Within this document the cStat field will be set to either W for winner, R for reversal, or V for advances-to-runoff. */
    est: {
      /** Format: date */
      eDate: string;
      jType: components['schemas']['ENSJurisdictionTypeType'];
      /** @description Tag for document key */
      key: {
        /** Format: date */
        eDate: string;
        eType: components['schemas']['ENSElectionTypeType'];
        jCde: components['schemas']['ENSJurisdictionCodeType'];
        jType: components['schemas']['ENSJurisdictionTypeType'];
        st: components['schemas']['ENSStateCodeTypeJson'];
        ofc: components['schemas']['ENSOfficeDesignationType'];
      };
      cStat: components['schemas']['ENSCallStatusType'];
      /** @description Collection of candidate’s estimated vote percents. There is one instance per candidate */
      candidates: {
        /** @description Winning candidate. Distinguished from same attribute at candidate level by tag hierarchy. */
        cId: components['schemas']['ENSCandidateIdType'];
        /** @description Percentage of vote. */
        cPct?: components['schemas']['ENSPercentType'];
        /** @description Order of the finish */
        orderOfFinish?: components['schemas']['ENSTinyNumberType'];
        /** @description Indicates whether the candidate will be included in the runoff race */
        runoffCandidate?: components['schemas']['ENSYesNoType'];
      }[];
      /**
       * @description Percents status
       * @enum {string}
       */
      pStat?: 'N' | 'H';
      jCde: components['schemas']['ENSJurisdictionCodeType'];
      transSrc: components['schemas']['ENSTransmissionSourceType'];
      ts: components['schemas']['RFC3339DateTime'];
      st: components['schemas']['ENSStateCodeTypeJson'];
      ofc: components['schemas']['ENSOfficeDesignationType'];
      eType: components['schemas']['ENSElectionTypeType'];
      seq: components['schemas']['ENSSequenceNumberType'];
      /** @description Candidate ID if the leading candidate. */
      leadCId: components['schemas']['ENSCandidateIdType'];
    };
    /** @description delegate-district-type document.
     *
     *     Describes districts used to report on a particular election.
     *     Districts will be linked to races through the race element of the election document */
    'delegate-district-type': {
      eDate: components['schemas']['ENSDateType'];
      st: components['schemas']['ENSStateCodeTypeJson'];
      /** @description Tag for document key. */
      key?: {
        eDate: components['schemas']['ENSDateType'];
        st: components['schemas']['ENSStateCodeTypeJson'];
      };
      'district-types': {
        dType: string;
        dTypeName: string;
        dTypeAbbrev: string;
      }[];
    };
    /** @description Election day delegate allocations */
    'delegate-allocation': {
      /** Format: date */
      eDate: string;
      totPcts: components['schemas']['ENSPctNumberType'];
      scp: components['schemas']['ENSScpType'];
      jType: components['schemas']['ENSJurisdictionTypeType'];
      totVote?: components['schemas']['ENSHugeNumberType'];
      /** @description Tag for document key */
      key: {
        /** Format: date */
        eDate: string;
        eType: components['schemas']['ENSElectionTypeType'];
        jCde: components['schemas']['ENSJurisdictionCodeType'];
        jType: components['schemas']['ENSJurisdictionTypeType'];
        st: components['schemas']['ENSStateCodeTypeJson'];
        ofc: components['schemas']['ENSOfficeDesignationType'];
        dId: components['schemas']['ENSSmallNumberType'];
      };
      /** @description Optional tag for district level (instead of county of statewide level) votes */
      dist?: {
        dId: components['schemas']['ENSDistrictIdType'];
        dType: components['schemas']['ENSDistrictTypeType'];
      };
      /** @description Collection of single candidate’s vote/delegate results. There is one instance per candidate.   */
      candidates: {
        cId: components['schemas']['ENSCandidateIdType'];
        cVote: components['schemas']['ENSVoteCountType'];
      }[];
      pctsRep: components['schemas']['ENSPctNumberType'];
      proOut?: components['schemas']['ENSHugeNumberType'];
      jCde: components['schemas']['ENSJurisdictionCodeType'];
      transSrc: components['schemas']['ENSTransmissionSourceType'];
      ts: components['schemas']['RFC3339DateTime'];
      st: components['schemas']['ENSStateCodeTypeJson'];
      /** @description Optional tag present at race wide or county level. */
      flgs?: {
        absVotes?: string;
        complete?: components['schemas']['ENSYesNoType'];
        final?: components['schemas']['ENSYesNoType'];
        proVotes?: components['schemas']['ENSVoteTurnoutType'];
        repSrc: components['schemas']['ENSReportingSourceType'];
        verified?: components['schemas']['ENSYesNoType'];
      };
      ofc: components['schemas']['ENSOfficeDesignationType'];
      eType: components['schemas']['ENSElectionTypeType'];
      seq: components['schemas']['ENSSequenceNumberType'];
      cnty?: components['schemas']['ENSSmallNumberType'];
    };
    /** @description Provides a list of stream endpoints and their current max position */
    streams: {
      /** @description The document type is also the last part of the endpoint URI. */
      docType: string;
      /**
       * Format: int64
       * @description The current maximum position of the stream endpoint.
       */
      maxPosition: number;
    };
  };
  responses: never;
  parameters: never;
  requestBodies: never;
  headers: never;
  pathItems: never;
}
export type $defs = Record<string, never>;
export type operations = Record<string, never>;

[]

TypeScript coverage report