patents-mcp-server 1.0.0

package/dist/generated/odp/types.gen.d.ts

@@ -0,0 +1,4432 @@
+//#region src/generated/odp/types.gen.d.ts
+type ClientOptions = {
+  baseUrl: "https://api.uspto.gov" | (string & {});
+};
+type PatentSearchRequest = {
+  /**
+   * Search by field value or pass opensearch string query syntax
+   */
+  q?: string;
+  filters?: Array<Filter>;
+  rangeFilters?: Array<Range>;
+  sort?: Array<Sort2>;
+  fields?: Array<string>;
+  pagination?: Pagination;
+  facets?: Array<string>;
+};
+type PatentDownloadRequest = {
+  /**
+   * Search by field value or pass opensearch string query syntax
+   */
+  q?: string;
+  filters?: Array<Filter>;
+  rangeFilters?: Array<Range>;
+  sort?: Array<Sort2>;
+  fields?: Array<string>;
+  pagination?: Pagination;
+  /**
+   * Download format. csv or json
+   */
+  format?: "json" | "csv";
+};
+/**
+ * This json structure represents all data fields possible for a patent application. Not all fields mentioned here will be returned in API response, only fields that have data should present in the response.
+ */
+type PatentDataResponse = {
+  count?: number;
+  patentFileWrapperDataBag?: Array<{
+    /**
+     * Free format of application number
+     */
+    applicationNumberText?: string;
+    applicationMetaData?: ApplicationMetaData;
+    /**
+     * Collection of correspondences
+     */
+    correspondenceAddressBag?: Array<{
+      nameLineOneText?: string;
+      nameLineTwoText?: string;
+      addressLineOneText?: string;
+      addressLineTwoText?: string;
+      geographicRegionName?: string;
+      geographicRegionCode?: string;
+      postalCode?: string;
+      cityName?: string;
+      countryCode?: string;
+      countryName?: string;
+      postalAddressCategory?: string;
+    }>;
+    assignmentBag?: Array<Assignment>;
+    recordAttorney?: RecordAttorney;
+    foreignPriorityBag?: Array<ForeignPriority>;
+    parentContinuityBag?: Array<ParentContinuityData>;
+    childContinuityBag?: Array<ChildContinuityData>;
+    patentTermAdjustmentData?: PatentTermAdjustment;
+    eventDataBag?: Array<EventData>;
+    pgpubDocumentMetaData?: PgPubFileMetaData;
+    grantDocumentMetaData?: GrantFileMetaData;
+    lastIngestionDateTime?: string;
+  }>;
+  facets?: Array<{
+    applicationStatusCode?: Array<{
+      value?: string;
+      count?: number;
+    }>;
+  }>;
+};
+/**
+ * Represents patent application meta data properties
+ */
+type ApplicationMetaData = {
+  /**
+   * Indicates whether this application is a national application which entered the national stage from an international PCT application
+   */
+  nationalStageIndicator?: boolean;
+  /**
+   * Indicates the applicant's entity status
+   */
+  entityStatusData?: {
+    /**
+     * Indicates whether the applicant qualifies for small entity status
+     */
+    smallEntityStatusIndicator?: boolean;
+    /**
+     * Status of business entity being established for the purpose of paying a fee such as a filing fee and a maintenance fee
+     */
+    businessEntityStatusCategory?: string;
+  };
+  publicationDateBag?: Array<string>;
+  publicationSequenceNumberBag?: Array<string>;
+  publicationCategoryBag?: Array<string>;
+  docketNumber?: string;
+  firstInventorToFileIndicator?: string;
+  firstApplicantName?: string;
+  firstInventorName?: string;
+  applicationConfirmationNumber?: number;
+  applicationStatusDate?: string;
+  applicationStatusDescriptionText?: string;
+  /**
+   * The date assigned by the Patent Office that identifies when an application meets certain criteria to qualify as having been filed. Refers to ST.9 INID Code 22.
+   */
+  filingDate?: string;
+  /**
+   * The date according to PTO criteria that the patent case qualified as having been 'filed'.  The effective filing date is the same or later than the Filing Date.  The filing date can be changed due to a subsequent action on an application patent case.
+   */
+  effectiveFilingDate?: string;
+  grantDate?: string;
+  /**
+   * GAU Code
+   */
+  groupArtUnitNumber?: string;
+  /**
+   * Code corresponding to Utility, Plant, Design, or Reissue
+   */
+  applicationTypeCode?: string;
+  applicationTypeLabelName?: string;
+  applicationTypeCategory?: string;
+  inventionTitle?: string;
+  patentNumber?: string;
+  applicationStatusCode?: number;
+  /**
+   * Publication number corresponding to the earliest publication
+   */
+  earliestPublicationNumber?: string;
+  earliestPublicationDate?: string;
+  /**
+   * The unique identifier assigned to the publication of an international patent application in the PCT Gazette by the International Bureau (IB) of the World Intellectual Property Organization (WIPO).
+   */
+  pctPublicationNumber?: string;
+  pctPublicationDate?: string;
+  /**
+   * The date that the IPR is published by the International Bureau
+   */
+  internationalRegistrationPublicationDate?: string;
+  /**
+   * The number assigned by the International Bureau to an international registration upon registering an industrial design, a trademark or other type of IPR in the International Register
+   */
+  internationalRegistrationNumber?: string;
+  /**
+   * Name of patent examiner
+   */
+  examinerNameText?: string;
+  /**
+   * The first hierarchical level in the USPC classification schedule
+   */
+  class?: string;
+  /**
+   * The second highest hierarchical level  in the USP C classification schedule
+   */
+  subclass?: string;
+  /**
+   * The first hierarchical level in the USPC classification schedule/ The second highest hierarchical level in the USP C classification schedule
+   */
+  uspcSymbolText?: string;
+  /**
+   * Correspondence address of the application inherited from the customer.
+   */
+  customerNumber?: number;
+  /**
+   * Collection of Classifications for CPC
+   */
+  cpcClassificationBag?: Array<string>;
+  applicantBag?: Array<{
+    applicantNameText?: string;
+    firstName?: string;
+    middleName?: string;
+    lastName?: string;
+    preferredName?: string;
+    namePrefix?: string;
+    nameSuffix?: string;
+    countryCode?: string;
+    correspondenceAddressBag?: Array<{
+      nameLineOneText?: string;
+      nameLineTwoText?: string;
+      geographicRegionName?: string;
+      geographicRegionCode?: string;
+      cityName?: string;
+      countryCode?: string;
+      countryName?: string;
+      postalAddressCategory?: string;
+    }>;
+  }>;
+  inventorBag?: Array<{
+    firstName?: string;
+    middleName?: string;
+    lastName?: string;
+    namePrefix?: string;
+    nameSuffix?: string;
+    preferredName?: string;
+    countryCode?: string;
+    inventorNameText?: string;
+    correspondenceAddressBag?: Array<{
+      nameLineOneText?: string;
+      nameLineTwoText?: string;
+      geographicRegionName?: string;
+      geographicRegionCode?: string;
+      cityName?: string;
+      countryCode?: string;
+      countryName?: string;
+      postalAddressCategory?: string;
+    }>;
+  }>;
+};
+/**
+ * Patent term adjustment data
+ */
+type PatentTermAdjustment = {
+  /**
+   * A delays quantity number of adjustments to the term of the patent based upon USPTO delays included in the PTA determination that is mailed as part of the ISSUE NOTIFICATION LETTER.
+   */
+  aDelayQuantity?: number;
+  /**
+   * Patent term adjustment total quantity number that is a summation of NONOVERLAPPING USPTO DELAYS (+/- PTO MANUAL ADJUSTMENTS) - APPLICANT DELAYS.
+   */
+  adjustmentTotalQuantity?: number;
+  /**
+   * Patent term adjustment applicant delays quantity number of the patent term due to the Applicant's failure to engage in reasonable efforts to conclude prosecution of the application for the cumulative period in excess of three
+   */
+  applicantDayDelayQuantity?: number;
+  /**
+   * B delays quantity number of adjustments to the term of the patent based upon the patent failing to issue within three years of the actual filing date of the application at the time that the issue notification letter is generated and an issue date has been established.
+   */
+  bDelayQuantity?: number;
+  /**
+   * C delays quantity number of adjustments to the term of the patent based upon USPTO delays caused by interference proceedings, secrecy orders, and successful appellate reviews.
+   */
+  cDelayQuantity?: number;
+  /**
+   * Patent term adjustment non overlapping days quantity number of overall summation of the USPTO delays minus any overlapping days.
+   */
+  nonOverlappingDayQuantity?: number;
+  /**
+   * Patent term adjustment overlapping days quantity number that reflects the calculation of overlapping delays consistent with the federal circuit's interpretation.
+   */
+  overlappingDayQuantity?: number;
+  patentTermAdjustmentHistoryDataBag?: Array<{
+    /**
+     * The date that the symbol was assigned to the patent document
+     */
+    eventDate?: string;
+    applicantDayDelayQuantity?: number;
+    eventDescriptionText?: string;
+    eventSequenceNumber?: number;
+    /**
+     * Number of days the UPSTO personnel adjusting the calculation to increase or decrease the patent term adjustment based upon a request for reconsideration of the patent term adjustment.
+     */
+    ipOfficeDayDelayQuantity?: number;
+    originatingEventSequenceNumber?: number;
+    ptaPTECode?: string;
+  }>;
+};
+/**
+ * The collection of national assignments related to a patent
+ */
+type Assignment = {
+  /**
+   * 1-6 digit number identifies the reel number to be used to locate the assignment on microfilm.
+   */
+  reelNumber?: number;
+  /**
+   * 1-4 digit number that identifies the frame number to be used to locate the first image(page) of the assignment on microfilm.
+   */
+  frameNumber?: number;
+  reelAndFrameNumber?: string;
+  pageTotalQuantity?: number;
+  imageAvailableStatusCode?: boolean;
+  assignmentDocumentLocationURI?: string;
+  assignmentReceivedDate?: string;
+  assignmentRecordedDate?: string;
+  /**
+   * The date an assignment request was mailed to the office or received by the office
+   */
+  assignmentMailedDate?: string;
+  /**
+   * A description of the nature of the interest conveyed or transaction to be recorded in an assignment. Examples of the types of descriptions `include:` assignment, security agreement, merger, change of name, license, foreclosure, lien,
+   */
+  conveyanceText?: string;
+  assignorBag?: Array<{
+    assignorName?: string;
+    executionDate?: string;
+  }>;
+  assigneeBag?: Array<{
+    assigneeNameText?: string;
+    assigneeAddress?: {
+      addressLineOneText?: string;
+      addressLineTwoText?: string;
+      addressLineThreeText?: string;
+      addressLineFourText?: string;
+      cityName?: string;
+      geographicRegionName?: string;
+      geographicRegionCode?: string;
+      countryName?: string;
+      postalCode?: string;
+      countryOrStateCode?: string;
+      ictStateCode?: string;
+      ictCountryCode?: string;
+    };
+  }>;
+  correspondenceAddress?: {
+    [key: string]: unknown;
+  };
+  /**
+   * US representative for foreign entity
+   */
+  domesticRepresentative?: {
+    name?: string;
+    addressLineOneText?: string;
+    addressLineTwoText?: string;
+    addressLineThreeText?: string;
+    addressLineFourText?: string;
+    cityName?: string;
+    postalCode?: string;
+    geographicRegionName?: string;
+    countryName?: string;
+    emailAddress?: string;
+    lastIngestionDateTime?: string;
+  };
+};
+/**
+ * An attorney selected by the applicant or owner of an intellectual property to represent them before the national office.
+ */
+type RecordAttorney = {
+  /**
+   * Correspondence address of the application inherited from the customer.
+   */
+  customerNumberCorrespondenceData?: {
+    patronIdentifier?: number;
+    organizationStandardName?: string;
+    powerOfAttorneyAddressBag?: Array<{
+      nameLineOneText?: string;
+      addressLineOneText?: string;
+      addressLineTwoText?: string;
+      geographicRegionName?: string;
+      geographicRegionCode?: string;
+      postalCode?: string;
+      cityName?: string;
+      countryCode?: string;
+      countryName?: string;
+    }>;
+    telecommunicationAddressBag?: Array<{
+      telecommunicationNumber?: string;
+      extensionNumber?: string;
+      telecomTypeCode?: string;
+    }>;
+  };
+  powerOfAttorneyBag?: Array<{
+    firstName?: string;
+    middleName?: string;
+    lastName?: string;
+    namePrefix?: string;
+    nameSuffix?: string;
+    preferredName?: string;
+    countryCode?: string;
+    registrationNumber?: string;
+    activeIndicator?: string;
+    registeredPractitionerCategory?: string;
+    attorneyAddressBag?: Array<{
+      nameLineOneText?: string;
+      nameLineTwoText?: string;
+      addressLineOneText?: string;
+      addressLineTwoText?: string;
+      geographicRegionName?: string;
+      geographicRegionCode?: string;
+      postalCode?: string;
+      cityName?: string;
+      countryCode?: string;
+      countryName?: string;
+    }>;
+    telecommunicationAddressBag?: Array<{
+      telecommunicationNumber?: string;
+      extensionNumber?: string;
+      telecomTypeCode?: string;
+    }>;
+  }>;
+  attorneyBag?: Array<{
+    firstName?: string;
+    middleName?: string;
+    lastName?: string;
+    namePrefix?: string;
+    nameSuffix?: string;
+    registrationNumber?: string;
+    activeIndicator?: string;
+    registeredPractitionerCategory?: string;
+    attorneyAddressBag?: Array<{
+      nameLineOneText?: string;
+      nameLineTwoText?: string;
+      addressLineOneText?: string;
+      addressLineTwoText?: string;
+      geographicRegionName?: string;
+      geographicRegionCode?: string;
+      postalCode?: string;
+      cityName?: string;
+      countryCode?: string;
+      countryName?: string;
+    }>;
+    telecommunicationAddressBag?: Array<{
+      telecommunicationNumber?: string;
+      extensionNumber?: string;
+      telecomTypeCode?: string;
+    }>;
+  }>;
+};
+type ParentContinuityData = {
+  /**
+   * Indicates first inventor to file.
+   */
+  firstInventorToFileIndicator?: boolean;
+  parentApplicationStatusCode?: number;
+  parentPatentNumber?: string;
+  parentApplicationStatusDescriptionText?: string;
+  parentApplicationFilingDate?: string;
+  parentApplicationNumberText?: string;
+  childApplicationNumberText?: string;
+  claimParentageTypeCode?: string;
+  claimParentageTypeCodeDescriptionText?: string;
+};
+type ChildContinuityData = {
+  childApplicationStatusCode?: number;
+  parentApplicationNumberText?: string;
+  /**
+   * Application number of the child application, which is the unique value assigned by the USPTO to a patent application upon receipt
+   */
+  childApplicationNumberText?: string;
+  childApplicationStatusDescriptionText?: string;
+  childApplicationFilingDate?: string;
+  firstInventorToFileIndicator?: boolean;
+  childPatentNumber?: string;
+  claimParentageTypeCode?: string;
+  claimParentageTypeCodeDescriptionText?: string;
+};
+type ForeignPriority = {
+  ipOfficeName?: string;
+  filingDate?: string;
+  applicationNumberText?: string;
+};
+/**
+ * The date the patent case action was recorded.
+ */
+type EventData = {
+  eventCode?: string;
+  eventDescriptionText?: string;
+  /**
+   * The date the patent case action was recorded.
+   */
+  eventDate?: string;
+};
+type DocumentBag = {
+  documentBag?: Array<{
+    applicationNumberText?: string;
+    officialDate?: string;
+    documentIdentifier?: string;
+    documentCode?: string;
+    documentCodeDescriptionText?: string;
+    documentDirectionCategory?: string;
+    downloadOptionBag?: Array<{
+      mimeTypeIdentifier?: string;
+      downloadUrl?: string;
+      pageTotalQuantity?: number;
+    }>;
+  }>;
+};
+/**
+ * Contains pgpub zip and xml file meta data for an application
+ */
+type PgPubFileMetaData = {
+  zipFileName?: string;
+  productIdentifier?: string;
+  fileLocationURI?: string;
+  fileCreateDateTime?: string;
+  xmlFileName?: string;
+};
+/**
+ * Contains patent grant zip and xml file meta data for an application
+ */
+type GrantFileMetaData = {
+  zipFileName?: string;
+  productIdentifier?: string;
+  fileLocationURI?: string;
+  fileCreateDateTime?: string;
+  xmlFileName?: string;
+};
+/**
+ * This json structure represents data fields for status codes search API
+ */
+type StatusCodeSearchResponse = {
+  count?: number;
+  statusCodeBag?: Array<{
+    /**
+     * Application status code
+     */
+    applicationStatusCode?: number;
+    /**
+     * Application status code description
+     */
+    applicationStatusDescriptionText?: string;
+  }>;
+  requestIdentifier?: string;
+};
+type BdssResponseProductBag = {
+  count?: number;
+  bulkDataProductBag?: Array<BulkDataProductBag>;
+};
+type PetitionDecisionResponseBag = {
+  count?: number;
+  petitionDecisionDataBag?: Array<PetitionDecision>;
+  facets?: Array<PetitionDecisionFacet>;
+};
+type PetitionDecisionIdentifierResponseBag = {
+  count?: number;
+  petitionDecisionDataBag?: Array<PetitionDecisionAndDocuments>;
+};
+type ProceedingDataResponse = {
+  count?: number;
+  requestIdentifier?: string;
+  patentTrialProceedingDataBag?: Array<PatentTrialProceedingDataBag2>;
+};
+type PatentTrialProceedingDataBag = PatentTrialProceedingDataBag2;
+type DocumentDataResponse = {
+  count?: number;
+  patentTrialDocumentDataBag?: Array<PatentTrialDocumentDataBag2>;
+  facets?: Array<Facet>;
+};
+type PatentTrialDocumentDataBag = PatentTrialDocumentDataBag2;
+/**
+ * Identical structure, just decisions-only data.
+ */
+type DecisionDataResponse = DocumentDataResponse;
+type PatentTrialDecisionDataBag = PatentTrialDecisionDataBag2;
+type InterferenceDecisionDataResponse = {
+  count: number;
+  requestIdentifier: string;
+  patentInterferenceDataBag: Array<InterferenceDecisionRecord>;
+};
+type AppealDecisionDataResponse = {
+  count?: number;
+  patentAppealDataBag?: Array<PatentAppealDataBag2>;
+};
+type PatentAppealDataBag = PatentAppealDataBag2;
+type Q = ParamQ;
+type Sort = ParamSort;
+type Offset = ParamOffset;
+type Limit = ParamLimit;
+type Facets = ParamFacets;
+type Fields = ParamFields;
+type Filters = ParamFilters;
+type RangeFilters = ParamRangeFilters;
+type Format = ParamFormat;
+type BadRequestSchema = {
+  code?: unknown;
+  error?: unknown;
+  errorDetails?: unknown;
+  requestIdentifier?: unknown;
+};
+type ForbiddenSchema = {
+  code?: string;
+  error?: string;
+};
+type NotFoundSchema = {
+  code?: string;
+  error?: string;
+  errorDetails?: string;
+  requestIdentifier?: string;
+};
+type Status413 = {
+  code?: string;
+  message?: string;
+  detailedMessage?: string;
+  requestIdentifier?: string;
+};
+type InternalErrorSchema = {
+  code?: string;
+  error?: string;
+  errorDetails?: string;
+  requestIdentifier?: string;
+};
+/**
+ * A single PTAB trial proceeding record.
+ */
+type PatentTrialProceedingDataBag2 = {
+  trialNumber?: string;
+  lastModifiedDateTime?: string;
+  trialMetaData?: TrialMetaData;
+  patentOwnerData?: PatentOwnerData;
+  regularPetitionerData?: RegularPetitionerData;
+  respondentData?: RespondentData;
+  derivationPetitionerData?: DerivationPetitionerData;
+};
+type StatusCodeSearchRequest = {
+  /**
+   * Search by field value or pass opensearch string query syntax
+   */
+  q?: string;
+  pagination?: Pagination;
+};
+/**
+ * Add filters to your search request by providing filter name and filter value where name in filter request some field in data set.
+ */
+type Filter = {
+  name?: string;
+  value?: Array<string>;
+};
+/**
+ * Range filter. Provide field from dataset and valueFrom and valueTo. If range filter is for date field, date must be in “yyyy-MM-dd” format
+ */
+type Range = {
+  field?: string;
+  valueFrom?: string;
+  valueTo?: string;
+};
+/**
+ * Sort you search result by providing field to be sorted and sort order
+ */
+type Sort2 = {
+  field?: string;
+  /**
+   * Sort order. e.g. Asc, ASC, Desc, desc, DESC
+   */
+  order?: "Asc" | "asc" | "Desc" | "desc";
+};
+/**
+ * Pagination information.
+ */
+type Pagination = {
+  /**
+   * Start
+   */
+  offset?: number;
+  /**
+   * Maximum number of patent records to be returned in response
+   */
+  limit?: number;
+};
+/**
+ * Facet Description
+ */
+type Facet = {
+  value?: string;
+  count?: number;
+};
+/**
+ * Object representing the error response
+ */
+type Error = {
+  code?: 400 | 403 | 404 | 413 | 500;
+  description?: "Bad Request" | "Unauthorized" | "Not Found" | "Payload Too Large" | "Internal Server Error";
+  detailedError?: string;
+  requestIdentifier?: string;
+};
+type BulkDataProductBag = {
+  productIdentifier?: string;
+  productDescriptionText?: string;
+  productTitleText?: string;
+  productFrequencyText?: string;
+  daysOfWeekText?: string;
+  productLabelArrayText?: Array<string>;
+  productDataSetArrayText?: Array<string>;
+  productDataSetCategoryArrayText?: Array<string>;
+  productFromDate?: string;
+  productToDate?: string;
+  productTotalFileSize?: number;
+  productFileTotalQuantity?: number;
+  lastModifiedDateTime?: string;
+  mimeTypeIdentifierArrayText?: Array<string>;
+  productFileBag?: ProductFileBag;
+};
+type ProductFileBag = {
+  count?: number;
+  fileDataBag?: Array<{
+    fileName?: string;
+    fileSize?: number;
+    fileDataFromDate?: string;
+    fileDataToDate?: string;
+    fileTypeText?: string;
+    fileDownloadURI?: string;
+    fileReleaseDate?: string;
+    fileDate?: string;
+    fileLastModifiedDateTime?: string;
+  }>;
+};
+type BdssResponseBag = {
+  count?: number;
+  bulkDataProductBag?: Array<BulkDataProductBag>;
+  facets?: Facets2;
+};
+type Facets2 = {
+  productLabelArrayText?: Array<{
+    value?: string;
+    count?: number;
+  }>;
+  productDataSetArrayText?: Array<{
+    value?: string;
+    count?: number;
+  }>;
+  productCategoryArrayText?: Array<{
+    value?: string;
+    count?: number;
+  }>;
+  mimeTypeIdentifierArrayText?: Array<{
+    value?: string;
+    count?: number;
+  }>;
+  productFrequencyArrayText?: Array<{
+    value?: string;
+    count?: number;
+  }>;
+};
+/**
+ * Add filters to your search request by providing filter name and filter value where name in filter request some field in data set.
+ */
+type PetitionDecisionFilter = {
+  name?: string;
+  value?: Array<string>;
+};
+/**
+ * Range filter. Provide field from dataset and valueFrom and valueTo. If range filter is for date field, date must be in “yyyy-MM-dd” format
+ */
+type PetitionDecisionRange = {
+  field?: string;
+  valueFrom?: string;
+  valueTo?: string;
+};
+/**
+ * Sort you search result by providing field to be sorted and sort order
+ */
+type PetitionDecisionSort = {
+  field?: string;
+  /**
+   * Sort order. e.g. Asc, ASC, Desc, desc, DESC
+   */
+  order?: "Asc" | "asc" | "Desc" | "desc";
+};
+type Response400 = {
+  code?: unknown;
+  error?: unknown;
+  errorDetails?: unknown;
+  requestIdentifier?: unknown;
+};
+type Response403 = {
+  code?: unknown;
+  error?: unknown;
+};
+type Response404 = {
+  code?: unknown;
+  error?: unknown;
+  errorDetails?: unknown;
+  requestIdentifier?: unknown;
+};
+type Response500 = {
+  code?: unknown;
+  error?: unknown;
+  errorDetails?: unknown;
+  requestIdentifier?: unknown;
+};
+type PetitionDecisionSearchRequest = {
+  /**
+   * Search by field value or pass opensearch string query syntax
+   */
+  q?: string;
+  filters?: Array<PetitionDecisionFilter>;
+  rangeFilters?: Array<PetitionDecisionRange>;
+  sort?: Array<PetitionDecisionSort>;
+  fields?: Array<string>;
+  pagination?: Pagination;
+  facets?: Array<string>;
+};
+type PetitionDecisionDownloadRequest = {
+  /**
+   * Search by field value or pass opensearch string query syntax
+   */
+  q?: string;
+  filters?: Array<PetitionDecisionFilter>;
+  rangeFilters?: Array<PetitionDecisionRange>;
+  sort?: Array<PetitionDecisionSort>;
+  fields?: Array<string>;
+  pagination?: Pagination;
+  /**
+   * Download format. pdf,xml or docs
+   */
+  format?: "json" | "csv";
+};
+type PetitionDecision = {
+  petitionDecisionRecordIdentifier?: string;
+  applicationNumberText?: string;
+  businessEntityStatusCategory?: string;
+  customerNumber?: number;
+  decisionDate?: string;
+  decisionPetitionTypeCode?: number;
+  decisionTypeCode?: string;
+  decisionPetitionTypeCodeDescriptionText?: string;
+  finalDecidingOfficeName?: string;
+  firstApplicantName?: string;
+  firstInventorToFileIndicator?: boolean;
+  groupArtUnitNumber?: string;
+  technologyCenter?: string;
+  inventionTitle?: string;
+  inventorBag?: Array<string>;
+  actionTakenByCourtName?: string;
+  courtActionIndicator?: boolean;
+  lastIngestionDateTime?: string;
+  patentNumber?: string;
+  petitionIssueConsideredTextBag?: Array<string>;
+  petitionMailDate?: string;
+  prosecutionStatusCodeDescriptionText?: string;
+  ruleBag?: Array<string>;
+  statuteBag?: Array<string>;
+};
+type PetitionDecisionAndDocuments = PetitionDecision & {
+  documentBag?: Array<PetitionDecisionDocument>;
+};
+type PetitionDecisionFacetEntity = {
+  value?: string;
+  count?: number;
+};
+type PetitionDecisionFacet = {
+  technologyCenter?: Array<PetitionDecisionFacetEntity>;
+  finalDecidingOfficeName?: Array<PetitionDecisionFacetEntity>;
+  firstInventorToFileIndicator?: Array<PetitionDecisionFacetEntity>;
+  decisionPetitionTypeCode?: Array<PetitionDecisionFacetEntity>;
+  decisionTypeCodeDescriptionText?: Array<PetitionDecisionFacetEntity>;
+  prosecutionStatusCodeDescriptionText?: Array<PetitionDecisionFacetEntity>;
+  petitionIssueConsideredTextBag?: Array<PetitionDecisionFacetEntity>;
+  statuteBag?: Array<PetitionDecisionFacetEntity>;
+  ruleBag?: Array<PetitionDecisionFacetEntity>;
+  actionTakenByCourtName?: Array<PetitionDecisionFacetEntity>;
+  courtActionIndicator?: Array<PetitionDecisionFacetEntity>;
+  businessEntityStatusCategory?: Array<PetitionDecisionFacetEntity>;
+};
+type PetitionDecisionDocument = {
+  applicationNumberText?: string;
+  officialDate?: string;
+  documentIdentifier?: string;
+  documentCode?: string;
+  documentCodeDescriptionText?: string;
+  documentDirectionCategory?: string;
+  downloadOptionBag?: Array<{
+    mimeTypeIdentifier?: string;
+    documentURI?: string;
+    pageTotalQuantity?: number;
+  }>;
+};
+/**
+ * Boolean/wildcard search query string.
+ */
+type ParamQ = string;
+/**
+ * Field followed by sort order, e.g. 'fieldName desc'.
+ */
+type ParamSort = string;
+type ParamOffset = number;
+type ParamLimit = number;
+/**
+ * Comma-separated facet fields.
+ */
+type ParamFacets = string;
+/**
+ * Comma-separated field list to include in the response.
+ */
+type ParamFields = string;
+/**
+ * Whitespace-separated filters.
+ */
+type ParamFilters = string;
+/**
+ * Range filter: 'field YYYY-MM-DD:YYYY-MM-DD'.
+ */
+type ParamRangeFilters = string;
+type ParamFormat = "json" | "csv";
+type PatentAppealDataBag2 = {
+  appealNumber?: string;
+  lastModifiedDateTime?: string;
+  appealDocumentCategory?: string;
+  appealMetaData?: {
+    docketNoticeMailedDate?: string;
+    appealFilingDate?: string;
+    appealLastModifiedDate?: string;
+    appealLastModifiedDateTime?: string;
+    applicationTypeCategory?: string;
+    fileDownloadURI?: string;
+  };
+  appelantData?: {
+    applicationNumberText?: string;
+    counselName?: string;
+    groupArtUnitNumber?: string;
+    inventorName?: string;
+    realPartyName?: string;
+    patentNumber?: string;
+    patentOwnerName?: string;
+    publicationDate?: string;
+    publicationNumber?: string;
+    techCenterNumber?: string;
+  };
+  requestorData?: {
+    thirdPartyName?: string;
+  };
+  documentData?: {
+    documentFilingDate?: string;
+    documentIdentifier?: string;
+    documentName?: string;
+    documentSizeQuantity?: number;
+    documentOCRText?: string;
+    documentTypeCategory?: string;
+    downloadURI?: string;
+  };
+};
+type SearchRequest = PatentSearchRequest;
+type DownloadRequest = PatentDownloadRequest;
+type LookupRequest = {
+  trialNumber: string;
+};
+type TrialMetaData = {
+  accordedFilingDate?: string;
+  institutionDecisionDate?: string;
+  latestDecisionDate?: string;
+  petitionFilingDate?: string;
+  terminationDate?: string;
+  trialLastModifiedDateTime?: string;
+  trialLastModifiedDate?: string;
+  trialStatusCategory?: string;
+  trialTypeCode?: string;
+};
+type PatentOwnerData = {
+  applicationNumberText?: string;
+  counselName?: string;
+  grantDate?: string;
+  groupArtUnitNumber?: string;
+  inventorName?: string;
+  realPartyInInterestName?: string;
+  patentNumber?: string;
+  patentOwnerName?: string;
+  technologyCenterNumber?: string;
+};
+type RegularPetitionerData = {
+  counselName?: string;
+  realPartyInInterestName?: string;
+};
+type RespondentData = {
+  applicationNumberText?: string;
+  counselName?: string;
+  grantDate?: string;
+  groupArtUnitNumber?: string;
+  inventorName?: string;
+  realPartyInInterestName?: string;
+  patentNumber?: string;
+  patentOwnerName?: string;
+  technologyCenterNumber?: string;
+};
+type DerivationPetitionerData = {
+  applicationNumberText?: string;
+  counselName?: string;
+  grantDate?: string;
+  groupArtUnitNumber?: string;
+  inventorName?: string;
+  realPartyInInterestName?: string;
+  patentNumber?: string;
+  technologyCenterNumber?: string;
+  patentOwnerName?: string;
+};
+type DocumentData = {
+  documentCategory?: string;
+  documentFilingDate?: string;
+  documentIdentifier?: string;
+  documentName?: string;
+  documentNumber?: number;
+  documentSizeQuantity?: number;
+  documentOCRText?: string;
+  documentTitleText?: string;
+  documentTypeDescriptionText?: string;
+  downloadURI?: string;
+  filingPartyCategory?: string;
+  mimeTypeIdentifier?: string;
+  documentStatus?: string;
+};
+type DecisionData = {
+  statuteAndRuleBag?: Array<string>;
+  decisionIssueDate?: string;
+  decisionTypeCategory?: string;
+  issueTypeBag?: Array<string>;
+  trialOutcomeCategory?: string;
+};
+type FacetItem = {
+  name?: string;
+  quantity?: number;
+};
+type InterferenceDecisionRecord = {
+  interferenceNumber: string;
+  lastModifiedDateTime?: string;
+  interferenceMetaData?: {
+    interferenceStyleName?: string;
+    interferenceLastModifiedDate?: string;
+    fileDownloadURI?: string;
+  };
+  seniorPartyData?: InterferencePartyData;
+  juniorPartyData?: InterferencePartyData;
+  additionalPartyDataBag?: Array<{
+    applicationNumberText?: string;
+    inventorName?: string;
+    additionalPartyName?: string;
+    patentNumber?: string;
+  }>;
+  documentData?: InterferenceDecisionDocumentData;
+};
+type InterferencePartyData = {
+  applicationNumberText?: string;
+  counselName?: string;
+  grantDate?: string;
+  groupArtUnitNumber?: string;
+  inventorName?: string;
+  realPartyInInterestName?: string;
+  patentNumber?: string;
+  patentOwnerName?: string;
+  technologyCenterNumber?: string;
+  publicationDate?: string;
+  publicationNumber?: string;
+};
+type InterferenceDecisionDocumentData = {
+  documentFilingDate?: string;
+  documentIdentifier?: string;
+  documentName?: string;
+  documentSizeQuantity?: number;
+  documentOCRText?: string;
+  documentTitleText?: string;
+  downloadURI?: string;
+  statuteAndRuleBag?: Array<string>;
+  decisionIssueDate?: string;
+  decisionTypeCategory?: string;
+  issueTypeBag?: Array<string>;
+  interferenceOutcomeCategory?: string;
+};
+/**
+ * Decision records only (trialDocumentCategory = decision).
+ */
+type PatentTrialDecisionDataBag2 = PatentTrialDocumentDataBag2;
+/**
+ * A single PTAB document record.
+ */
+type PatentTrialDocumentDataBag2 = {
+  trialDocumentCategory?: string;
+  lastModifiedDateTime?: string;
+  trialNumber?: string;
+  trialTypeCode?: string;
+  trialMetaData?: TrialMetaData;
+  patentOwnerData?: PatentOwnerData;
+  regularPetitionerData?: RegularPetitionerData;
+  respondentData?: RespondentData;
+  derivationPetitionerData?: DerivationPetitionerData;
+  documentData?: DocumentData;
+  decisionData?: DecisionData;
+};
+type GetApiV1PatentApplicationsSearchData = {
+  body?: never;
+  path?: never;
+  query?: {
+    /**
+     * A search query string which accepts boolean operators (AND, OR, NOT), wildcards (*), and exact phrases ("").
+     */
+    q?: string;
+    /**
+     * Field to be sorted followed by sort order
+     */
+    sort?: string;
+    /**
+     * Position in the dataset of a particular record
+     */
+    offset?: number;
+    /**
+     * Limit the number of results returned
+     */
+    limit?: number;
+    /**
+     * List of fields names to be faceted upon separated by comma (<b>,</b>)
+     */
+    facets?: string;
+    /**
+     * Limits the response by specifying which fields from dataset should be included.
+     */
+    fields?: string;
+    /**
+     * Filter data by supplying filter parameter. Provide field name and its value.
+     */
+    filters?: string;
+    /**
+     * Filter the data by supplying range of values. Applicable for number and date type fields.
+     */
+    rangeFilters?: string;
+  };
+  url: "/api/v1/patent/applications/search";
+};
+type GetApiV1PatentApplicationsSearchErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: unknown;
+    error?: unknown;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Payload Too Large
+   */
+  413: Status413;
+  /**
+   * Internal Server Error
+   */
+  500: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+};
+type GetApiV1PatentApplicationsSearchError = GetApiV1PatentApplicationsSearchErrors[keyof GetApiV1PatentApplicationsSearchErrors];
+type GetApiV1PatentApplicationsSearchResponses = {
+  /**
+   * OK
+   */
+  200: PatentDataResponse;
+};
+type GetApiV1PatentApplicationsSearchResponse = GetApiV1PatentApplicationsSearchResponses[keyof GetApiV1PatentApplicationsSearchResponses];
+type PostApiV1PatentApplicationsSearchData = {
+  /**
+   * Patent data search request json payload. Fields in the request is optional
+   */
+  body?: PatentSearchRequest;
+  path?: never;
+  query?: never;
+  url: "/api/v1/patent/applications/search";
+};
+type PostApiV1PatentApplicationsSearchErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: unknown;
+    error?: unknown;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Payload Too Large
+   */
+  413: Status413;
+  /**
+   * Internal Server Error
+   */
+  500: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+};
+type PostApiV1PatentApplicationsSearchError = PostApiV1PatentApplicationsSearchErrors[keyof PostApiV1PatentApplicationsSearchErrors];
+type PostApiV1PatentApplicationsSearchResponses = {
+  /**
+   * OK
+   */
+  200: PatentDataResponse;
+};
+type PostApiV1PatentApplicationsSearchResponse = PostApiV1PatentApplicationsSearchResponses[keyof PostApiV1PatentApplicationsSearchResponses];
+type GetApiV1PatentApplicationsSearchDownloadData = {
+  body?: never;
+  path?: never;
+  query?: {
+    /**
+     * A search query string which accepts boolean operators (AND, OR, NOT), wildcards (*), and exact phrases ("").
+     */
+    q?: string;
+    /**
+     * field to be sorted followed by sort order
+     */
+    sort?: string;
+    /**
+     * Page number to begin with
+     */
+    offset?: number;
+    /**
+     * Limit the number of results returned
+     */
+    limit?: number;
+    /**
+     * Limits the response by specifying fields from dataset should be included.
+     */
+    fields?: string;
+    /**
+     * Filter data by supplying filter parameter. Provide field name and its value
+     */
+    filters?: string;
+    /**
+     * Filter the data by supplying range of values. Applicable for number and date type fields.
+     */
+    rangeFilters?: string;
+    /**
+     * Download Format
+     */
+    format?: string;
+  };
+  url: "/api/v1/patent/applications/search/download";
+};
+type GetApiV1PatentApplicationsSearchDownloadErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    message?: unknown;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Internal Server Error
+   */
+  500: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+};
+type GetApiV1PatentApplicationsSearchDownloadError = GetApiV1PatentApplicationsSearchDownloadErrors[keyof GetApiV1PatentApplicationsSearchDownloadErrors];
+type GetApiV1PatentApplicationsSearchDownloadResponses = {
+  /**
+   * OK
+   */
+  200: PatentDataResponse;
+};
+type GetApiV1PatentApplicationsSearchDownloadResponse = GetApiV1PatentApplicationsSearchDownloadResponses[keyof GetApiV1PatentApplicationsSearchDownloadResponses];
+type PostApiV1PatentApplicationsSearchDownloadData = {
+  /**
+   * Patent data search request json payload. Fields in the request is optional
+   */
+  body?: PatentDownloadRequest;
+  path?: never;
+  query?: never;
+  url: "/api/v1/patent/applications/search/download";
+};
+type PostApiV1PatentApplicationsSearchDownloadErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: unknown;
+    error?: unknown;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Internal Server Error
+   */
+  500: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+};
+type PostApiV1PatentApplicationsSearchDownloadError = PostApiV1PatentApplicationsSearchDownloadErrors[keyof PostApiV1PatentApplicationsSearchDownloadErrors];
+type PostApiV1PatentApplicationsSearchDownloadResponses = {
+  /**
+   * OK
+   */
+  200: PatentDataResponse;
+};
+type PostApiV1PatentApplicationsSearchDownloadResponse = PostApiV1PatentApplicationsSearchDownloadResponses[keyof PostApiV1PatentApplicationsSearchDownloadResponses];
+type GetApiV1PatentApplicationsByApplicationNumberTextData = {
+  body?: never;
+  path: {
+    /**
+     * Patent application number. <b>Note</b>:Application number having special character e.g PCT/BR00/000001 must be encoded with UTF-8 character encoding standard
+     */
+    applicationNumberText: string;
+  };
+  query?: never;
+  url: "/api/v1/patent/applications/{applicationNumberText}";
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: unknown;
+    error?: unknown;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Internal Server Error
+   */
+  500: {
+    code?: unknown;
+    error?: unknown;
+    errorDetailed?: unknown;
+    requestIdentifier?: unknown;
+  };
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextError = GetApiV1PatentApplicationsByApplicationNumberTextErrors[keyof GetApiV1PatentApplicationsByApplicationNumberTextErrors];
+type GetApiV1PatentApplicationsByApplicationNumberTextResponses = {
+  /**
+   * OK
+   */
+  200: PatentDataResponse;
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextResponse = GetApiV1PatentApplicationsByApplicationNumberTextResponses[keyof GetApiV1PatentApplicationsByApplicationNumberTextResponses];
+type GetApiV1PatentApplicationsByApplicationNumberTextMetaDataData = {
+  body?: never;
+  path: {
+    /**
+     * Patent application number
+     */
+    applicationNumberText: string;
+  };
+  query?: never;
+  url: "/api/v1/patent/applications/{applicationNumberText}/meta-data";
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextMetaDataErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: unknown;
+    error?: unknown;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Internal Server Error
+   */
+  500: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextMetaDataError = GetApiV1PatentApplicationsByApplicationNumberTextMetaDataErrors[keyof GetApiV1PatentApplicationsByApplicationNumberTextMetaDataErrors];
+type GetApiV1PatentApplicationsByApplicationNumberTextMetaDataResponses = {
+  /**
+   * Application meta data section
+   */
+  200: {
+    count?: unknown;
+    patentFileWrapperDataBag?: Array<{
+      /**
+       * Free format of application number
+       */
+      applicationNumberText?: string;
+      applicationMetaData?: ApplicationMetaData;
+    }>;
+    requestIdentifier?: unknown;
+  };
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextMetaDataResponse = GetApiV1PatentApplicationsByApplicationNumberTextMetaDataResponses[keyof GetApiV1PatentApplicationsByApplicationNumberTextMetaDataResponses];
+type GetApiV1PatentApplicationsByApplicationNumberTextAdjustmentData = {
+  body?: never;
+  path: {
+    /**
+     * Patent application number
+     */
+    applicationNumberText: string;
+  };
+  query?: never;
+  url: "/api/v1/patent/applications/{applicationNumberText}/adjustment";
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextAdjustmentErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: unknown;
+    error?: unknown;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Internal Server Error
+   */
+  500: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextAdjustmentError = GetApiV1PatentApplicationsByApplicationNumberTextAdjustmentErrors[keyof GetApiV1PatentApplicationsByApplicationNumberTextAdjustmentErrors];
+type GetApiV1PatentApplicationsByApplicationNumberTextAdjustmentResponses = {
+  /**
+   * OK
+   */
+  200: {
+    count?: number;
+    patentFileWrapperDataBag?: Array<{
+      /**
+       * Free format of application number
+       */
+      applicationNumberText?: string;
+      patentTermAdjustmentData?: PatentTermAdjustment;
+    }>;
+  };
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextAdjustmentResponse = GetApiV1PatentApplicationsByApplicationNumberTextAdjustmentResponses[keyof GetApiV1PatentApplicationsByApplicationNumberTextAdjustmentResponses];
+type GetApiV1PatentApplicationsByApplicationNumberTextAssignmentData = {
+  body?: never;
+  path: {
+    /**
+     * Patent application number
+     */
+    applicationNumberText: string;
+  };
+  query?: never;
+  url: "/api/v1/patent/applications/{applicationNumberText}/assignment";
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextAssignmentErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: unknown;
+    error?: unknown;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Internal Server Error
+   */
+  500: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextAssignmentError = GetApiV1PatentApplicationsByApplicationNumberTextAssignmentErrors[keyof GetApiV1PatentApplicationsByApplicationNumberTextAssignmentErrors];
+type GetApiV1PatentApplicationsByApplicationNumberTextAssignmentResponses = {
+  /**
+   * OK
+   */
+  200: {
+    count?: number;
+    patentFileWrapperDataBag?: Array<{
+      /**
+       * Free format of application number
+       */
+      applicationNumberText?: string;
+      assignmentBag?: Array<Assignment>;
+    }>;
+  };
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextAssignmentResponse = GetApiV1PatentApplicationsByApplicationNumberTextAssignmentResponses[keyof GetApiV1PatentApplicationsByApplicationNumberTextAssignmentResponses];
+type GetApiV1PatentApplicationsByApplicationNumberTextAttorneyData = {
+  body?: never;
+  path: {
+    /**
+     * Patent application number
+     */
+    applicationNumberText: string;
+  };
+  query?: never;
+  url: "/api/v1/patent/applications/{applicationNumberText}/attorney";
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextAttorneyErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: unknown;
+    error?: unknown;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Internal Server Error
+   */
+  500: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextAttorneyError = GetApiV1PatentApplicationsByApplicationNumberTextAttorneyErrors[keyof GetApiV1PatentApplicationsByApplicationNumberTextAttorneyErrors];
+type GetApiV1PatentApplicationsByApplicationNumberTextAttorneyResponses = {
+  /**
+   * OK
+   */
+  200: {
+    count?: number;
+    patentFileWrapperDataBag?: Array<{
+      /**
+       * Free format of application number
+       */
+      applicationNumberText?: string;
+      recordAttorney?: RecordAttorney;
+    }>;
+  };
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextAttorneyResponse = GetApiV1PatentApplicationsByApplicationNumberTextAttorneyResponses[keyof GetApiV1PatentApplicationsByApplicationNumberTextAttorneyResponses];
+type GetApiV1PatentApplicationsByApplicationNumberTextContinuityData = {
+  body?: never;
+  path: {
+    /**
+     * Patent application number
+     */
+    applicationNumberText: string;
+  };
+  query?: never;
+  url: "/api/v1/patent/applications/{applicationNumberText}/continuity";
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextContinuityResponses = {
+  /**
+   * OK
+   */
+  200: {
+    count?: number;
+    patentFileWrapperDataBag?: Array<{
+      /**
+       * Free format of application number
+       */
+      applicationNumberText?: string;
+      parentContinuityBag?: Array<ParentContinuityData>;
+      childContinuityBag?: Array<ChildContinuityData>;
+      requestIdentifier?: string;
+    }>;
+  };
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextContinuityResponse = GetApiV1PatentApplicationsByApplicationNumberTextContinuityResponses[keyof GetApiV1PatentApplicationsByApplicationNumberTextContinuityResponses];
+type GetApiV1PatentApplicationsByApplicationNumberTextForeignPriorityData = {
+  body?: never;
+  path: {
+    /**
+     * Patent application number
+     */
+    applicationNumberText: string;
+  };
+  query?: never;
+  url: "/api/v1/patent/applications/{applicationNumberText}/foreign-priority";
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextForeignPriorityErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: unknown;
+    error?: unknown;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Internal Server Error
+   */
+  500: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextForeignPriorityError = GetApiV1PatentApplicationsByApplicationNumberTextForeignPriorityErrors[keyof GetApiV1PatentApplicationsByApplicationNumberTextForeignPriorityErrors];
+type GetApiV1PatentApplicationsByApplicationNumberTextForeignPriorityResponses = {
+  /**
+   * OK
+   */
+  200: {
+    count?: number;
+    patentFileWrapperDataBag?: Array<{
+      /**
+       * Free format of application number
+       */
+      applicationNumberText?: string;
+      foreignPriorityBag?: Array<ForeignPriority>;
+    }>;
+  };
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextForeignPriorityResponse = GetApiV1PatentApplicationsByApplicationNumberTextForeignPriorityResponses[keyof GetApiV1PatentApplicationsByApplicationNumberTextForeignPriorityResponses];
+type GetApiV1PatentApplicationsByApplicationNumberTextTransactionsData = {
+  body?: never;
+  path: {
+    /**
+     * Patent application number
+     */
+    applicationNumberText: string;
+  };
+  query?: never;
+  url: "/api/v1/patent/applications/{applicationNumberText}/transactions";
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextTransactionsErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: unknown;
+    error?: unknown;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Internal Server Error
+   */
+  500: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextTransactionsError = GetApiV1PatentApplicationsByApplicationNumberTextTransactionsErrors[keyof GetApiV1PatentApplicationsByApplicationNumberTextTransactionsErrors];
+type GetApiV1PatentApplicationsByApplicationNumberTextTransactionsResponses = {
+  /**
+   * OK
+   */
+  200: {
+    count?: number;
+    patentFileWrapperDataBag?: Array<{
+      /**
+       * Free format of application number
+       */
+      applicationNumberText?: string;
+      eventDataBag?: Array<EventData>;
+    }>;
+  };
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextTransactionsResponse = GetApiV1PatentApplicationsByApplicationNumberTextTransactionsResponses[keyof GetApiV1PatentApplicationsByApplicationNumberTextTransactionsResponses];
+type GetApiV1PatentApplicationsByApplicationNumberTextDocumentsData = {
+  body?: never;
+  path: {
+    /**
+     * application number
+     */
+    applicationNumberText: string;
+  };
+  query?: {
+    /**
+     * single or multiple comma separated document codes
+     */
+    documentCodes?: string;
+    /**
+     * Search by document official date from
+     */
+    officialDateFrom?: string;
+    /**
+     * Search by document official date to
+     */
+    officialDateTo?: string;
+  };
+  url: "/api/v1/patent/applications/{applicationNumberText}/documents";
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextDocumentsErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: unknown;
+    error?: unknown;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Internal Server Error
+   */
+  500: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextDocumentsError = GetApiV1PatentApplicationsByApplicationNumberTextDocumentsErrors[keyof GetApiV1PatentApplicationsByApplicationNumberTextDocumentsErrors];
+type GetApiV1PatentApplicationsByApplicationNumberTextDocumentsResponses = {
+  /**
+   * OK
+   */
+  200: DocumentBag;
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextDocumentsResponse = GetApiV1PatentApplicationsByApplicationNumberTextDocumentsResponses[keyof GetApiV1PatentApplicationsByApplicationNumberTextDocumentsResponses];
+type GetApiV1PatentApplicationsByApplicationNumberTextAssociatedDocumentsData = {
+  body?: never;
+  path: {
+    /**
+     * application number
+     */
+    applicationNumberText: string;
+  };
+  query?: never;
+  url: "/api/v1/patent/applications/{applicationNumberText}/associated-documents";
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextAssociatedDocumentsErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: unknown;
+    error?: unknown;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Internal Server Error
+   */
+  500: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextAssociatedDocumentsError = GetApiV1PatentApplicationsByApplicationNumberTextAssociatedDocumentsErrors[keyof GetApiV1PatentApplicationsByApplicationNumberTextAssociatedDocumentsErrors];
+type GetApiV1PatentApplicationsByApplicationNumberTextAssociatedDocumentsResponses = {
+  /**
+   * OK
+   */
+  200: {
+    count?: number;
+    patentFileWrapperDataBag?: Array<{
+      /**
+       * Free format of application number
+       */
+      applicationNumberText?: string;
+      pgpubDocumentMetaData?: PgPubFileMetaData;
+      grantDocumentMetaData?: GrantFileMetaData;
+      requestIdentifier?: string;
+    }>;
+  };
+};
+type GetApiV1PatentApplicationsByApplicationNumberTextAssociatedDocumentsResponse = GetApiV1PatentApplicationsByApplicationNumberTextAssociatedDocumentsResponses[keyof GetApiV1PatentApplicationsByApplicationNumberTextAssociatedDocumentsResponses];
+type GetApiV1PatentStatusCodesData = {
+  body?: never;
+  path?: never;
+  query?: {
+    /**
+     * A search query string which accepts boolean operators (AND, OR, NOT), wildcards (*), and exact phrases ("").
+     */
+    q?: string;
+    /**
+     * Position in the dataset of a particular record
+     */
+    offset?: number;
+    /**
+     * Limit the number of results returned
+     */
+    limit?: number;
+  };
+  url: "/api/v1/patent/status-codes";
+};
+type GetApiV1PatentStatusCodesErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: unknown;
+    error?: unknown;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Internal Server Error
+   */
+  500: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+};
+type GetApiV1PatentStatusCodesError = GetApiV1PatentStatusCodesErrors[keyof GetApiV1PatentStatusCodesErrors];
+type GetApiV1PatentStatusCodesResponses = {
+  /**
+   * OK
+   */
+  200: StatusCodeSearchResponse;
+};
+type GetApiV1PatentStatusCodesResponse = GetApiV1PatentStatusCodesResponses[keyof GetApiV1PatentStatusCodesResponses];
+type PostApiV1PatentStatusCodesData = {
+  /**
+   * Patent status code search request json payload. All fields in the request are optional
+   */
+  body?: StatusCodeSearchRequest;
+  path?: never;
+  query?: never;
+  url: "/api/v1/patent/status-codes";
+};
+type PostApiV1PatentStatusCodesErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: unknown;
+    error?: unknown;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Internal Server Error
+   */
+  500: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+};
+type PostApiV1PatentStatusCodesError = PostApiV1PatentStatusCodesErrors[keyof PostApiV1PatentStatusCodesErrors];
+type PostApiV1PatentStatusCodesResponses = {
+  /**
+   * OK
+   */
+  200: StatusCodeSearchResponse;
+};
+type PostApiV1PatentStatusCodesResponse = PostApiV1PatentStatusCodesResponses[keyof PostApiV1PatentStatusCodesResponses];
+type GetApiV1DatasetsProductsSearchData = {
+  body?: never;
+  path?: never;
+  query?: {
+    /**
+     * A search query string which accepts boolean operators (AND, OR, NOT), wildcards (*), and exact phrases ("").
+     */
+    q?: string;
+    /**
+     * field to be sorted followed by sort order
+     */
+    sort?: string;
+    /**
+     * Position in the dataset of a particular record
+     */
+    offset?: number;
+    /**
+     * Limit the number of results returned
+     */
+    limit?: number;
+    /**
+     * List of fields names to be faceted upon separated by comma (<b>,</b>)
+     */
+    facets?: string;
+    /**
+     * Limits the response by specifying fields from dataset should be included.
+     */
+    fields?: string;
+    /**
+     * Filter data by supplying filter parameter. Provide field name and its value
+     */
+    filters?: string;
+    /**
+     * Filter the data by supplying range of values. Applicable for number and date type fields.
+     */
+    rangeFilters?: string;
+  };
+  url: "/api/v1/datasets/products/search";
+};
+type GetApiV1DatasetsProductsSearchErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: unknown;
+    error?: unknown;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Internal Server Error
+   */
+  500: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+};
+type GetApiV1DatasetsProductsSearchError = GetApiV1DatasetsProductsSearchErrors[keyof GetApiV1DatasetsProductsSearchErrors];
+type GetApiV1DatasetsProductsSearchResponses = {
+  /**
+   * OK
+   */
+  200: BdssResponseBag;
+};
+type GetApiV1DatasetsProductsSearchResponse = GetApiV1DatasetsProductsSearchResponses[keyof GetApiV1DatasetsProductsSearchResponses];
+type GetApiV1DatasetsProductsByProductIdentifierData = {
+  body?: never;
+  path: {
+    /**
+     * productIdentifier represents product Short name
+     */
+    productIdentifier: string;
+  };
+  query?: {
+    /**
+     * fileDataFromDate
+     */
+    fileDataFromDate?: string;
+    /**
+     * fileDataToDate
+     */
+    fileDataToDate?: string;
+    /**
+     * Number of product file records to skip
+     */
+    offset?: number;
+    /**
+     * Number of product file records to collect
+     */
+    limit?: number;
+    /**
+     * value true if product files should be included or false if they should be omitted from the response
+     */
+    includeFiles?: string;
+    /**
+     * value is true if only the latest product file should be returned for this specific product
+     */
+    latest?: string;
+  };
+  url: "/api/v1/datasets/products/{productIdentifier}";
+};
+type GetApiV1DatasetsProductsByProductIdentifierErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: unknown;
+    error?: unknown;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Internal Server Error
+   */
+  500: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+};
+type GetApiV1DatasetsProductsByProductIdentifierError = GetApiV1DatasetsProductsByProductIdentifierErrors[keyof GetApiV1DatasetsProductsByProductIdentifierErrors];
+type GetApiV1DatasetsProductsByProductIdentifierResponses = {
+  /**
+   * OK
+   */
+  200: BdssResponseProductBag;
+};
+type GetApiV1DatasetsProductsByProductIdentifierResponse = GetApiV1DatasetsProductsByProductIdentifierResponses[keyof GetApiV1DatasetsProductsByProductIdentifierResponses];
+type GetApiV1DatasetsProductsFilesByProductIdentifierByFileNameData = {
+  body?: never;
+  path: {
+    productIdentifier: string;
+    fileName: string;
+  };
+  query?: never;
+  url: "/api/v1/datasets/products/files/{productIdentifier}/{fileName}";
+};
+type GetApiV1PetitionDecisionsSearchData = {
+  body?: never;
+  path?: never;
+  query?: {
+    /**
+     * A search query string which accepts boolean operators (AND, OR, NOT), wildcards (*), and exact phrases ("").
+     */
+    q?: string;
+    /**
+     * field to be sorted followed by sort order
+     */
+    sort?: string;
+    /**
+     * Position in the dataset of a particular record
+     */
+    offset?: number;
+    /**
+     * Limit the number of results returned
+     */
+    limit?: number;
+    /**
+     * List of fields names to be faceted upon separated by comma (<b>,</b>)
+     */
+    facets?: string;
+    /**
+     * Limits the response by specifying fields from dataset should be included.
+     */
+    fields?: string;
+    /**
+     * Filter data by supplying filter parameter. Provide field name and its value
+     */
+    filters?: string;
+    /**
+     * Filter the data by supplying range of values. Applicable for number and date type fields.
+     */
+    rangeFilters?: string;
+  };
+  url: "/api/v1/petition/decisions/search";
+};
+type GetApiV1PetitionDecisionsSearchErrors = {
+  /**
+   * Bad Request
+   */
+  400: Response400;
+  /**
+   * Forbidden
+   */
+  403: Response403;
+  /**
+   * Not Found
+   */
+  404: Response404;
+  /**
+   * Internal Server Error
+   */
+  500: Response500;
+};
+type GetApiV1PetitionDecisionsSearchError = GetApiV1PetitionDecisionsSearchErrors[keyof GetApiV1PetitionDecisionsSearchErrors];
+type GetApiV1PetitionDecisionsSearchResponses = {
+  /**
+   * OK
+   */
+  200: PetitionDecisionResponseBag;
+};
+type GetApiV1PetitionDecisionsSearchResponse = GetApiV1PetitionDecisionsSearchResponses[keyof GetApiV1PetitionDecisionsSearchResponses];
+type PostApiV1PetitionDecisionsSearchData = {
+  /**
+   * Petition Decision data search request json payload. Fields in the request is optional
+   */
+  body?: PetitionDecisionSearchRequest;
+  path?: never;
+  query?: never;
+  url: "/api/v1/petition/decisions/search";
+};
+type PostApiV1PetitionDecisionsSearchErrors = {
+  /**
+   * Bad Request
+   */
+  400: Response400;
+  /**
+   * Forbidden
+   */
+  403: Response403;
+  /**
+   * Not Found
+   */
+  404: Response404;
+  /**
+   * Internal Server Error
+   */
+  500: Response500;
+};
+type PostApiV1PetitionDecisionsSearchError = PostApiV1PetitionDecisionsSearchErrors[keyof PostApiV1PetitionDecisionsSearchErrors];
+type PostApiV1PetitionDecisionsSearchResponses = {
+  /**
+   * OK
+   */
+  200: PetitionDecisionResponseBag;
+};
+type PostApiV1PetitionDecisionsSearchResponse = PostApiV1PetitionDecisionsSearchResponses[keyof PostApiV1PetitionDecisionsSearchResponses];
+type GetApiV1PetitionDecisionsSearchDownloadData = {
+  body?: never;
+  path?: never;
+  query?: {
+    /**
+     * A search query string which accepts boolean operators (AND, OR, NOT), wildcards (*), and exact phrases ("").
+     */
+    q?: string;
+    /**
+     * field to be sorted followed by sort order
+     */
+    sort?: string;
+    /**
+     * Position in the dataset of a particular record
+     */
+    offset?: number;
+    /**
+     * Limit the number of results returned
+     */
+    limit?: number;
+    /**
+     * Limits the response by specifying fields from dataset should be included.
+     */
+    fields?: string;
+    /**
+     * Filter data by supplying filter parameter. Provide field name and its value
+     */
+    filters?: string;
+    /**
+     * Filter the data by supplying range of values. Applicable for number and date type fields.
+     */
+    rangeFilters?: string;
+    /**
+     * Download Format
+     */
+    format?: string;
+  };
+  url: "/api/v1/petition/decisions/search/download";
+};
+type GetApiV1PetitionDecisionsSearchDownloadErrors = {
+  /**
+   * Bad Request
+   */
+  400: Response400;
+  /**
+   * Forbidden
+   */
+  403: Response403;
+  /**
+   * Not Found
+   */
+  404: Response404;
+  /**
+   * Internal Server Error
+   */
+  500: Response500;
+};
+type GetApiV1PetitionDecisionsSearchDownloadError = GetApiV1PetitionDecisionsSearchDownloadErrors[keyof GetApiV1PetitionDecisionsSearchDownloadErrors];
+type GetApiV1PetitionDecisionsSearchDownloadResponses = {
+  /**
+   * OK
+   */
+  200: PetitionDecisionResponseBag;
+};
+type GetApiV1PetitionDecisionsSearchDownloadResponse = GetApiV1PetitionDecisionsSearchDownloadResponses[keyof GetApiV1PetitionDecisionsSearchDownloadResponses];
+type PostApiV1PetitionDecisionsSearchDownloadData = {
+  /**
+   * Petition decision data search request json payload. Fields in the request is optional
+   */
+  body?: PetitionDecisionDownloadRequest;
+  path?: never;
+  query?: never;
+  url: "/api/v1/petition/decisions/search/download";
+};
+type PostApiV1PetitionDecisionsSearchDownloadErrors = {
+  /**
+   * Bad Request
+   */
+  400: Response400;
+  /**
+   * Forbidden
+   */
+  403: Response403;
+  /**
+   * Not Found
+   */
+  404: Response404;
+  /**
+   * Internal Server Error
+   */
+  500: Response500;
+};
+type PostApiV1PetitionDecisionsSearchDownloadError = PostApiV1PetitionDecisionsSearchDownloadErrors[keyof PostApiV1PetitionDecisionsSearchDownloadErrors];
+type PostApiV1PetitionDecisionsSearchDownloadResponses = {
+  /**
+   * OK
+   */
+  200: PetitionDecisionResponseBag;
+};
+type PostApiV1PetitionDecisionsSearchDownloadResponse = PostApiV1PetitionDecisionsSearchDownloadResponses[keyof PostApiV1PetitionDecisionsSearchDownloadResponses];
+type GetApiV1PetitionDecisionsByPetitionDecisionRecordIdentifierData = {
+  body?: never;
+  path: {
+    /**
+     * Petition Decision number
+     */
+    petitionDecisionRecordIdentifier: string;
+  };
+  query?: {
+    /**
+     * This is a true or false...yes to include petition decision documents in the response and no to omit the petition decision documents from the response
+     */
+    includeDocuments?: boolean;
+  };
+  url: "/api/v1/petition/decisions/{petitionDecisionRecordIdentifier}";
+};
+type GetApiV1PetitionDecisionsByPetitionDecisionRecordIdentifierErrors = {
+  /**
+   * Bad Request
+   */
+  400: Response400;
+  /**
+   * Forbidden
+   */
+  403: Response403;
+  /**
+   * Not Found
+   */
+  404: Response404;
+  /**
+   * Internal Server Error
+   */
+  500: Response500;
+};
+type GetApiV1PetitionDecisionsByPetitionDecisionRecordIdentifierError = GetApiV1PetitionDecisionsByPetitionDecisionRecordIdentifierErrors[keyof GetApiV1PetitionDecisionsByPetitionDecisionRecordIdentifierErrors];
+type GetApiV1PetitionDecisionsByPetitionDecisionRecordIdentifierResponses = {
+  /**
+   * OK
+   */
+  200: PetitionDecisionIdentifierResponseBag;
+};
+type GetApiV1PetitionDecisionsByPetitionDecisionRecordIdentifierResponse = GetApiV1PetitionDecisionsByPetitionDecisionRecordIdentifierResponses[keyof GetApiV1PetitionDecisionsByPetitionDecisionRecordIdentifierResponses];
+type GetApiV1PatentTrialsProceedingsSearchData = {
+  body?: never;
+  path?: never;
+  query?: {
+    /**
+     * A search query string which accepts boolean operators (AND, OR, NOT), wildcards (*), and exact phrases ("").
+     */
+    q?: string;
+    /**
+     * Field to be sorted followed by sort order
+     */
+    sort?: string;
+    /**
+     * Position in the dataset of a particular record
+     */
+    offset?: number;
+    /**
+     * Limit the number of results returned
+     */
+    limit?: number;
+    /**
+     * List of fields names to be faceted upon separated by comma (<b>,</b>)
+     */
+    facets?: string;
+    /**
+     * Limits the response by specifying which fields from dataset should be included.
+     */
+    fields?: string;
+    /**
+     * Filter data by supplying filter parameter. Provide field name and its value.
+     */
+    filters?: string;
+    /**
+     * Filter the data by supplying range of values. Applicable for number and date type fields.
+     */
+    rangeFilters?: string;
+  };
+  url: "/api/v1/patent/trials/proceedings/search";
+};
+type GetApiV1PatentTrialsProceedingsSearchErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type GetApiV1PatentTrialsProceedingsSearchError = GetApiV1PatentTrialsProceedingsSearchErrors[keyof GetApiV1PatentTrialsProceedingsSearchErrors];
+type GetApiV1PatentTrialsProceedingsSearchResponses = {
+  /**
+   * OK
+   */
+  200: ProceedingDataResponse;
+};
+type GetApiV1PatentTrialsProceedingsSearchResponse = GetApiV1PatentTrialsProceedingsSearchResponses[keyof GetApiV1PatentTrialsProceedingsSearchResponses];
+type PostApiV1PatentTrialsProceedingsSearchData = {
+  body: SearchRequest;
+  path?: never;
+  query?: never;
+  url: "/api/v1/patent/trials/proceedings/search";
+};
+type PostApiV1PatentTrialsProceedingsSearchErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type PostApiV1PatentTrialsProceedingsSearchError = PostApiV1PatentTrialsProceedingsSearchErrors[keyof PostApiV1PatentTrialsProceedingsSearchErrors];
+type PostApiV1PatentTrialsProceedingsSearchResponses = {
+  /**
+   * OK
+   */
+  200: ProceedingDataResponse;
+};
+type PostApiV1PatentTrialsProceedingsSearchResponse = PostApiV1PatentTrialsProceedingsSearchResponses[keyof PostApiV1PatentTrialsProceedingsSearchResponses];
+type GetApiV1PatentTrialsProceedingsSearchDownloadData = {
+  body?: never;
+  path?: never;
+  query?: {
+    /**
+     * A search query string which accepts boolean operators (AND, OR, NOT), wildcards (*), and exact phrases ("").
+     */
+    q?: string;
+    /**
+     * Field to be sorted followed by sort order
+     */
+    sort?: string;
+    /**
+     * Position in the dataset of a particular record
+     */
+    offset?: number;
+    /**
+     * Limit the number of results returned
+     */
+    limit?: number;
+    /**
+     * List of fields names to be faceted upon separated by comma (<b>,</b>)
+     */
+    facets?: string;
+    /**
+     * Limits the response by specifying which fields from dataset should be included.
+     */
+    fields?: string;
+    /**
+     * Filter data by supplying filter parameter. Provide field name and its value.
+     */
+    filters?: string;
+    /**
+     * Filter the data by supplying range of values. Applicable for number and date type fields.
+     */
+    rangeFilters?: string;
+    /**
+     * Download Format
+     */
+    format?: string;
+  };
+  url: "/api/v1/patent/trials/proceedings/search/download";
+};
+type GetApiV1PatentTrialsProceedingsSearchDownloadErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type GetApiV1PatentTrialsProceedingsSearchDownloadError = GetApiV1PatentTrialsProceedingsSearchDownloadErrors[keyof GetApiV1PatentTrialsProceedingsSearchDownloadErrors];
+type GetApiV1PatentTrialsProceedingsSearchDownloadResponses = {
+  /**
+   * OK
+   */
+  200: ProceedingDataResponse;
+};
+type GetApiV1PatentTrialsProceedingsSearchDownloadResponse = GetApiV1PatentTrialsProceedingsSearchDownloadResponses[keyof GetApiV1PatentTrialsProceedingsSearchDownloadResponses];
+type PostApiV1PatentTrialsProceedingsSearchDownloadData = {
+  /**
+   * Proceeding download request. Same structure as PatentDownloadRequest.
+   */
+  body: DownloadRequest;
+  path?: never;
+  query?: never;
+  url: "/api/v1/patent/trials/proceedings/search/download";
+};
+type PostApiV1PatentTrialsProceedingsSearchDownloadErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type PostApiV1PatentTrialsProceedingsSearchDownloadError = PostApiV1PatentTrialsProceedingsSearchDownloadErrors[keyof PostApiV1PatentTrialsProceedingsSearchDownloadErrors];
+type PostApiV1PatentTrialsProceedingsSearchDownloadResponses = {
+  /**
+   * OK
+   */
+  200: ProceedingDataResponse;
+};
+type PostApiV1PatentTrialsProceedingsSearchDownloadResponse = PostApiV1PatentTrialsProceedingsSearchDownloadResponses[keyof PostApiV1PatentTrialsProceedingsSearchDownloadResponses];
+type GetApiV1PatentTrialsProceedingsByTrialNumberData = {
+  body?: never;
+  path: {
+    /**
+     * trialNumber number.
+     */
+    trialNumber: string;
+  };
+  query?: never;
+  url: "/api/v1/patent/trials/proceedings/{trialNumber}";
+};
+type GetApiV1PatentTrialsProceedingsByTrialNumberErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type GetApiV1PatentTrialsProceedingsByTrialNumberError = GetApiV1PatentTrialsProceedingsByTrialNumberErrors[keyof GetApiV1PatentTrialsProceedingsByTrialNumberErrors];
+type GetApiV1PatentTrialsProceedingsByTrialNumberResponses = {
+  /**
+   * OK
+   */
+  200: ProceedingDataResponse;
+};
+type GetApiV1PatentTrialsProceedingsByTrialNumberResponse = GetApiV1PatentTrialsProceedingsByTrialNumberResponses[keyof GetApiV1PatentTrialsProceedingsByTrialNumberResponses];
+type GetApiV1PatentTrialsDecisionsSearchData = {
+  body?: never;
+  path?: never;
+  query?: {
+    /**
+     * A search query string which accepts boolean operators (AND, OR, NOT), wildcards (*), and exact phrases ("").
+     */
+    q?: string;
+    /**
+     * Field to be sorted followed by sort order
+     */
+    sort?: string;
+    /**
+     * Position in the dataset of a particular record
+     */
+    offset?: number;
+    /**
+     * Limit the number of results returned
+     */
+    limit?: number;
+    /**
+     * List of fields names to be faceted upon separated by comma (<b>,</b>)
+     */
+    facets?: string;
+    /**
+     * Limits the response by specifying which fields from dataset should be included.
+     */
+    fields?: string;
+    /**
+     * Filter data by supplying filter parameter. Provide field name and its value.
+     */
+    filters?: string;
+    /**
+     * Filter the data by supplying range of values. Applicable for number and date type fields.
+     */
+    rangeFilters?: string;
+  };
+  url: "/api/v1/patent/trials/decisions/search";
+};
+type GetApiV1PatentTrialsDecisionsSearchErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type GetApiV1PatentTrialsDecisionsSearchError = GetApiV1PatentTrialsDecisionsSearchErrors[keyof GetApiV1PatentTrialsDecisionsSearchErrors];
+type GetApiV1PatentTrialsDecisionsSearchResponses = {
+  /**
+   * OK
+   */
+  200: DecisionDataResponse;
+};
+type GetApiV1PatentTrialsDecisionsSearchResponse = GetApiV1PatentTrialsDecisionsSearchResponses[keyof GetApiV1PatentTrialsDecisionsSearchResponses];
+type PostApiV1PatentTrialsDecisionsSearchData = {
+  body: PatentSearchRequest;
+  path?: never;
+  query?: never;
+  url: "/api/v1/patent/trials/decisions/search";
+};
+type PostApiV1PatentTrialsDecisionsSearchErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type PostApiV1PatentTrialsDecisionsSearchError = PostApiV1PatentTrialsDecisionsSearchErrors[keyof PostApiV1PatentTrialsDecisionsSearchErrors];
+type PostApiV1PatentTrialsDecisionsSearchResponses = {
+  /**
+   * OK
+   */
+  200: DecisionDataResponse;
+};
+type PostApiV1PatentTrialsDecisionsSearchResponse = PostApiV1PatentTrialsDecisionsSearchResponses[keyof PostApiV1PatentTrialsDecisionsSearchResponses];
+type GetApiV1PatentTrialsDecisionsSearchDownloadData = {
+  body?: never;
+  path?: never;
+  query?: {
+    /**
+     * A search query string which accepts boolean operators (AND, OR, NOT), wildcards (*), and exact phrases ("").
+     */
+    q?: string;
+    /**
+     * Field to be sorted followed by sort order
+     */
+    sort?: string;
+    /**
+     * Position in the dataset of a particular record
+     */
+    offset?: number;
+    /**
+     * Limit the number of results returned
+     */
+    limit?: number;
+    /**
+     * List of fields names to be faceted upon separated by comma (<b>,</b>)
+     */
+    facets?: string;
+    /**
+     * Limits the response by specifying which fields from dataset should be included.
+     */
+    fields?: string;
+    /**
+     * Filter data by supplying filter parameter. Provide field name and its value.
+     */
+    filters?: string;
+    /**
+     * Filter the data by supplying range of values. Applicable for number and date type fields.
+     */
+    rangeFilters?: string;
+    /**
+     * Download Format
+     */
+    format?: string;
+  };
+  url: "/api/v1/patent/trials/decisions/search/download";
+};
+type GetApiV1PatentTrialsDecisionsSearchDownloadErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type GetApiV1PatentTrialsDecisionsSearchDownloadError = GetApiV1PatentTrialsDecisionsSearchDownloadErrors[keyof GetApiV1PatentTrialsDecisionsSearchDownloadErrors];
+type GetApiV1PatentTrialsDecisionsSearchDownloadResponses = {
+  /**
+   * OK
+   */
+  200: DecisionDataResponse;
+};
+type GetApiV1PatentTrialsDecisionsSearchDownloadResponse = GetApiV1PatentTrialsDecisionsSearchDownloadResponses[keyof GetApiV1PatentTrialsDecisionsSearchDownloadResponses];
+type PostApiV1PatentTrialsDecisionsSearchDownloadData = {
+  /**
+   * Download request. Same structure as PatentDownloadRequest.
+   */
+  body: DownloadRequest;
+  path?: never;
+  query?: never;
+  url: "/api/v1/patent/trials/decisions/search/download";
+};
+type PostApiV1PatentTrialsDecisionsSearchDownloadErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type PostApiV1PatentTrialsDecisionsSearchDownloadError = PostApiV1PatentTrialsDecisionsSearchDownloadErrors[keyof PostApiV1PatentTrialsDecisionsSearchDownloadErrors];
+type PostApiV1PatentTrialsDecisionsSearchDownloadResponses = {
+  /**
+   * OK
+   */
+  200: DecisionDataResponse;
+};
+type PostApiV1PatentTrialsDecisionsSearchDownloadResponse = PostApiV1PatentTrialsDecisionsSearchDownloadResponses[keyof PostApiV1PatentTrialsDecisionsSearchDownloadResponses];
+type GetApiV1PatentTrialsDecisionsByDocumentIdentifierData = {
+  body?: never;
+  path: {
+    documentIdentifier: string;
+  };
+  query?: never;
+  url: "/api/v1/patent/trials/decisions/{documentIdentifier}";
+};
+type GetApiV1PatentTrialsDecisionsByDocumentIdentifierErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type GetApiV1PatentTrialsDecisionsByDocumentIdentifierError = GetApiV1PatentTrialsDecisionsByDocumentIdentifierErrors[keyof GetApiV1PatentTrialsDecisionsByDocumentIdentifierErrors];
+type GetApiV1PatentTrialsDecisionsByDocumentIdentifierResponses = {
+  /**
+   * OK
+   */
+  200: DecisionDataResponse;
+};
+type GetApiV1PatentTrialsDecisionsByDocumentIdentifierResponse = GetApiV1PatentTrialsDecisionsByDocumentIdentifierResponses[keyof GetApiV1PatentTrialsDecisionsByDocumentIdentifierResponses];
+type GetApiV1PatentTrialsByTrialNumberDecisionsData = {
+  body?: never;
+  path: {
+    trialNumber: string;
+  };
+  query?: never;
+  url: "/api/v1/patent/trials/{trialNumber}/decisions";
+};
+type GetApiV1PatentTrialsByTrialNumberDecisionsErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type GetApiV1PatentTrialsByTrialNumberDecisionsError = GetApiV1PatentTrialsByTrialNumberDecisionsErrors[keyof GetApiV1PatentTrialsByTrialNumberDecisionsErrors];
+type GetApiV1PatentTrialsByTrialNumberDecisionsResponses = {
+  /**
+   * OK
+   */
+  200: DecisionDataResponse;
+};
+type GetApiV1PatentTrialsByTrialNumberDecisionsResponse = GetApiV1PatentTrialsByTrialNumberDecisionsResponses[keyof GetApiV1PatentTrialsByTrialNumberDecisionsResponses];
+type GetApiV1PatentTrialsDocumentsSearchData = {
+  body?: never;
+  path?: never;
+  query?: {
+    /**
+     * A search query string which accepts boolean operators (AND, OR, NOT), wildcards (*), and exact phrases ("").
+     */
+    q?: string;
+    /**
+     * Field to be sorted followed by sort order
+     */
+    sort?: string;
+    /**
+     * Position in the dataset of a particular record
+     */
+    offset?: number;
+    /**
+     * Limit the number of results returned
+     */
+    limit?: number;
+    /**
+     * List of fields names to be faceted upon separated by comma (<b>,</b>)
+     */
+    facets?: string;
+    /**
+     * Limits the response by specifying which fields from dataset should be included.
+     */
+    fields?: string;
+    /**
+     * Filter data by supplying filter parameter. Provide field name and its value.
+     */
+    filters?: string;
+    /**
+     * Filter the data by supplying range of values. Applicable for number and date type fields.
+     */
+    rangeFilters?: string;
+  };
+  url: "/api/v1/patent/trials/documents/search";
+};
+type GetApiV1PatentTrialsDocumentsSearchErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type GetApiV1PatentTrialsDocumentsSearchError = GetApiV1PatentTrialsDocumentsSearchErrors[keyof GetApiV1PatentTrialsDocumentsSearchErrors];
+type GetApiV1PatentTrialsDocumentsSearchResponses = {
+  /**
+   * OK
+   */
+  200: DocumentDataResponse;
+};
+type GetApiV1PatentTrialsDocumentsSearchResponse = GetApiV1PatentTrialsDocumentsSearchResponses[keyof GetApiV1PatentTrialsDocumentsSearchResponses];
+type PostApiV1PatentTrialsDocumentsSearchData = {
+  body: SearchRequest;
+  path?: never;
+  query?: never;
+  url: "/api/v1/patent/trials/documents/search";
+};
+type PostApiV1PatentTrialsDocumentsSearchErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type PostApiV1PatentTrialsDocumentsSearchError = PostApiV1PatentTrialsDocumentsSearchErrors[keyof PostApiV1PatentTrialsDocumentsSearchErrors];
+type PostApiV1PatentTrialsDocumentsSearchResponses = {
+  /**
+   * OK
+   */
+  200: DocumentDataResponse;
+};
+type PostApiV1PatentTrialsDocumentsSearchResponse = PostApiV1PatentTrialsDocumentsSearchResponses[keyof PostApiV1PatentTrialsDocumentsSearchResponses];
+type GetApiV1PatentTrialsDocumentsSearchDownloadData = {
+  body?: never;
+  path?: never;
+  query?: {
+    /**
+     * A search query string which accepts boolean operators (AND, OR, NOT), wildcards (*), and exact phrases ("").
+     */
+    q?: string;
+    /**
+     * Field to be sorted followed by sort order
+     */
+    sort?: string;
+    /**
+     * Position in the dataset of a particular record
+     */
+    offset?: number;
+    /**
+     * Limit the number of results returned
+     */
+    limit?: number;
+    /**
+     * List of fields names to be faceted upon separated by comma (<b>,</b>)
+     */
+    facets?: string;
+    /**
+     * Limits the response by specifying which fields from dataset should be included.
+     */
+    fields?: string;
+    /**
+     * Filter data by supplying filter parameter. Provide field name and its value.
+     */
+    filters?: string;
+    /**
+     * Filter the data by supplying range of values. Applicable for number and date type fields.
+     */
+    rangeFilters?: string;
+    /**
+     * Download Format
+     */
+    format?: string;
+  };
+  url: "/api/v1/patent/trials/documents/search/download";
+};
+type GetApiV1PatentTrialsDocumentsSearchDownloadErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type GetApiV1PatentTrialsDocumentsSearchDownloadError = GetApiV1PatentTrialsDocumentsSearchDownloadErrors[keyof GetApiV1PatentTrialsDocumentsSearchDownloadErrors];
+type GetApiV1PatentTrialsDocumentsSearchDownloadResponses = {
+  /**
+   * OK
+   */
+  200: DocumentDataResponse;
+};
+type GetApiV1PatentTrialsDocumentsSearchDownloadResponse = GetApiV1PatentTrialsDocumentsSearchDownloadResponses[keyof GetApiV1PatentTrialsDocumentsSearchDownloadResponses];
+type PostApiV1PatentTrialsDocumentsSearchDownloadData = {
+  /**
+   * Document download request. Same structure as PatentDownloadRequest.
+   */
+  body: DownloadRequest;
+  path?: never;
+  query?: never;
+  url: "/api/v1/patent/trials/documents/search/download";
+};
+type PostApiV1PatentTrialsDocumentsSearchDownloadErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type PostApiV1PatentTrialsDocumentsSearchDownloadError = PostApiV1PatentTrialsDocumentsSearchDownloadErrors[keyof PostApiV1PatentTrialsDocumentsSearchDownloadErrors];
+type PostApiV1PatentTrialsDocumentsSearchDownloadResponses = {
+  /**
+   * OK
+   */
+  200: DocumentDataResponse;
+};
+type PostApiV1PatentTrialsDocumentsSearchDownloadResponse = PostApiV1PatentTrialsDocumentsSearchDownloadResponses[keyof PostApiV1PatentTrialsDocumentsSearchDownloadResponses];
+type GetApiV1PatentTrialsDocumentsByDocumentIdentifierData = {
+  body?: never;
+  path: {
+    /**
+     * document Identifier.
+     */
+    documentIdentifier: string;
+  };
+  query?: never;
+  url: "/api/v1/patent/trials/documents/{documentIdentifier}";
+};
+type GetApiV1PatentTrialsDocumentsByDocumentIdentifierErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type GetApiV1PatentTrialsDocumentsByDocumentIdentifierError = GetApiV1PatentTrialsDocumentsByDocumentIdentifierErrors[keyof GetApiV1PatentTrialsDocumentsByDocumentIdentifierErrors];
+type GetApiV1PatentTrialsDocumentsByDocumentIdentifierResponses = {
+  /**
+   * OK
+   */
+  200: DocumentDataResponse;
+};
+type GetApiV1PatentTrialsDocumentsByDocumentIdentifierResponse = GetApiV1PatentTrialsDocumentsByDocumentIdentifierResponses[keyof GetApiV1PatentTrialsDocumentsByDocumentIdentifierResponses];
+type GetApiV1PatentTrialsByTrialNumberDocumentsData = {
+  body?: never;
+  path: {
+    /**
+     * trialNumber number.
+     */
+    trialNumber: string;
+  };
+  query?: never;
+  url: "/api/v1/patent/trials/{trialNumber}/documents";
+};
+type GetApiV1PatentTrialsByTrialNumberDocumentsErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type GetApiV1PatentTrialsByTrialNumberDocumentsError = GetApiV1PatentTrialsByTrialNumberDocumentsErrors[keyof GetApiV1PatentTrialsByTrialNumberDocumentsErrors];
+type GetApiV1PatentTrialsByTrialNumberDocumentsResponses = {
+  /**
+   * OK
+   */
+  200: DocumentDataResponse;
+};
+type GetApiV1PatentTrialsByTrialNumberDocumentsResponse = GetApiV1PatentTrialsByTrialNumberDocumentsResponses[keyof GetApiV1PatentTrialsByTrialNumberDocumentsResponses];
+type GetApiV1PatentAppealsDecisionsSearchData = {
+  body?: never;
+  path?: never;
+  query?: {
+    /**
+     * A search query string which accepts boolean operators (AND, OR, NOT), wildcards (*), and exact phrases ("").
+     */
+    q?: string;
+    /**
+     * Field to be sorted followed by sort order
+     */
+    sort?: string;
+    /**
+     * Position in the dataset of a particular record
+     */
+    offset?: number;
+    /**
+     * Limit the number of results returned
+     */
+    limit?: number;
+    /**
+     * List of fields names to be faceted upon separated by comma (<b>,</b>)
+     */
+    facets?: string;
+    /**
+     * Limits the response by specifying which fields from dataset should be included.
+     */
+    fields?: string;
+    /**
+     * Filter data by supplying filter parameter. Provide field name and its value.
+     */
+    filters?: string;
+    /**
+     * Filter the data by supplying range of values. Applicable for number and date type fields.
+     */
+    rangeFilters?: string;
+  };
+  url: "/api/v1/patent/appeals/decisions/search";
+};
+type GetApiV1PatentAppealsDecisionsSearchErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type GetApiV1PatentAppealsDecisionsSearchError = GetApiV1PatentAppealsDecisionsSearchErrors[keyof GetApiV1PatentAppealsDecisionsSearchErrors];
+type GetApiV1PatentAppealsDecisionsSearchResponses = {
+  /**
+   * Successful search
+   */
+  200: AppealDecisionDataResponse;
+};
+type GetApiV1PatentAppealsDecisionsSearchResponse = GetApiV1PatentAppealsDecisionsSearchResponses[keyof GetApiV1PatentAppealsDecisionsSearchResponses];
+type PostApiV1PatentAppealsDecisionsSearchData = {
+  body: PatentSearchRequest;
+  path?: never;
+  query?: never;
+  url: "/api/v1/patent/appeals/decisions/search";
+};
+type PostApiV1PatentAppealsDecisionsSearchErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type PostApiV1PatentAppealsDecisionsSearchError = PostApiV1PatentAppealsDecisionsSearchErrors[keyof PostApiV1PatentAppealsDecisionsSearchErrors];
+type PostApiV1PatentAppealsDecisionsSearchResponses = {
+  /**
+   * Successful search
+   */
+  200: AppealDecisionDataResponse;
+};
+type PostApiV1PatentAppealsDecisionsSearchResponse = PostApiV1PatentAppealsDecisionsSearchResponses[keyof PostApiV1PatentAppealsDecisionsSearchResponses];
+type GetApiV1PatentAppealsDecisionsSearchDownloadData = {
+  body?: never;
+  path?: never;
+  query?: {
+    /**
+     * A search query string which accepts boolean operators (AND, OR, NOT), wildcards (*), and exact phrases ("").
+     */
+    q?: string;
+    /**
+     * Field to be sorted followed by sort order
+     */
+    sort?: string;
+    /**
+     * Position in the dataset of a particular record
+     */
+    offset?: number;
+    /**
+     * Limit the number of results returned
+     */
+    limit?: number;
+    /**
+     * Limits the response by specifying which fields from dataset should be included.
+     */
+    fields?: string;
+    /**
+     * Filter data by supplying filter parameter. Provide field name and its value.
+     */
+    filters?: string;
+    /**
+     * Filter the data by supplying range of values. Applicable for number and date type fields.
+     */
+    rangeFilters?: string;
+    /**
+     * Download Format
+     */
+    format?: string;
+  };
+  url: "/api/v1/patent/appeals/decisions/search/download";
+};
+type GetApiV1PatentAppealsDecisionsSearchDownloadErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type GetApiV1PatentAppealsDecisionsSearchDownloadError = GetApiV1PatentAppealsDecisionsSearchDownloadErrors[keyof GetApiV1PatentAppealsDecisionsSearchDownloadErrors];
+type GetApiV1PatentAppealsDecisionsSearchDownloadResponses = {
+  /**
+   * Successful search
+   */
+  200: AppealDecisionDataResponse;
+};
+type GetApiV1PatentAppealsDecisionsSearchDownloadResponse = GetApiV1PatentAppealsDecisionsSearchDownloadResponses[keyof GetApiV1PatentAppealsDecisionsSearchDownloadResponses];
+type PostApiV1PatentAppealsDecisionsSearchDownloadData = {
+  /**
+   * Download request. Same structure as PatentDownloadRequest.
+   */
+  body: DownloadRequest;
+  path?: never;
+  query?: never;
+  url: "/api/v1/patent/appeals/decisions/search/download";
+};
+type PostApiV1PatentAppealsDecisionsSearchDownloadErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type PostApiV1PatentAppealsDecisionsSearchDownloadError = PostApiV1PatentAppealsDecisionsSearchDownloadErrors[keyof PostApiV1PatentAppealsDecisionsSearchDownloadErrors];
+type PostApiV1PatentAppealsDecisionsSearchDownloadResponses = {
+  /**
+   * Successful search
+   */
+  200: AppealDecisionDataResponse;
+};
+type PostApiV1PatentAppealsDecisionsSearchDownloadResponse = PostApiV1PatentAppealsDecisionsSearchDownloadResponses[keyof PostApiV1PatentAppealsDecisionsSearchDownloadResponses];
+type GetApiV1PatentAppealsDecisionsByDocumentIdentifierData = {
+  body?: never;
+  path: {
+    /**
+     * document Identifier.
+     */
+    documentIdentifier: string;
+  };
+  query?: never;
+  url: "/api/v1/patent/appeals/decisions/{documentIdentifier}";
+};
+type GetApiV1PatentAppealsDecisionsByDocumentIdentifierErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type GetApiV1PatentAppealsDecisionsByDocumentIdentifierError = GetApiV1PatentAppealsDecisionsByDocumentIdentifierErrors[keyof GetApiV1PatentAppealsDecisionsByDocumentIdentifierErrors];
+type GetApiV1PatentAppealsDecisionsByDocumentIdentifierResponses = {
+  /**
+   * Appeal decision found
+   */
+  200: AppealDecisionDataResponse;
+};
+type GetApiV1PatentAppealsDecisionsByDocumentIdentifierResponse = GetApiV1PatentAppealsDecisionsByDocumentIdentifierResponses[keyof GetApiV1PatentAppealsDecisionsByDocumentIdentifierResponses];
+type GetApiV1PatentAppealsByAppealNumberDecisionsData = {
+  body?: never;
+  path: {
+    appealNumber: string;
+  };
+  query?: never;
+  url: "/api/v1/patent/appeals/{appealNumber}/decisions";
+};
+type GetApiV1PatentAppealsByAppealNumberDecisionsErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type GetApiV1PatentAppealsByAppealNumberDecisionsError = GetApiV1PatentAppealsByAppealNumberDecisionsErrors[keyof GetApiV1PatentAppealsByAppealNumberDecisionsErrors];
+type GetApiV1PatentAppealsByAppealNumberDecisionsResponses = {
+  /**
+   * Appeal decision found
+   */
+  200: AppealDecisionDataResponse;
+};
+type GetApiV1PatentAppealsByAppealNumberDecisionsResponse = GetApiV1PatentAppealsByAppealNumberDecisionsResponses[keyof GetApiV1PatentAppealsByAppealNumberDecisionsResponses];
+type GetApiV1PatentInterferencesDecisionsSearchData = {
+  body?: never;
+  path?: never;
+  query?: {
+    /**
+     * A search query string which accepts boolean operators (AND, OR, NOT), wildcards (*), and exact phrases ("").
+     */
+    q?: string;
+    /**
+     * Field to be sorted followed by sort order
+     */
+    sort?: string;
+    /**
+     * Position in the dataset of a particular record
+     */
+    offset?: number;
+    /**
+     * Limit the number of results returned
+     */
+    limit?: number;
+    /**
+     * List of fields names to be faceted upon separated by comma (<b>,</b>)
+     */
+    facets?: string;
+    /**
+     * Limits the response by specifying which fields from dataset should be included.
+     */
+    fields?: string;
+    /**
+     * Filter data by supplying filter parameter. Provide field name and its value.
+     */
+    filters?: string;
+    /**
+     * Filter the data by supplying range of values. Applicable for number and date type fields.
+     */
+    rangeFilters?: string;
+  };
+  url: "/api/v1/patent/interferences/decisions/search";
+};
+type GetApiV1PatentInterferencesDecisionsSearchErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type GetApiV1PatentInterferencesDecisionsSearchError = GetApiV1PatentInterferencesDecisionsSearchErrors[keyof GetApiV1PatentInterferencesDecisionsSearchErrors];
+type GetApiV1PatentInterferencesDecisionsSearchResponses = {
+  /**
+   * OK
+   */
+  200: InterferenceDecisionDataResponse;
+};
+type GetApiV1PatentInterferencesDecisionsSearchResponse = GetApiV1PatentInterferencesDecisionsSearchResponses[keyof GetApiV1PatentInterferencesDecisionsSearchResponses];
+type PostApiV1PatentInterferencesDecisionsSearchData = {
+  body: PatentSearchRequest;
+  path?: never;
+  query?: never;
+  url: "/api/v1/patent/interferences/decisions/search";
+};
+type PostApiV1PatentInterferencesDecisionsSearchErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type PostApiV1PatentInterferencesDecisionsSearchError = PostApiV1PatentInterferencesDecisionsSearchErrors[keyof PostApiV1PatentInterferencesDecisionsSearchErrors];
+type PostApiV1PatentInterferencesDecisionsSearchResponses = {
+  /**
+   * OK
+   */
+  200: InterferenceDecisionDataResponse;
+};
+type PostApiV1PatentInterferencesDecisionsSearchResponse = PostApiV1PatentInterferencesDecisionsSearchResponses[keyof PostApiV1PatentInterferencesDecisionsSearchResponses];
+type GetApiV1PatentInterferencesDecisionsSearchDownloadData = {
+  body?: never;
+  path?: never;
+  query?: {
+    /**
+     * A search query string which accepts boolean operators (AND, OR, NOT), wildcards (*), and exact phrases ("").
+     */
+    q?: string;
+    /**
+     * Field to be sorted followed by sort order
+     */
+    sort?: string;
+    /**
+     * Position in the dataset of a particular record
+     */
+    offset?: number;
+    /**
+     * Limit the number of results returned
+     */
+    limit?: number;
+    /**
+     * List of fields names to be faceted upon separated by comma (<b>,</b>)
+     */
+    facets?: string;
+    /**
+     * Limits the response by specifying which fields from dataset should be included.
+     */
+    fields?: string;
+    /**
+     * Filter data by supplying filter parameter. Provide field name and its value.
+     */
+    filters?: string;
+    /**
+     * Filter the data by supplying range of values. Applicable for number and date type fields.
+     */
+    rangeFilters?: string;
+    /**
+     * Download Format
+     */
+    format?: string;
+  };
+  url: "/api/v1/patent/interferences/decisions/search/download";
+};
+type GetApiV1PatentInterferencesDecisionsSearchDownloadErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type GetApiV1PatentInterferencesDecisionsSearchDownloadError = GetApiV1PatentInterferencesDecisionsSearchDownloadErrors[keyof GetApiV1PatentInterferencesDecisionsSearchDownloadErrors];
+type GetApiV1PatentInterferencesDecisionsSearchDownloadResponses = {
+  /**
+   * OK (file or JSON depending on format)
+   */
+  200: InterferenceDecisionDataResponse;
+};
+type GetApiV1PatentInterferencesDecisionsSearchDownloadResponse = GetApiV1PatentInterferencesDecisionsSearchDownloadResponses[keyof GetApiV1PatentInterferencesDecisionsSearchDownloadResponses];
+type PostApiV1PatentInterferencesDecisionsSearchDownloadData = {
+  body: PatentDownloadRequest;
+  path?: never;
+  query?: never;
+  url: "/api/v1/patent/interferences/decisions/search/download";
+};
+type PostApiV1PatentInterferencesDecisionsSearchDownloadErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type PostApiV1PatentInterferencesDecisionsSearchDownloadError = PostApiV1PatentInterferencesDecisionsSearchDownloadErrors[keyof PostApiV1PatentInterferencesDecisionsSearchDownloadErrors];
+type PostApiV1PatentInterferencesDecisionsSearchDownloadResponses = {
+  /**
+   * OK (file or JSON depending on format)
+   */
+  200: InterferenceDecisionDataResponse;
+};
+type PostApiV1PatentInterferencesDecisionsSearchDownloadResponse = PostApiV1PatentInterferencesDecisionsSearchDownloadResponses[keyof PostApiV1PatentInterferencesDecisionsSearchDownloadResponses];
+type GetApiV1PatentInterferencesByInterferenceNumberDecisionsData = {
+  body?: never;
+  path: {
+    /**
+     * Interference number (e.g., 103751).
+     */
+    interferenceNumber: string;
+  };
+  query?: never;
+  url: "/api/v1/patent/interferences/{interferenceNumber}/decisions";
+};
+type GetApiV1PatentInterferencesByInterferenceNumberDecisionsErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type GetApiV1PatentInterferencesByInterferenceNumberDecisionsError = GetApiV1PatentInterferencesByInterferenceNumberDecisionsErrors[keyof GetApiV1PatentInterferencesByInterferenceNumberDecisionsErrors];
+type GetApiV1PatentInterferencesByInterferenceNumberDecisionsResponses = {
+  /**
+   * OK
+   */
+  200: InterferenceDecisionDataResponse;
+};
+type GetApiV1PatentInterferencesByInterferenceNumberDecisionsResponse = GetApiV1PatentInterferencesByInterferenceNumberDecisionsResponses[keyof GetApiV1PatentInterferencesByInterferenceNumberDecisionsResponses];
+type GetApiV1PatentInterferencesDecisionsByDocumentIdentifierData = {
+  body?: never;
+  path: {
+    /**
+     * Unique document identifier (opaque string).
+     */
+    documentIdentifier: string;
+  };
+  query?: never;
+  url: "/api/v1/patent/interferences/decisions/{documentIdentifier}";
+};
+type GetApiV1PatentInterferencesDecisionsByDocumentIdentifierErrors = {
+  /**
+   * Bad Request
+   */
+  400: {
+    code?: unknown;
+    error?: unknown;
+    errorDetails?: unknown;
+    requestIdentifier?: unknown;
+  };
+  /**
+   * Forbidden
+   */
+  403: {
+    code?: string;
+    error?: string;
+  };
+  /**
+   * Not Found
+   */
+  404: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+  /**
+   * Status413
+   */
+  413: Status413;
+  /**
+   * Internal Error
+   */
+  500: {
+    code?: string;
+    error?: string;
+    errorDetails?: string;
+    requestIdentifier?: string;
+  };
+};
+type GetApiV1PatentInterferencesDecisionsByDocumentIdentifierError = GetApiV1PatentInterferencesDecisionsByDocumentIdentifierErrors[keyof GetApiV1PatentInterferencesDecisionsByDocumentIdentifierErrors];
+type GetApiV1PatentInterferencesDecisionsByDocumentIdentifierResponses = {
+  /**
+   * OK
+   */
+  200: InterferenceDecisionDataResponse;
+};
+type GetApiV1PatentInterferencesDecisionsByDocumentIdentifierResponse = GetApiV1PatentInterferencesDecisionsByDocumentIdentifierResponses[keyof GetApiV1PatentInterferencesDecisionsByDocumentIdentifierResponses];
+//#endregion
+export { AppealDecisionDataResponse, ApplicationMetaData, Assignment, BadRequestSchema, BdssResponseBag, BdssResponseProductBag, BulkDataProductBag, ChildContinuityData, ClientOptions, DecisionData, DecisionDataResponse, DerivationPetitionerData, DocumentBag, DocumentData, DocumentDataResponse, DownloadRequest, Error, EventData, Facet, FacetItem, Facets, Facets2, Fields, Filter, Filters, ForbiddenSchema, ForeignPriority, Format, GetApiV1DatasetsProductsByProductIdentifierData, GetApiV1DatasetsProductsByProductIdentifierError, GetApiV1DatasetsProductsByProductIdentifierErrors, GetApiV1DatasetsProductsByProductIdentifierResponse, GetApiV1DatasetsProductsByProductIdentifierResponses, GetApiV1DatasetsProductsFilesByProductIdentifierByFileNameData, GetApiV1DatasetsProductsSearchData, GetApiV1DatasetsProductsSearchError, GetApiV1DatasetsProductsSearchErrors, GetApiV1DatasetsProductsSearchResponse, GetApiV1DatasetsProductsSearchResponses, GetApiV1PatentAppealsByAppealNumberDecisionsData, GetApiV1PatentAppealsByAppealNumberDecisionsError, GetApiV1PatentAppealsByAppealNumberDecisionsErrors, GetApiV1PatentAppealsByAppealNumberDecisionsResponse, GetApiV1PatentAppealsByAppealNumberDecisionsResponses, GetApiV1PatentAppealsDecisionsByDocumentIdentifierData, GetApiV1PatentAppealsDecisionsByDocumentIdentifierError, GetApiV1PatentAppealsDecisionsByDocumentIdentifierErrors, GetApiV1PatentAppealsDecisionsByDocumentIdentifierResponse, GetApiV1PatentAppealsDecisionsByDocumentIdentifierResponses, GetApiV1PatentAppealsDecisionsSearchData, GetApiV1PatentAppealsDecisionsSearchDownloadData, GetApiV1PatentAppealsDecisionsSearchDownloadError, GetApiV1PatentAppealsDecisionsSearchDownloadErrors, GetApiV1PatentAppealsDecisionsSearchDownloadResponse, GetApiV1PatentAppealsDecisionsSearchDownloadResponses, GetApiV1PatentAppealsDecisionsSearchError, GetApiV1PatentAppealsDecisionsSearchErrors, GetApiV1PatentAppealsDecisionsSearchResponse, GetApiV1PatentAppealsDecisionsSearchResponses, GetApiV1PatentApplicationsByApplicationNumberTextAdjustmentData, GetApiV1PatentApplicationsByApplicationNumberTextAdjustmentError, GetApiV1PatentApplicationsByApplicationNumberTextAdjustmentErrors, GetApiV1PatentApplicationsByApplicationNumberTextAdjustmentResponse, GetApiV1PatentApplicationsByApplicationNumberTextAdjustmentResponses, GetApiV1PatentApplicationsByApplicationNumberTextAssignmentData, GetApiV1PatentApplicationsByApplicationNumberTextAssignmentError, GetApiV1PatentApplicationsByApplicationNumberTextAssignmentErrors, GetApiV1PatentApplicationsByApplicationNumberTextAssignmentResponse, GetApiV1PatentApplicationsByApplicationNumberTextAssignmentResponses, GetApiV1PatentApplicationsByApplicationNumberTextAssociatedDocumentsData, GetApiV1PatentApplicationsByApplicationNumberTextAssociatedDocumentsError, GetApiV1PatentApplicationsByApplicationNumberTextAssociatedDocumentsErrors, GetApiV1PatentApplicationsByApplicationNumberTextAssociatedDocumentsResponse, GetApiV1PatentApplicationsByApplicationNumberTextAssociatedDocumentsResponses, GetApiV1PatentApplicationsByApplicationNumberTextAttorneyData, GetApiV1PatentApplicationsByApplicationNumberTextAttorneyError, GetApiV1PatentApplicationsByApplicationNumberTextAttorneyErrors, GetApiV1PatentApplicationsByApplicationNumberTextAttorneyResponse, GetApiV1PatentApplicationsByApplicationNumberTextAttorneyResponses, GetApiV1PatentApplicationsByApplicationNumberTextContinuityData, GetApiV1PatentApplicationsByApplicationNumberTextContinuityResponse, GetApiV1PatentApplicationsByApplicationNumberTextContinuityResponses, GetApiV1PatentApplicationsByApplicationNumberTextData, GetApiV1PatentApplicationsByApplicationNumberTextDocumentsData, GetApiV1PatentApplicationsByApplicationNumberTextDocumentsError, GetApiV1PatentApplicationsByApplicationNumberTextDocumentsErrors, GetApiV1PatentApplicationsByApplicationNumberTextDocumentsResponse, GetApiV1PatentApplicationsByApplicationNumberTextDocumentsResponses, GetApiV1PatentApplicationsByApplicationNumberTextError, GetApiV1PatentApplicationsByApplicationNumberTextErrors, GetApiV1PatentApplicationsByApplicationNumberTextForeignPriorityData, GetApiV1PatentApplicationsByApplicationNumberTextForeignPriorityError, GetApiV1PatentApplicationsByApplicationNumberTextForeignPriorityErrors, GetApiV1PatentApplicationsByApplicationNumberTextForeignPriorityResponse, GetApiV1PatentApplicationsByApplicationNumberTextForeignPriorityResponses, GetApiV1PatentApplicationsByApplicationNumberTextMetaDataData, GetApiV1PatentApplicationsByApplicationNumberTextMetaDataError, GetApiV1PatentApplicationsByApplicationNumberTextMetaDataErrors, GetApiV1PatentApplicationsByApplicationNumberTextMetaDataResponse, GetApiV1PatentApplicationsByApplicationNumberTextMetaDataResponses, GetApiV1PatentApplicationsByApplicationNumberTextResponse, GetApiV1PatentApplicationsByApplicationNumberTextResponses, GetApiV1PatentApplicationsByApplicationNumberTextTransactionsData, GetApiV1PatentApplicationsByApplicationNumberTextTransactionsError, GetApiV1PatentApplicationsByApplicationNumberTextTransactionsErrors, GetApiV1PatentApplicationsByApplicationNumberTextTransactionsResponse, GetApiV1PatentApplicationsByApplicationNumberTextTransactionsResponses, GetApiV1PatentApplicationsSearchData, GetApiV1PatentApplicationsSearchDownloadData, GetApiV1PatentApplicationsSearchDownloadError, GetApiV1PatentApplicationsSearchDownloadErrors, GetApiV1PatentApplicationsSearchDownloadResponse, GetApiV1PatentApplicationsSearchDownloadResponses, GetApiV1PatentApplicationsSearchError, GetApiV1PatentApplicationsSearchErrors, GetApiV1PatentApplicationsSearchResponse, GetApiV1PatentApplicationsSearchResponses, GetApiV1PatentInterferencesByInterferenceNumberDecisionsData, GetApiV1PatentInterferencesByInterferenceNumberDecisionsError, GetApiV1PatentInterferencesByInterferenceNumberDecisionsErrors, GetApiV1PatentInterferencesByInterferenceNumberDecisionsResponse, GetApiV1PatentInterferencesByInterferenceNumberDecisionsResponses, GetApiV1PatentInterferencesDecisionsByDocumentIdentifierData, GetApiV1PatentInterferencesDecisionsByDocumentIdentifierError, GetApiV1PatentInterferencesDecisionsByDocumentIdentifierErrors, GetApiV1PatentInterferencesDecisionsByDocumentIdentifierResponse, GetApiV1PatentInterferencesDecisionsByDocumentIdentifierResponses, GetApiV1PatentInterferencesDecisionsSearchData, GetApiV1PatentInterferencesDecisionsSearchDownloadData, GetApiV1PatentInterferencesDecisionsSearchDownloadError, GetApiV1PatentInterferencesDecisionsSearchDownloadErrors, GetApiV1PatentInterferencesDecisionsSearchDownloadResponse, GetApiV1PatentInterferencesDecisionsSearchDownloadResponses, GetApiV1PatentInterferencesDecisionsSearchError, GetApiV1PatentInterferencesDecisionsSearchErrors, GetApiV1PatentInterferencesDecisionsSearchResponse, GetApiV1PatentInterferencesDecisionsSearchResponses, GetApiV1PatentStatusCodesData, GetApiV1PatentStatusCodesError, GetApiV1PatentStatusCodesErrors, GetApiV1PatentStatusCodesResponse, GetApiV1PatentStatusCodesResponses, GetApiV1PatentTrialsByTrialNumberDecisionsData, GetApiV1PatentTrialsByTrialNumberDecisionsError, GetApiV1PatentTrialsByTrialNumberDecisionsErrors, GetApiV1PatentTrialsByTrialNumberDecisionsResponse, GetApiV1PatentTrialsByTrialNumberDecisionsResponses, GetApiV1PatentTrialsByTrialNumberDocumentsData, GetApiV1PatentTrialsByTrialNumberDocumentsError, GetApiV1PatentTrialsByTrialNumberDocumentsErrors, GetApiV1PatentTrialsByTrialNumberDocumentsResponse, GetApiV1PatentTrialsByTrialNumberDocumentsResponses, GetApiV1PatentTrialsDecisionsByDocumentIdentifierData, GetApiV1PatentTrialsDecisionsByDocumentIdentifierError, GetApiV1PatentTrialsDecisionsByDocumentIdentifierErrors, GetApiV1PatentTrialsDecisionsByDocumentIdentifierResponse, GetApiV1PatentTrialsDecisionsByDocumentIdentifierResponses, GetApiV1PatentTrialsDecisionsSearchData, GetApiV1PatentTrialsDecisionsSearchDownloadData, GetApiV1PatentTrialsDecisionsSearchDownloadError, GetApiV1PatentTrialsDecisionsSearchDownloadErrors, GetApiV1PatentTrialsDecisionsSearchDownloadResponse, GetApiV1PatentTrialsDecisionsSearchDownloadResponses, GetApiV1PatentTrialsDecisionsSearchError, GetApiV1PatentTrialsDecisionsSearchErrors, GetApiV1PatentTrialsDecisionsSearchResponse, GetApiV1PatentTrialsDecisionsSearchResponses, GetApiV1PatentTrialsDocumentsByDocumentIdentifierData, GetApiV1PatentTrialsDocumentsByDocumentIdentifierError, GetApiV1PatentTrialsDocumentsByDocumentIdentifierErrors, GetApiV1PatentTrialsDocumentsByDocumentIdentifierResponse, GetApiV1PatentTrialsDocumentsByDocumentIdentifierResponses, GetApiV1PatentTrialsDocumentsSearchData, GetApiV1PatentTrialsDocumentsSearchDownloadData, GetApiV1PatentTrialsDocumentsSearchDownloadError, GetApiV1PatentTrialsDocumentsSearchDownloadErrors, GetApiV1PatentTrialsDocumentsSearchDownloadResponse, GetApiV1PatentTrialsDocumentsSearchDownloadResponses, GetApiV1PatentTrialsDocumentsSearchError, GetApiV1PatentTrialsDocumentsSearchErrors, GetApiV1PatentTrialsDocumentsSearchResponse, GetApiV1PatentTrialsDocumentsSearchResponses, GetApiV1PatentTrialsProceedingsByTrialNumberData, GetApiV1PatentTrialsProceedingsByTrialNumberError, GetApiV1PatentTrialsProceedingsByTrialNumberErrors, GetApiV1PatentTrialsProceedingsByTrialNumberResponse, GetApiV1PatentTrialsProceedingsByTrialNumberResponses, GetApiV1PatentTrialsProceedingsSearchData, GetApiV1PatentTrialsProceedingsSearchDownloadData, GetApiV1PatentTrialsProceedingsSearchDownloadError, GetApiV1PatentTrialsProceedingsSearchDownloadErrors, GetApiV1PatentTrialsProceedingsSearchDownloadResponse, GetApiV1PatentTrialsProceedingsSearchDownloadResponses, GetApiV1PatentTrialsProceedingsSearchError, GetApiV1PatentTrialsProceedingsSearchErrors, GetApiV1PatentTrialsProceedingsSearchResponse, GetApiV1PatentTrialsProceedingsSearchResponses, GetApiV1PetitionDecisionsByPetitionDecisionRecordIdentifierData, GetApiV1PetitionDecisionsByPetitionDecisionRecordIdentifierError, GetApiV1PetitionDecisionsByPetitionDecisionRecordIdentifierErrors, GetApiV1PetitionDecisionsByPetitionDecisionRecordIdentifierResponse, GetApiV1PetitionDecisionsByPetitionDecisionRecordIdentifierResponses, GetApiV1PetitionDecisionsSearchData, GetApiV1PetitionDecisionsSearchDownloadData, GetApiV1PetitionDecisionsSearchDownloadError, GetApiV1PetitionDecisionsSearchDownloadErrors, GetApiV1PetitionDecisionsSearchDownloadResponse, GetApiV1PetitionDecisionsSearchDownloadResponses, GetApiV1PetitionDecisionsSearchError, GetApiV1PetitionDecisionsSearchErrors, GetApiV1PetitionDecisionsSearchResponse, GetApiV1PetitionDecisionsSearchResponses, GrantFileMetaData, InterferenceDecisionDataResponse, InterferenceDecisionDocumentData, InterferenceDecisionRecord, InterferencePartyData, InternalErrorSchema, Limit, LookupRequest, NotFoundSchema, Offset, Pagination, ParamFacets, ParamFields, ParamFilters, ParamFormat, ParamLimit, ParamOffset, ParamQ, ParamRangeFilters, ParamSort, ParentContinuityData, PatentAppealDataBag, PatentAppealDataBag2, PatentDataResponse, PatentDownloadRequest, PatentOwnerData, PatentSearchRequest, PatentTermAdjustment, PatentTrialDecisionDataBag, PatentTrialDecisionDataBag2, PatentTrialDocumentDataBag, PatentTrialDocumentDataBag2, PatentTrialProceedingDataBag, PatentTrialProceedingDataBag2, PetitionDecision, PetitionDecisionAndDocuments, PetitionDecisionDocument, PetitionDecisionDownloadRequest, PetitionDecisionFacet, PetitionDecisionFacetEntity, PetitionDecisionFilter, PetitionDecisionIdentifierResponseBag, PetitionDecisionRange, PetitionDecisionResponseBag, PetitionDecisionSearchRequest, PetitionDecisionSort, PgPubFileMetaData, PostApiV1PatentAppealsDecisionsSearchData, PostApiV1PatentAppealsDecisionsSearchDownloadData, PostApiV1PatentAppealsDecisionsSearchDownloadError, PostApiV1PatentAppealsDecisionsSearchDownloadErrors, PostApiV1PatentAppealsDecisionsSearchDownloadResponse, PostApiV1PatentAppealsDecisionsSearchDownloadResponses, PostApiV1PatentAppealsDecisionsSearchError, PostApiV1PatentAppealsDecisionsSearchErrors, PostApiV1PatentAppealsDecisionsSearchResponse, PostApiV1PatentAppealsDecisionsSearchResponses, PostApiV1PatentApplicationsSearchData, PostApiV1PatentApplicationsSearchDownloadData, PostApiV1PatentApplicationsSearchDownloadError, PostApiV1PatentApplicationsSearchDownloadErrors, PostApiV1PatentApplicationsSearchDownloadResponse, PostApiV1PatentApplicationsSearchDownloadResponses, PostApiV1PatentApplicationsSearchError, PostApiV1PatentApplicationsSearchErrors, PostApiV1PatentApplicationsSearchResponse, PostApiV1PatentApplicationsSearchResponses, PostApiV1PatentInterferencesDecisionsSearchData, PostApiV1PatentInterferencesDecisionsSearchDownloadData, PostApiV1PatentInterferencesDecisionsSearchDownloadError, PostApiV1PatentInterferencesDecisionsSearchDownloadErrors, PostApiV1PatentInterferencesDecisionsSearchDownloadResponse, PostApiV1PatentInterferencesDecisionsSearchDownloadResponses, PostApiV1PatentInterferencesDecisionsSearchError, PostApiV1PatentInterferencesDecisionsSearchErrors, PostApiV1PatentInterferencesDecisionsSearchResponse, PostApiV1PatentInterferencesDecisionsSearchResponses, PostApiV1PatentStatusCodesData, PostApiV1PatentStatusCodesError, PostApiV1PatentStatusCodesErrors, PostApiV1PatentStatusCodesResponse, PostApiV1PatentStatusCodesResponses, PostApiV1PatentTrialsDecisionsSearchData, PostApiV1PatentTrialsDecisionsSearchDownloadData, PostApiV1PatentTrialsDecisionsSearchDownloadError, PostApiV1PatentTrialsDecisionsSearchDownloadErrors, PostApiV1PatentTrialsDecisionsSearchDownloadResponse, PostApiV1PatentTrialsDecisionsSearchDownloadResponses, PostApiV1PatentTrialsDecisionsSearchError, PostApiV1PatentTrialsDecisionsSearchErrors, PostApiV1PatentTrialsDecisionsSearchResponse, PostApiV1PatentTrialsDecisionsSearchResponses, PostApiV1PatentTrialsDocumentsSearchData, PostApiV1PatentTrialsDocumentsSearchDownloadData, PostApiV1PatentTrialsDocumentsSearchDownloadError, PostApiV1PatentTrialsDocumentsSearchDownloadErrors, PostApiV1PatentTrialsDocumentsSearchDownloadResponse, PostApiV1PatentTrialsDocumentsSearchDownloadResponses, PostApiV1PatentTrialsDocumentsSearchError, PostApiV1PatentTrialsDocumentsSearchErrors, PostApiV1PatentTrialsDocumentsSearchResponse, PostApiV1PatentTrialsDocumentsSearchResponses, PostApiV1PatentTrialsProceedingsSearchData, PostApiV1PatentTrialsProceedingsSearchDownloadData, PostApiV1PatentTrialsProceedingsSearchDownloadError, PostApiV1PatentTrialsProceedingsSearchDownloadErrors, PostApiV1PatentTrialsProceedingsSearchDownloadResponse, PostApiV1PatentTrialsProceedingsSearchDownloadResponses, PostApiV1PatentTrialsProceedingsSearchError, PostApiV1PatentTrialsProceedingsSearchErrors, PostApiV1PatentTrialsProceedingsSearchResponse, PostApiV1PatentTrialsProceedingsSearchResponses, PostApiV1PetitionDecisionsSearchData, PostApiV1PetitionDecisionsSearchDownloadData, PostApiV1PetitionDecisionsSearchDownloadError, PostApiV1PetitionDecisionsSearchDownloadErrors, PostApiV1PetitionDecisionsSearchDownloadResponse, PostApiV1PetitionDecisionsSearchDownloadResponses, PostApiV1PetitionDecisionsSearchError, PostApiV1PetitionDecisionsSearchErrors, PostApiV1PetitionDecisionsSearchResponse, PostApiV1PetitionDecisionsSearchResponses, ProceedingDataResponse, ProductFileBag, Q, Range, RangeFilters, RecordAttorney, RegularPetitionerData, RespondentData, Response400, Response403, Response404, Response500, SearchRequest, Sort, Sort2, Status413, StatusCodeSearchRequest, StatusCodeSearchResponse, TrialMetaData };
+//# sourceMappingURL=types.gen.d.ts.map