@invinite-org/data-api-client 1.0.0 → 1.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,5 +1,6 @@
1
1
  .gitignore
2
2
  .npmignore
3
+ .openapi-generator-ignore
3
4
  README.md
4
5
  docs/AccountApi.md
5
6
  docs/AccountUsage200Response.md
@@ -240,6 +241,7 @@ docs/SecSearch200Response.md
240
241
  docs/SecSearch200ResponseHitsInner.md
241
242
  docs/SecSearchCoverage.md
242
243
  docs/SecSearchCoverageLexical.md
244
+ docs/SecSearchCoverageMatches.md
243
245
  docs/SecStoreError.md
244
246
  docs/SegmentedFinancials200Response.md
245
247
  docs/SegmentedFinancials200ResponseCompaniesInner.md
@@ -566,6 +568,7 @@ src/models/SecSearch200Response.ts
566
568
  src/models/SecSearch200ResponseHitsInner.ts
567
569
  src/models/SecSearchCoverage.ts
568
570
  src/models/SecSearchCoverageLexical.ts
571
+ src/models/SecSearchCoverageMatches.ts
569
572
  src/models/SecStoreError.ts
570
573
  src/models/SegmentedFinancials200Response.ts
571
574
  src/models/SegmentedFinancials200ResponseCompaniesInner.ts
@@ -619,12 +619,12 @@ export declare class SECApi extends runtime.BaseAPI {
619
619
  */
620
620
  secSearchRequestOpts(requestParameters: SecSearchRequest): Promise<runtime.RequestOpts>;
621
621
  /**
622
- * Find passages in SEC documents, with citations: `mode=lexical` (default; keywords and quoted phrases, English stemming, ranked) or `mode=literal` (the exact characters; `case_sensitive=false` folds case). The earnings search contract: every hit carries `match` (`type`, `lexical_rank`, `spans` = code-point offsets into `text`), `document_spans` (offsets into the document text and each block), the cited blocks with neighbors and footnotes, and `citation` (version, block, the original\'s permanent URL). `coverage` says how complete the answer is: `forms_indexed` / `years_indexed` state the index policy; empty hits with `completeness: complete` is a genuine no-result, anything else is not. A stale or expired cursor answers 409 `restart_required`. Read from Invinite\'s SEC document store: every answer carries `readiness` (`ready` / `partial` 200, `pending` 202 — retry later, not billed — `excluded` 403, `unknown` 404, `failed` 424, `not_ready` 503 while the capability is switched off). Originals, figures and PDFs are permanent public URLs; nothing is fetched from SEC on request. Minimum tier for rag: STANDARD.
622
+ * Find passages in SEC documents, with citations: `mode=lexical` (default; keywords and quoted phrases, English stemming, ranked) or `mode=literal` (the exact characters; `case_sensitive=false` folds case). The earnings search contract: every hit carries `match` (`type`, `lexical_rank`, `spans` = code-point offsets into `text`), `document_spans` (offsets into the document text and each block), the cited blocks with neighbors and footnotes, and `citation` (version, block, the original\'s permanent URL). `coverage` says how complete the answer is: `forms_indexed` / `years_indexed` state the index policy; empty hits with `completeness: complete` is a genuine no-result, anything else is not. A search WITHOUT any filter (no `cik` / `entity_id` / `accession` / `form` / date) reads at most `coverage.matches.cap` matching passages (index order, not newest-first): when more match, `readiness` is `partial` / `too_many_matches`, `coverage.matches` states how many passages were examined, that the total is unknown (`total: null`, `total_at_least`) and the filing dates the examined passages span, and `coverage.hint` says how to get complete results (narrow by filer, form or filing-date range); the hits returned are still ranked and cited. A filtered search is never capped. A capped search costs the same 100 credits (hits are returned). A stale or expired cursor answers 409 `restart_required`. Read from Invinite\'s SEC document store: every answer carries `readiness` (`ready` / `partial` 200, `pending` 202 — retry later, not billed — `excluded` 403, `unknown` 404, `failed` 424, `not_ready` 503 while the capability is switched off). Originals, figures and PDFs are permanent public URLs; nothing is fetched from SEC on request. Minimum tier for rag: STANDARD.
623
623
  * Search SEC documents
624
624
  */
625
625
  secSearchRaw(requestParameters: SecSearchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SecSearch200Response>>;
626
626
  /**
627
- * Find passages in SEC documents, with citations: `mode=lexical` (default; keywords and quoted phrases, English stemming, ranked) or `mode=literal` (the exact characters; `case_sensitive=false` folds case). The earnings search contract: every hit carries `match` (`type`, `lexical_rank`, `spans` = code-point offsets into `text`), `document_spans` (offsets into the document text and each block), the cited blocks with neighbors and footnotes, and `citation` (version, block, the original\'s permanent URL). `coverage` says how complete the answer is: `forms_indexed` / `years_indexed` state the index policy; empty hits with `completeness: complete` is a genuine no-result, anything else is not. A stale or expired cursor answers 409 `restart_required`. Read from Invinite\'s SEC document store: every answer carries `readiness` (`ready` / `partial` 200, `pending` 202 — retry later, not billed — `excluded` 403, `unknown` 404, `failed` 424, `not_ready` 503 while the capability is switched off). Originals, figures and PDFs are permanent public URLs; nothing is fetched from SEC on request. Minimum tier for rag: STANDARD.
627
+ * Find passages in SEC documents, with citations: `mode=lexical` (default; keywords and quoted phrases, English stemming, ranked) or `mode=literal` (the exact characters; `case_sensitive=false` folds case). The earnings search contract: every hit carries `match` (`type`, `lexical_rank`, `spans` = code-point offsets into `text`), `document_spans` (offsets into the document text and each block), the cited blocks with neighbors and footnotes, and `citation` (version, block, the original\'s permanent URL). `coverage` says how complete the answer is: `forms_indexed` / `years_indexed` state the index policy; empty hits with `completeness: complete` is a genuine no-result, anything else is not. A search WITHOUT any filter (no `cik` / `entity_id` / `accession` / `form` / date) reads at most `coverage.matches.cap` matching passages (index order, not newest-first): when more match, `readiness` is `partial` / `too_many_matches`, `coverage.matches` states how many passages were examined, that the total is unknown (`total: null`, `total_at_least`) and the filing dates the examined passages span, and `coverage.hint` says how to get complete results (narrow by filer, form or filing-date range); the hits returned are still ranked and cited. A filtered search is never capped. A capped search costs the same 100 credits (hits are returned). A stale or expired cursor answers 409 `restart_required`. Read from Invinite\'s SEC document store: every answer carries `readiness` (`ready` / `partial` 200, `pending` 202 — retry later, not billed — `excluded` 403, `unknown` 404, `failed` 424, `not_ready` 503 while the capability is switched off). Originals, figures and PDFs are permanent public URLs; nothing is fetched from SEC on request. Minimum tier for rag: STANDARD.
628
628
  * Search SEC documents
629
629
  */
630
630
  secSearch(requestParameters: SecSearchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SecSearch200Response>;
@@ -1750,7 +1750,7 @@ class SECApi extends runtime.BaseAPI {
1750
1750
  });
1751
1751
  }
1752
1752
  /**
1753
- * Find passages in SEC documents, with citations: `mode=lexical` (default; keywords and quoted phrases, English stemming, ranked) or `mode=literal` (the exact characters; `case_sensitive=false` folds case). The earnings search contract: every hit carries `match` (`type`, `lexical_rank`, `spans` = code-point offsets into `text`), `document_spans` (offsets into the document text and each block), the cited blocks with neighbors and footnotes, and `citation` (version, block, the original\'s permanent URL). `coverage` says how complete the answer is: `forms_indexed` / `years_indexed` state the index policy; empty hits with `completeness: complete` is a genuine no-result, anything else is not. A stale or expired cursor answers 409 `restart_required`. Read from Invinite\'s SEC document store: every answer carries `readiness` (`ready` / `partial` 200, `pending` 202 — retry later, not billed — `excluded` 403, `unknown` 404, `failed` 424, `not_ready` 503 while the capability is switched off). Originals, figures and PDFs are permanent public URLs; nothing is fetched from SEC on request. Minimum tier for rag: STANDARD.
1753
+ * Find passages in SEC documents, with citations: `mode=lexical` (default; keywords and quoted phrases, English stemming, ranked) or `mode=literal` (the exact characters; `case_sensitive=false` folds case). The earnings search contract: every hit carries `match` (`type`, `lexical_rank`, `spans` = code-point offsets into `text`), `document_spans` (offsets into the document text and each block), the cited blocks with neighbors and footnotes, and `citation` (version, block, the original\'s permanent URL). `coverage` says how complete the answer is: `forms_indexed` / `years_indexed` state the index policy; empty hits with `completeness: complete` is a genuine no-result, anything else is not. A search WITHOUT any filter (no `cik` / `entity_id` / `accession` / `form` / date) reads at most `coverage.matches.cap` matching passages (index order, not newest-first): when more match, `readiness` is `partial` / `too_many_matches`, `coverage.matches` states how many passages were examined, that the total is unknown (`total: null`, `total_at_least`) and the filing dates the examined passages span, and `coverage.hint` says how to get complete results (narrow by filer, form or filing-date range); the hits returned are still ranked and cited. A filtered search is never capped. A capped search costs the same 100 credits (hits are returned). A stale or expired cursor answers 409 `restart_required`. Read from Invinite\'s SEC document store: every answer carries `readiness` (`ready` / `partial` 200, `pending` 202 — retry later, not billed — `excluded` 403, `unknown` 404, `failed` 424, `not_ready` 503 while the capability is switched off). Originals, figures and PDFs are permanent public URLs; nothing is fetched from SEC on request. Minimum tier for rag: STANDARD.
1754
1754
  * Search SEC documents
1755
1755
  */
1756
1756
  secSearchRaw(requestParameters, initOverrides) {
@@ -1761,7 +1761,7 @@ class SECApi extends runtime.BaseAPI {
1761
1761
  });
1762
1762
  }
1763
1763
  /**
1764
- * Find passages in SEC documents, with citations: `mode=lexical` (default; keywords and quoted phrases, English stemming, ranked) or `mode=literal` (the exact characters; `case_sensitive=false` folds case). The earnings search contract: every hit carries `match` (`type`, `lexical_rank`, `spans` = code-point offsets into `text`), `document_spans` (offsets into the document text and each block), the cited blocks with neighbors and footnotes, and `citation` (version, block, the original\'s permanent URL). `coverage` says how complete the answer is: `forms_indexed` / `years_indexed` state the index policy; empty hits with `completeness: complete` is a genuine no-result, anything else is not. A stale or expired cursor answers 409 `restart_required`. Read from Invinite\'s SEC document store: every answer carries `readiness` (`ready` / `partial` 200, `pending` 202 — retry later, not billed — `excluded` 403, `unknown` 404, `failed` 424, `not_ready` 503 while the capability is switched off). Originals, figures and PDFs are permanent public URLs; nothing is fetched from SEC on request. Minimum tier for rag: STANDARD.
1764
+ * Find passages in SEC documents, with citations: `mode=lexical` (default; keywords and quoted phrases, English stemming, ranked) or `mode=literal` (the exact characters; `case_sensitive=false` folds case). The earnings search contract: every hit carries `match` (`type`, `lexical_rank`, `spans` = code-point offsets into `text`), `document_spans` (offsets into the document text and each block), the cited blocks with neighbors and footnotes, and `citation` (version, block, the original\'s permanent URL). `coverage` says how complete the answer is: `forms_indexed` / `years_indexed` state the index policy; empty hits with `completeness: complete` is a genuine no-result, anything else is not. A search WITHOUT any filter (no `cik` / `entity_id` / `accession` / `form` / date) reads at most `coverage.matches.cap` matching passages (index order, not newest-first): when more match, `readiness` is `partial` / `too_many_matches`, `coverage.matches` states how many passages were examined, that the total is unknown (`total: null`, `total_at_least`) and the filing dates the examined passages span, and `coverage.hint` says how to get complete results (narrow by filer, form or filing-date range); the hits returned are still ranked and cited. A filtered search is never capped. A capped search costs the same 100 credits (hits are returned). A stale or expired cursor answers 409 `restart_required`. Read from Invinite\'s SEC document store: every answer carries `readiness` (`ready` / `partial` 200, `pending` 202 — retry later, not billed — `excluded` 403, `unknown` 404, `failed` 424, `not_ready` 503 while the capability is switched off). Originals, figures and PDFs are permanent public URLs; nothing is fetched from SEC on request. Minimum tier for rag: STANDARD.
1765
1765
  * Search SEC documents
1766
1766
  */
1767
1767
  secSearch(requestParameters, initOverrides) {
@@ -619,12 +619,12 @@ export declare class SECApi extends runtime.BaseAPI {
619
619
  */
620
620
  secSearchRequestOpts(requestParameters: SecSearchRequest): Promise<runtime.RequestOpts>;
621
621
  /**
622
- * Find passages in SEC documents, with citations: `mode=lexical` (default; keywords and quoted phrases, English stemming, ranked) or `mode=literal` (the exact characters; `case_sensitive=false` folds case). The earnings search contract: every hit carries `match` (`type`, `lexical_rank`, `spans` = code-point offsets into `text`), `document_spans` (offsets into the document text and each block), the cited blocks with neighbors and footnotes, and `citation` (version, block, the original\'s permanent URL). `coverage` says how complete the answer is: `forms_indexed` / `years_indexed` state the index policy; empty hits with `completeness: complete` is a genuine no-result, anything else is not. A stale or expired cursor answers 409 `restart_required`. Read from Invinite\'s SEC document store: every answer carries `readiness` (`ready` / `partial` 200, `pending` 202 — retry later, not billed — `excluded` 403, `unknown` 404, `failed` 424, `not_ready` 503 while the capability is switched off). Originals, figures and PDFs are permanent public URLs; nothing is fetched from SEC on request. Minimum tier for rag: STANDARD.
622
+ * Find passages in SEC documents, with citations: `mode=lexical` (default; keywords and quoted phrases, English stemming, ranked) or `mode=literal` (the exact characters; `case_sensitive=false` folds case). The earnings search contract: every hit carries `match` (`type`, `lexical_rank`, `spans` = code-point offsets into `text`), `document_spans` (offsets into the document text and each block), the cited blocks with neighbors and footnotes, and `citation` (version, block, the original\'s permanent URL). `coverage` says how complete the answer is: `forms_indexed` / `years_indexed` state the index policy; empty hits with `completeness: complete` is a genuine no-result, anything else is not. A search WITHOUT any filter (no `cik` / `entity_id` / `accession` / `form` / date) reads at most `coverage.matches.cap` matching passages (index order, not newest-first): when more match, `readiness` is `partial` / `too_many_matches`, `coverage.matches` states how many passages were examined, that the total is unknown (`total: null`, `total_at_least`) and the filing dates the examined passages span, and `coverage.hint` says how to get complete results (narrow by filer, form or filing-date range); the hits returned are still ranked and cited. A filtered search is never capped. A capped search costs the same 100 credits (hits are returned). A stale or expired cursor answers 409 `restart_required`. Read from Invinite\'s SEC document store: every answer carries `readiness` (`ready` / `partial` 200, `pending` 202 — retry later, not billed — `excluded` 403, `unknown` 404, `failed` 424, `not_ready` 503 while the capability is switched off). Originals, figures and PDFs are permanent public URLs; nothing is fetched from SEC on request. Minimum tier for rag: STANDARD.
623
623
  * Search SEC documents
624
624
  */
625
625
  secSearchRaw(requestParameters: SecSearchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SecSearch200Response>>;
626
626
  /**
627
- * Find passages in SEC documents, with citations: `mode=lexical` (default; keywords and quoted phrases, English stemming, ranked) or `mode=literal` (the exact characters; `case_sensitive=false` folds case). The earnings search contract: every hit carries `match` (`type`, `lexical_rank`, `spans` = code-point offsets into `text`), `document_spans` (offsets into the document text and each block), the cited blocks with neighbors and footnotes, and `citation` (version, block, the original\'s permanent URL). `coverage` says how complete the answer is: `forms_indexed` / `years_indexed` state the index policy; empty hits with `completeness: complete` is a genuine no-result, anything else is not. A stale or expired cursor answers 409 `restart_required`. Read from Invinite\'s SEC document store: every answer carries `readiness` (`ready` / `partial` 200, `pending` 202 — retry later, not billed — `excluded` 403, `unknown` 404, `failed` 424, `not_ready` 503 while the capability is switched off). Originals, figures and PDFs are permanent public URLs; nothing is fetched from SEC on request. Minimum tier for rag: STANDARD.
627
+ * Find passages in SEC documents, with citations: `mode=lexical` (default; keywords and quoted phrases, English stemming, ranked) or `mode=literal` (the exact characters; `case_sensitive=false` folds case). The earnings search contract: every hit carries `match` (`type`, `lexical_rank`, `spans` = code-point offsets into `text`), `document_spans` (offsets into the document text and each block), the cited blocks with neighbors and footnotes, and `citation` (version, block, the original\'s permanent URL). `coverage` says how complete the answer is: `forms_indexed` / `years_indexed` state the index policy; empty hits with `completeness: complete` is a genuine no-result, anything else is not. A search WITHOUT any filter (no `cik` / `entity_id` / `accession` / `form` / date) reads at most `coverage.matches.cap` matching passages (index order, not newest-first): when more match, `readiness` is `partial` / `too_many_matches`, `coverage.matches` states how many passages were examined, that the total is unknown (`total: null`, `total_at_least`) and the filing dates the examined passages span, and `coverage.hint` says how to get complete results (narrow by filer, form or filing-date range); the hits returned are still ranked and cited. A filtered search is never capped. A capped search costs the same 100 credits (hits are returned). A stale or expired cursor answers 409 `restart_required`. Read from Invinite\'s SEC document store: every answer carries `readiness` (`ready` / `partial` 200, `pending` 202 — retry later, not billed — `excluded` 403, `unknown` 404, `failed` 424, `not_ready` 503 while the capability is switched off). Originals, figures and PDFs are permanent public URLs; nothing is fetched from SEC on request. Minimum tier for rag: STANDARD.
628
628
  * Search SEC documents
629
629
  */
630
630
  secSearch(requestParameters: SecSearchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SecSearch200Response>;
@@ -1747,7 +1747,7 @@ export class SECApi extends runtime.BaseAPI {
1747
1747
  });
1748
1748
  }
1749
1749
  /**
1750
- * Find passages in SEC documents, with citations: `mode=lexical` (default; keywords and quoted phrases, English stemming, ranked) or `mode=literal` (the exact characters; `case_sensitive=false` folds case). The earnings search contract: every hit carries `match` (`type`, `lexical_rank`, `spans` = code-point offsets into `text`), `document_spans` (offsets into the document text and each block), the cited blocks with neighbors and footnotes, and `citation` (version, block, the original\'s permanent URL). `coverage` says how complete the answer is: `forms_indexed` / `years_indexed` state the index policy; empty hits with `completeness: complete` is a genuine no-result, anything else is not. A stale or expired cursor answers 409 `restart_required`. Read from Invinite\'s SEC document store: every answer carries `readiness` (`ready` / `partial` 200, `pending` 202 — retry later, not billed — `excluded` 403, `unknown` 404, `failed` 424, `not_ready` 503 while the capability is switched off). Originals, figures and PDFs are permanent public URLs; nothing is fetched from SEC on request. Minimum tier for rag: STANDARD.
1750
+ * Find passages in SEC documents, with citations: `mode=lexical` (default; keywords and quoted phrases, English stemming, ranked) or `mode=literal` (the exact characters; `case_sensitive=false` folds case). The earnings search contract: every hit carries `match` (`type`, `lexical_rank`, `spans` = code-point offsets into `text`), `document_spans` (offsets into the document text and each block), the cited blocks with neighbors and footnotes, and `citation` (version, block, the original\'s permanent URL). `coverage` says how complete the answer is: `forms_indexed` / `years_indexed` state the index policy; empty hits with `completeness: complete` is a genuine no-result, anything else is not. A search WITHOUT any filter (no `cik` / `entity_id` / `accession` / `form` / date) reads at most `coverage.matches.cap` matching passages (index order, not newest-first): when more match, `readiness` is `partial` / `too_many_matches`, `coverage.matches` states how many passages were examined, that the total is unknown (`total: null`, `total_at_least`) and the filing dates the examined passages span, and `coverage.hint` says how to get complete results (narrow by filer, form or filing-date range); the hits returned are still ranked and cited. A filtered search is never capped. A capped search costs the same 100 credits (hits are returned). A stale or expired cursor answers 409 `restart_required`. Read from Invinite\'s SEC document store: every answer carries `readiness` (`ready` / `partial` 200, `pending` 202 — retry later, not billed — `excluded` 403, `unknown` 404, `failed` 424, `not_ready` 503 while the capability is switched off). Originals, figures and PDFs are permanent public URLs; nothing is fetched from SEC on request. Minimum tier for rag: STANDARD.
1751
1751
  * Search SEC documents
1752
1752
  */
1753
1753
  secSearchRaw(requestParameters, initOverrides) {
@@ -1758,7 +1758,7 @@ export class SECApi extends runtime.BaseAPI {
1758
1758
  });
1759
1759
  }
1760
1760
  /**
1761
- * Find passages in SEC documents, with citations: `mode=lexical` (default; keywords and quoted phrases, English stemming, ranked) or `mode=literal` (the exact characters; `case_sensitive=false` folds case). The earnings search contract: every hit carries `match` (`type`, `lexical_rank`, `spans` = code-point offsets into `text`), `document_spans` (offsets into the document text and each block), the cited blocks with neighbors and footnotes, and `citation` (version, block, the original\'s permanent URL). `coverage` says how complete the answer is: `forms_indexed` / `years_indexed` state the index policy; empty hits with `completeness: complete` is a genuine no-result, anything else is not. A stale or expired cursor answers 409 `restart_required`. Read from Invinite\'s SEC document store: every answer carries `readiness` (`ready` / `partial` 200, `pending` 202 — retry later, not billed — `excluded` 403, `unknown` 404, `failed` 424, `not_ready` 503 while the capability is switched off). Originals, figures and PDFs are permanent public URLs; nothing is fetched from SEC on request. Minimum tier for rag: STANDARD.
1761
+ * Find passages in SEC documents, with citations: `mode=lexical` (default; keywords and quoted phrases, English stemming, ranked) or `mode=literal` (the exact characters; `case_sensitive=false` folds case). The earnings search contract: every hit carries `match` (`type`, `lexical_rank`, `spans` = code-point offsets into `text`), `document_spans` (offsets into the document text and each block), the cited blocks with neighbors and footnotes, and `citation` (version, block, the original\'s permanent URL). `coverage` says how complete the answer is: `forms_indexed` / `years_indexed` state the index policy; empty hits with `completeness: complete` is a genuine no-result, anything else is not. A search WITHOUT any filter (no `cik` / `entity_id` / `accession` / `form` / date) reads at most `coverage.matches.cap` matching passages (index order, not newest-first): when more match, `readiness` is `partial` / `too_many_matches`, `coverage.matches` states how many passages were examined, that the total is unknown (`total: null`, `total_at_least`) and the filing dates the examined passages span, and `coverage.hint` says how to get complete results (narrow by filer, form or filing-date range); the hits returned are still ranked and cited. A filtered search is never capped. A capped search costs the same 100 credits (hits are returned). A stale or expired cursor answers 409 `restart_required`. Read from Invinite\'s SEC document store: every answer carries `readiness` (`ready` / `partial` 200, `pending` 202 — retry later, not billed — `excluded` 403, `unknown` 404, `failed` 424, `not_ready` 503 while the capability is switched off). Originals, figures and PDFs are permanent public URLs; nothing is fetched from SEC on request. Minimum tier for rag: STANDARD.
1762
1762
  * Search SEC documents
1763
1763
  */
1764
1764
  secSearch(requestParameters, initOverrides) {
@@ -10,6 +10,7 @@
10
10
  * Do not edit the class manually.
11
11
  */
12
12
  import type { SecSearchCoverageLexical } from './SecSearchCoverageLexical';
13
+ import type { SecSearchCoverageMatches } from './SecSearchCoverageMatches';
13
14
  /**
14
15
  * How much of the searched SEC scope the text index covers (the earnings search vocabulary). `forms_indexed` / `years_indexed` / `indexed_since` state the index policy; documents of other forms are counted in `lexical.not_indexed_by_policy` (by design, not a gap). For exactly one `cik`, `held` / `mirror` say how much of the filer's history is held (`held_through`).
15
16
  * @export
@@ -30,7 +31,7 @@ export interface SecSearchCoverage {
30
31
  */
31
32
  lexical: SecSearchCoverageLexical | null;
32
33
  /**
33
- * Why the answer may be incomplete: not_projected, projection_failed, not_published, not_held, held_not_verified, candidate_cap_reached, scan_budget_reached, scope_needs_review, scope_not_current, form_not_indexed, older_than_index_window, no_forms_indexed, held_gap, search_provider_not_registered, search_projection_empty, search_timeout, scope_excluded, documents_not_held
34
+ * Why the answer may be incomplete: not_projected, projection_failed, not_published, not_held, held_not_verified, too_many_matches, candidate_cap_reached, scan_budget_reached, scope_needs_review, scope_not_current, form_not_indexed, older_than_index_window, no_forms_indexed, held_gap, search_provider_not_registered, search_projection_empty, search_timeout, scope_excluded, documents_not_held
34
35
  * @type {Array<string>}
35
36
  * @memberof SecSearchCoverage
36
37
  */
@@ -41,6 +42,18 @@ export interface SecSearchCoverage {
41
42
  * @memberof SecSearchCoverage
42
43
  */
43
44
  forms_indexed?: Array<string> | null;
45
+ /**
46
+ *
47
+ * @type {SecSearchCoverageMatches}
48
+ * @memberof SecSearchCoverage
49
+ */
50
+ matches?: SecSearchCoverageMatches | null;
51
+ /**
52
+ * What to do for a complete answer (set when `matches.capped`; null otherwise)
53
+ * @type {string}
54
+ * @memberof SecSearchCoverage
55
+ */
56
+ hint?: string | null;
44
57
  }
45
58
  /**
46
59
  * @export
@@ -12,6 +12,7 @@
12
12
  * Do not edit the class manually.
13
13
  */
14
14
  import { SecSearchCoverageLexicalFromJSON, SecSearchCoverageLexicalToJSON, } from './SecSearchCoverageLexical';
15
+ import { SecSearchCoverageMatchesFromJSON, SecSearchCoverageMatchesToJSON, } from './SecSearchCoverageMatches';
15
16
  /**
16
17
  * @export
17
18
  */
@@ -39,7 +40,7 @@ export function SecSearchCoverageFromJSONTyped(json, ignoreDiscriminator) {
39
40
  if (json == null) {
40
41
  return json;
41
42
  }
42
- return Object.assign(Object.assign({}, json), { 'completeness': json['completeness'], 'lexical': SecSearchCoverageLexicalFromJSON(json['lexical']), 'reasons': json['reasons'], 'forms_indexed': json['forms_indexed'] == null ? undefined : json['forms_indexed'] });
43
+ return Object.assign(Object.assign({}, json), { 'completeness': json['completeness'], 'lexical': SecSearchCoverageLexicalFromJSON(json['lexical']), 'reasons': json['reasons'], 'forms_indexed': json['forms_indexed'] == null ? undefined : json['forms_indexed'], 'matches': json['matches'] == null ? undefined : SecSearchCoverageMatchesFromJSON(json['matches']), 'hint': json['hint'] == null ? undefined : json['hint'] });
43
44
  }
44
45
  export function SecSearchCoverageToJSON(json) {
45
46
  return SecSearchCoverageToJSONTyped(json, false);
@@ -48,5 +49,5 @@ export function SecSearchCoverageToJSONTyped(value, ignoreDiscriminator = false)
48
49
  if (value == null) {
49
50
  return value;
50
51
  }
51
- return Object.assign(Object.assign({}, value), { 'completeness': value['completeness'], 'lexical': SecSearchCoverageLexicalToJSON(value['lexical']), 'reasons': value['reasons'], 'forms_indexed': value['forms_indexed'] });
52
+ return Object.assign(Object.assign({}, value), { 'completeness': value['completeness'], 'lexical': SecSearchCoverageLexicalToJSON(value['lexical']), 'reasons': value['reasons'], 'forms_indexed': value['forms_indexed'], 'matches': SecSearchCoverageMatchesToJSON(value['matches']), 'hint': value['hint'] });
52
53
  }
@@ -0,0 +1,94 @@
1
+ /**
2
+ * Invinite API
3
+ * Invinite financial data API. Each endpoint has a base credit cost: `x-credits` is the base cost; responses add 1 credit per started 1,000 rows beyond the first 1,000; `X-Credits-Charged` reports the final debit and `X-Credits-Included-Remaining` what is left of the plan\'s included credits. `GET /v1/account/usage` returns your account\'s usage by day, endpoint family and key (it costs no credits). SEC filing search has a 100-credit base cost. **Coverage.** Financial data covers SEC registrants and US listings; a foreign suffix (`SAP.DE`, `VOD.L`) or a crypto pair (`X:BTCUSD`) is not a known company and answers 404. A known company with no data in a family (for example no statements yet) answers 404 with `code: not_covered`; an empty page of a covered company stays 200 with an empty list. `GET /v1/company/available-companies` lists every known company. ## Webhooks Accounts on LITE and above subscribe with `POST /v1/earnings-calls/webhooks` to the `earnings_call.*` lifecycle events (filtered by CIK) and, on STANDARD and above, to `news.published` (one delivery per new news item, filtered by the CIKs it mentions); see `x-webhooks` for each `data` object. What a subscription may hold depends on the plan (a create / update beyond it is refused with the plan\'s limit; `ping` needs no subscription — the test route and the disabled notice send it to any subscription): | Plan | Webhooks | Events | CIKs per webhook | Keywords per webhook | |---|---|---|---|---| | FREE | 0 | — | — | — | | LITE | 5 | `.scheduled`, `.rescheduled`, `.started`, `.ended`, `.transcript_ready`, `.assets_ready` | ≤ 10 | — | | STANDARD | 15 | LITE + `.transcript_provisional`, `.transcript_corrected`, `.documents_updated`, `news.published` | ≤ 25 | — | | PRO / ENTERPRISE | 50 | STANDARD + `.guidance_flash`, `.keyword_hit` | ≤ 100 | ≤ 20 (on ≤ 10 webhooks) | Every delivery is a `POST` with `Content-Type: application/json`, `X-Invinite-Event`, `X-Invinite-Delivery` and `X-Invinite-Signature: t=<unix seconds>,v1=<hex>` where `v1` = HMAC-SHA256(secret, `<t>.<raw body>`); during a secret rotation the header carries one `v1` per valid secret. Reject a signature older than 5 minutes. Any 2xx within 10 s acknowledges; redirects are not followed. A failed delivery is retried after 1 min, 5 min, 30 min, 2 h, 6 h, 12 h, 24 h (8 attempts in all, the same delivery id each time). A subscription is disabled after 8 consecutive dead-lettered deliveries (a final `ping` with `notice: subscription_disabled` is sent). Deliveries are at-least-once and unordered: dedupe on the delivery id, order by `created_at`. ## Licensing | Tier | display | redistribute | rag | train | audio | resell | | --- | --- | --- | --- | --- | --- | --- | | FREE | ✓ | – | – | – | – | – | | LITE | ✓ | – | – | – | – | – | | STANDARD | ✓ | – | ✓ | – | – | – | | PRO | ✓ | ✓ | ✓ | – | ✓ | – | Invinite data may be shown and, from PRO, redistributed inside the licensee\'s own product with attribution (\"Source: Invinite\" on screen or in the API response that carries it). It may never be resold, relicensed, white-labelled or offered as a data feed as the licensee\'s own data, at any tier, under any contract. Policy version: 2026-10-draft. Draft — pending counsel sign-off. Audio files carry a forensic watermark that identifies the recording. Audio is subject to per-company takedown and may not be re-hosted. SEC data: Figures and filings originate from SEC EDGAR; the standardisation, mapping and derived metrics are Invinite\'s. News: Issuer and SEC text is served in full with its attribution; the licensee shows publisher, source URL and date next to it and may forward it unmodified; the resale rule applies. PDF documents: Branded PDFs of transcripts and news items are permanent URLs to one shared file per version. They may be shown, downloaded and forwarded unmodified with the notice page intact; the resale rule applies unchanged. News PDFs reproduce issuer or SEC text under the attribution stated on their notice page; a PDF disappears when the item is taken down or its source\'s reuse is denied. Every `/v1/_*` data operation carries `x-license`, the minimum use right its data ships with; `GET /status/licensing` serves the same matrix per route, rendered at [data.invinite.com/docs/licensing](https://data.invinite.com/docs/licensing). `/v1/account/usage` serves no licensed data and carries none. ## Status [`/status`](/status) reports whether each product family works (a status and its uptime over 7, 30 and 90 days); [`/status/licensing`](/status/licensing) serves the licensing matrix per route. The status routes need no API key and are cached for 5 minutes. The public status page is [status.data.invinite.com](https://status.data.invinite.com): a snapshot of `/status` every 15 minutes plus an external reachability probe of the API. Uptime is the share of requests answered without a server error, measured by the API per product family; a window with too little traffic to judge shows no figure. Status reflects the last 24 hours. Product families: Company, Financials, SEC Filings, Insider Trades, Institutional Ownership, IPOs, Market, Metadata, Earnings Calls, News, WebSocket, Account.
4
+ *
5
+ * The version of the OpenAPI document: 1.0.0
6
+ *
7
+ *
8
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
9
+ * https://openapi-generator.tech
10
+ * Do not edit the class manually.
11
+ */
12
+ /**
13
+ * The selectivity cap of a search WITHOUT any filter (null for a filtered search, which is never capped): at most `cap` matching passages are read from the index, in index order (not ranked, not newest-first), then ranked and cited
14
+ * @export
15
+ * @interface SecSearchCoverageMatches
16
+ */
17
+ export interface SecSearchCoverageMatches {
18
+ [key: string]: any | any;
19
+ /**
20
+ * true = more passages match than were examined: the answer is partial (`too_many_matches`)
21
+ * @type {boolean}
22
+ * @memberof SecSearchCoverageMatches
23
+ */
24
+ capped: boolean;
25
+ /**
26
+ * The most matching passages an unfiltered search reads
27
+ * @type {number}
28
+ * @memberof SecSearchCoverageMatches
29
+ */
30
+ cap: number;
31
+ /**
32
+ * Matching passages read from the index (at most `cap`)
33
+ * @type {number}
34
+ * @memberof SecSearchCoverageMatches
35
+ */
36
+ examined: number;
37
+ /**
38
+ * Of them, passages in searchable documents: the set the hits are ranked from
39
+ * @type {number}
40
+ * @memberof SecSearchCoverageMatches
41
+ */
42
+ examined_in_scope: number;
43
+ /**
44
+ * Every matching passage when not capped; null when capped (the total is unknown)
45
+ * @type {number}
46
+ * @memberof SecSearchCoverageMatches
47
+ */
48
+ total: number | null;
49
+ /**
50
+ * When capped: the total is at least this (cap + 1); never an estimate. null when not capped
51
+ * @type {number}
52
+ * @memberof SecSearchCoverageMatches
53
+ */
54
+ total_at_least: number | null;
55
+ /**
56
+ * Which passages were examined: the first ones the index returned (not newest-first)
57
+ * @type {SecSearchCoverageMatchesOrderEnum}
58
+ * @memberof SecSearchCoverageMatches
59
+ */
60
+ order: SecSearchCoverageMatchesOrderEnum;
61
+ /**
62
+ * Earliest filing date among the examined passages in searchable documents
63
+ * @type {Date}
64
+ * @memberof SecSearchCoverageMatches
65
+ */
66
+ filed_from: Date | null;
67
+ /**
68
+ * Latest filing date among the examined passages in searchable documents
69
+ * @type {Date}
70
+ * @memberof SecSearchCoverageMatches
71
+ */
72
+ filed_to: Date | null;
73
+ /**
74
+ * What makes the search complete: filer (`cik`), entity (`entity_id`), form (`form`), filed_from / filed_to (`filed_from` / `filed_to`), accession (`accession`)
75
+ * @type {Array<string>}
76
+ * @memberof SecSearchCoverageMatches
77
+ */
78
+ narrow_with: Array<string>;
79
+ }
80
+ /**
81
+ * @export
82
+ */
83
+ export declare const SecSearchCoverageMatchesOrderEnum: {
84
+ readonly IndexOrder: "index_order";
85
+ };
86
+ export type SecSearchCoverageMatchesOrderEnum = typeof SecSearchCoverageMatchesOrderEnum[keyof typeof SecSearchCoverageMatchesOrderEnum];
87
+ /**
88
+ * Check if a given object implements the SecSearchCoverageMatches interface.
89
+ */
90
+ export declare function instanceOfSecSearchCoverageMatches(value: object): value is SecSearchCoverageMatches;
91
+ export declare function SecSearchCoverageMatchesFromJSON(json: any): SecSearchCoverageMatches;
92
+ export declare function SecSearchCoverageMatchesFromJSONTyped(json: any, ignoreDiscriminator: boolean): SecSearchCoverageMatches;
93
+ export declare function SecSearchCoverageMatchesToJSON(json: any): SecSearchCoverageMatches;
94
+ export declare function SecSearchCoverageMatchesToJSONTyped(value?: SecSearchCoverageMatches | null, ignoreDiscriminator?: boolean): any;
@@ -0,0 +1,65 @@
1
+ /* tslint:disable */
2
+ /* eslint-disable */
3
+ /**
4
+ * Invinite API
5
+ * Invinite financial data API. Each endpoint has a base credit cost: `x-credits` is the base cost; responses add 1 credit per started 1,000 rows beyond the first 1,000; `X-Credits-Charged` reports the final debit and `X-Credits-Included-Remaining` what is left of the plan\'s included credits. `GET /v1/account/usage` returns your account\'s usage by day, endpoint family and key (it costs no credits). SEC filing search has a 100-credit base cost. **Coverage.** Financial data covers SEC registrants and US listings; a foreign suffix (`SAP.DE`, `VOD.L`) or a crypto pair (`X:BTCUSD`) is not a known company and answers 404. A known company with no data in a family (for example no statements yet) answers 404 with `code: not_covered`; an empty page of a covered company stays 200 with an empty list. `GET /v1/company/available-companies` lists every known company. ## Webhooks Accounts on LITE and above subscribe with `POST /v1/earnings-calls/webhooks` to the `earnings_call.*` lifecycle events (filtered by CIK) and, on STANDARD and above, to `news.published` (one delivery per new news item, filtered by the CIKs it mentions); see `x-webhooks` for each `data` object. What a subscription may hold depends on the plan (a create / update beyond it is refused with the plan\'s limit; `ping` needs no subscription — the test route and the disabled notice send it to any subscription): | Plan | Webhooks | Events | CIKs per webhook | Keywords per webhook | |---|---|---|---|---| | FREE | 0 | — | — | — | | LITE | 5 | `.scheduled`, `.rescheduled`, `.started`, `.ended`, `.transcript_ready`, `.assets_ready` | ≤ 10 | — | | STANDARD | 15 | LITE + `.transcript_provisional`, `.transcript_corrected`, `.documents_updated`, `news.published` | ≤ 25 | — | | PRO / ENTERPRISE | 50 | STANDARD + `.guidance_flash`, `.keyword_hit` | ≤ 100 | ≤ 20 (on ≤ 10 webhooks) | Every delivery is a `POST` with `Content-Type: application/json`, `X-Invinite-Event`, `X-Invinite-Delivery` and `X-Invinite-Signature: t=<unix seconds>,v1=<hex>` where `v1` = HMAC-SHA256(secret, `<t>.<raw body>`); during a secret rotation the header carries one `v1` per valid secret. Reject a signature older than 5 minutes. Any 2xx within 10 s acknowledges; redirects are not followed. A failed delivery is retried after 1 min, 5 min, 30 min, 2 h, 6 h, 12 h, 24 h (8 attempts in all, the same delivery id each time). A subscription is disabled after 8 consecutive dead-lettered deliveries (a final `ping` with `notice: subscription_disabled` is sent). Deliveries are at-least-once and unordered: dedupe on the delivery id, order by `created_at`. ## Licensing | Tier | display | redistribute | rag | train | audio | resell | | --- | --- | --- | --- | --- | --- | --- | | FREE | ✓ | – | – | – | – | – | | LITE | ✓ | – | – | – | – | – | | STANDARD | ✓ | – | ✓ | – | – | – | | PRO | ✓ | ✓ | ✓ | – | ✓ | – | Invinite data may be shown and, from PRO, redistributed inside the licensee\'s own product with attribution (\"Source: Invinite\" on screen or in the API response that carries it). It may never be resold, relicensed, white-labelled or offered as a data feed as the licensee\'s own data, at any tier, under any contract. Policy version: 2026-10-draft. Draft — pending counsel sign-off. Audio files carry a forensic watermark that identifies the recording. Audio is subject to per-company takedown and may not be re-hosted. SEC data: Figures and filings originate from SEC EDGAR; the standardisation, mapping and derived metrics are Invinite\'s. News: Issuer and SEC text is served in full with its attribution; the licensee shows publisher, source URL and date next to it and may forward it unmodified; the resale rule applies. PDF documents: Branded PDFs of transcripts and news items are permanent URLs to one shared file per version. They may be shown, downloaded and forwarded unmodified with the notice page intact; the resale rule applies unchanged. News PDFs reproduce issuer or SEC text under the attribution stated on their notice page; a PDF disappears when the item is taken down or its source\'s reuse is denied. Every `/v1/_*` data operation carries `x-license`, the minimum use right its data ships with; `GET /status/licensing` serves the same matrix per route, rendered at [data.invinite.com/docs/licensing](https://data.invinite.com/docs/licensing). `/v1/account/usage` serves no licensed data and carries none. ## Status [`/status`](/status) reports whether each product family works (a status and its uptime over 7, 30 and 90 days); [`/status/licensing`](/status/licensing) serves the licensing matrix per route. The status routes need no API key and are cached for 5 minutes. The public status page is [status.data.invinite.com](https://status.data.invinite.com): a snapshot of `/status` every 15 minutes plus an external reachability probe of the API. Uptime is the share of requests answered without a server error, measured by the API per product family; a window with too little traffic to judge shows no figure. Status reflects the last 24 hours. Product families: Company, Financials, SEC Filings, Insider Trades, Institutional Ownership, IPOs, Market, Metadata, Earnings Calls, News, WebSocket, Account.
6
+ *
7
+ * The version of the OpenAPI document: 1.0.0
8
+ *
9
+ *
10
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
11
+ * https://openapi-generator.tech
12
+ * Do not edit the class manually.
13
+ */
14
+ /**
15
+ * @export
16
+ */
17
+ export const SecSearchCoverageMatchesOrderEnum = {
18
+ IndexOrder: 'index_order'
19
+ };
20
+ /**
21
+ * Check if a given object implements the SecSearchCoverageMatches interface.
22
+ */
23
+ export function instanceOfSecSearchCoverageMatches(value) {
24
+ if (!('capped' in value) || value['capped'] === undefined)
25
+ return false;
26
+ if (!('cap' in value) || value['cap'] === undefined)
27
+ return false;
28
+ if (!('examined' in value) || value['examined'] === undefined)
29
+ return false;
30
+ if (!('examined_in_scope' in value) || value['examined_in_scope'] === undefined)
31
+ return false;
32
+ if (!('total' in value) || value['total'] === undefined)
33
+ return false;
34
+ if (!('total_at_least' in value) || value['total_at_least'] === undefined)
35
+ return false;
36
+ if (!('order' in value) || value['order'] === undefined)
37
+ return false;
38
+ if (value['order'] !== 'index_order')
39
+ return false;
40
+ if (!('filed_from' in value) || value['filed_from'] === undefined)
41
+ return false;
42
+ if (!('filed_to' in value) || value['filed_to'] === undefined)
43
+ return false;
44
+ if (!('narrow_with' in value) || value['narrow_with'] === undefined)
45
+ return false;
46
+ return true;
47
+ }
48
+ export function SecSearchCoverageMatchesFromJSON(json) {
49
+ return SecSearchCoverageMatchesFromJSONTyped(json, false);
50
+ }
51
+ export function SecSearchCoverageMatchesFromJSONTyped(json, ignoreDiscriminator) {
52
+ if (json == null) {
53
+ return json;
54
+ }
55
+ return Object.assign(Object.assign({}, json), { 'capped': json['capped'], 'cap': json['cap'], 'examined': json['examined'], 'examined_in_scope': json['examined_in_scope'], 'total': json['total'], 'total_at_least': json['total_at_least'], 'order': json['order'], 'filed_from': (json['filed_from'] == null ? null : new Date(json['filed_from'])), 'filed_to': (json['filed_to'] == null ? null : new Date(json['filed_to'])), 'narrow_with': json['narrow_with'] });
56
+ }
57
+ export function SecSearchCoverageMatchesToJSON(json) {
58
+ return SecSearchCoverageMatchesToJSONTyped(json, false);
59
+ }
60
+ export function SecSearchCoverageMatchesToJSONTyped(value, ignoreDiscriminator = false) {
61
+ if (value == null) {
62
+ return value;
63
+ }
64
+ return Object.assign(Object.assign({}, value), { 'capped': value['capped'], 'cap': value['cap'], 'examined': value['examined'], 'examined_in_scope': value['examined_in_scope'], 'total': value['total'], 'total_at_least': value['total_at_least'], 'order': value['order'], 'filed_from': value['filed_from'] == null ? value['filed_from'] : value['filed_from'].toISOString().substring(0, 10), 'filed_to': value['filed_to'] == null ? value['filed_to'] : value['filed_to'].toISOString().substring(0, 10), 'narrow_with': value['narrow_with'] });
65
+ }
@@ -221,6 +221,7 @@ export * from './SecSearch200Response';
221
221
  export * from './SecSearch200ResponseHitsInner';
222
222
  export * from './SecSearchCoverage';
223
223
  export * from './SecSearchCoverageLexical';
224
+ export * from './SecSearchCoverageMatches';
224
225
  export * from './SecStoreError';
225
226
  export * from './SegmentedFinancials200Response';
226
227
  export * from './SegmentedFinancials200ResponseCompaniesInner';
@@ -223,6 +223,7 @@ export * from './SecSearch200Response';
223
223
  export * from './SecSearch200ResponseHitsInner';
224
224
  export * from './SecSearchCoverage';
225
225
  export * from './SecSearchCoverageLexical';
226
+ export * from './SecSearchCoverageMatches';
226
227
  export * from './SecStoreError';
227
228
  export * from './SegmentedFinancials200Response';
228
229
  export * from './SegmentedFinancials200ResponseCompaniesInner';
@@ -10,6 +10,7 @@
10
10
  * Do not edit the class manually.
11
11
  */
12
12
  import type { SecSearchCoverageLexical } from './SecSearchCoverageLexical';
13
+ import type { SecSearchCoverageMatches } from './SecSearchCoverageMatches';
13
14
  /**
14
15
  * How much of the searched SEC scope the text index covers (the earnings search vocabulary). `forms_indexed` / `years_indexed` / `indexed_since` state the index policy; documents of other forms are counted in `lexical.not_indexed_by_policy` (by design, not a gap). For exactly one `cik`, `held` / `mirror` say how much of the filer's history is held (`held_through`).
15
16
  * @export
@@ -30,7 +31,7 @@ export interface SecSearchCoverage {
30
31
  */
31
32
  lexical: SecSearchCoverageLexical | null;
32
33
  /**
33
- * Why the answer may be incomplete: not_projected, projection_failed, not_published, not_held, held_not_verified, candidate_cap_reached, scan_budget_reached, scope_needs_review, scope_not_current, form_not_indexed, older_than_index_window, no_forms_indexed, held_gap, search_provider_not_registered, search_projection_empty, search_timeout, scope_excluded, documents_not_held
34
+ * Why the answer may be incomplete: not_projected, projection_failed, not_published, not_held, held_not_verified, too_many_matches, candidate_cap_reached, scan_budget_reached, scope_needs_review, scope_not_current, form_not_indexed, older_than_index_window, no_forms_indexed, held_gap, search_provider_not_registered, search_projection_empty, search_timeout, scope_excluded, documents_not_held
34
35
  * @type {Array<string>}
35
36
  * @memberof SecSearchCoverage
36
37
  */
@@ -41,6 +42,18 @@ export interface SecSearchCoverage {
41
42
  * @memberof SecSearchCoverage
42
43
  */
43
44
  forms_indexed?: Array<string> | null;
45
+ /**
46
+ *
47
+ * @type {SecSearchCoverageMatches}
48
+ * @memberof SecSearchCoverage
49
+ */
50
+ matches?: SecSearchCoverageMatches | null;
51
+ /**
52
+ * What to do for a complete answer (set when `matches.capped`; null otherwise)
53
+ * @type {string}
54
+ * @memberof SecSearchCoverage
55
+ */
56
+ hint?: string | null;
44
57
  }
45
58
  /**
46
59
  * @export
@@ -20,6 +20,7 @@ exports.SecSearchCoverageFromJSONTyped = SecSearchCoverageFromJSONTyped;
20
20
  exports.SecSearchCoverageToJSON = SecSearchCoverageToJSON;
21
21
  exports.SecSearchCoverageToJSONTyped = SecSearchCoverageToJSONTyped;
22
22
  const SecSearchCoverageLexical_1 = require("./SecSearchCoverageLexical");
23
+ const SecSearchCoverageMatches_1 = require("./SecSearchCoverageMatches");
23
24
  /**
24
25
  * @export
25
26
  */
@@ -47,7 +48,7 @@ function SecSearchCoverageFromJSONTyped(json, ignoreDiscriminator) {
47
48
  if (json == null) {
48
49
  return json;
49
50
  }
50
- return Object.assign(Object.assign({}, json), { 'completeness': json['completeness'], 'lexical': (0, SecSearchCoverageLexical_1.SecSearchCoverageLexicalFromJSON)(json['lexical']), 'reasons': json['reasons'], 'forms_indexed': json['forms_indexed'] == null ? undefined : json['forms_indexed'] });
51
+ return Object.assign(Object.assign({}, json), { 'completeness': json['completeness'], 'lexical': (0, SecSearchCoverageLexical_1.SecSearchCoverageLexicalFromJSON)(json['lexical']), 'reasons': json['reasons'], 'forms_indexed': json['forms_indexed'] == null ? undefined : json['forms_indexed'], 'matches': json['matches'] == null ? undefined : (0, SecSearchCoverageMatches_1.SecSearchCoverageMatchesFromJSON)(json['matches']), 'hint': json['hint'] == null ? undefined : json['hint'] });
51
52
  }
52
53
  function SecSearchCoverageToJSON(json) {
53
54
  return SecSearchCoverageToJSONTyped(json, false);
@@ -56,5 +57,5 @@ function SecSearchCoverageToJSONTyped(value, ignoreDiscriminator = false) {
56
57
  if (value == null) {
57
58
  return value;
58
59
  }
59
- return Object.assign(Object.assign({}, value), { 'completeness': value['completeness'], 'lexical': (0, SecSearchCoverageLexical_1.SecSearchCoverageLexicalToJSON)(value['lexical']), 'reasons': value['reasons'], 'forms_indexed': value['forms_indexed'] });
60
+ return Object.assign(Object.assign({}, value), { 'completeness': value['completeness'], 'lexical': (0, SecSearchCoverageLexical_1.SecSearchCoverageLexicalToJSON)(value['lexical']), 'reasons': value['reasons'], 'forms_indexed': value['forms_indexed'], 'matches': (0, SecSearchCoverageMatches_1.SecSearchCoverageMatchesToJSON)(value['matches']), 'hint': value['hint'] });
60
61
  }
@@ -0,0 +1,94 @@
1
+ /**
2
+ * Invinite API
3
+ * Invinite financial data API. Each endpoint has a base credit cost: `x-credits` is the base cost; responses add 1 credit per started 1,000 rows beyond the first 1,000; `X-Credits-Charged` reports the final debit and `X-Credits-Included-Remaining` what is left of the plan\'s included credits. `GET /v1/account/usage` returns your account\'s usage by day, endpoint family and key (it costs no credits). SEC filing search has a 100-credit base cost. **Coverage.** Financial data covers SEC registrants and US listings; a foreign suffix (`SAP.DE`, `VOD.L`) or a crypto pair (`X:BTCUSD`) is not a known company and answers 404. A known company with no data in a family (for example no statements yet) answers 404 with `code: not_covered`; an empty page of a covered company stays 200 with an empty list. `GET /v1/company/available-companies` lists every known company. ## Webhooks Accounts on LITE and above subscribe with `POST /v1/earnings-calls/webhooks` to the `earnings_call.*` lifecycle events (filtered by CIK) and, on STANDARD and above, to `news.published` (one delivery per new news item, filtered by the CIKs it mentions); see `x-webhooks` for each `data` object. What a subscription may hold depends on the plan (a create / update beyond it is refused with the plan\'s limit; `ping` needs no subscription — the test route and the disabled notice send it to any subscription): | Plan | Webhooks | Events | CIKs per webhook | Keywords per webhook | |---|---|---|---|---| | FREE | 0 | — | — | — | | LITE | 5 | `.scheduled`, `.rescheduled`, `.started`, `.ended`, `.transcript_ready`, `.assets_ready` | ≤ 10 | — | | STANDARD | 15 | LITE + `.transcript_provisional`, `.transcript_corrected`, `.documents_updated`, `news.published` | ≤ 25 | — | | PRO / ENTERPRISE | 50 | STANDARD + `.guidance_flash`, `.keyword_hit` | ≤ 100 | ≤ 20 (on ≤ 10 webhooks) | Every delivery is a `POST` with `Content-Type: application/json`, `X-Invinite-Event`, `X-Invinite-Delivery` and `X-Invinite-Signature: t=<unix seconds>,v1=<hex>` where `v1` = HMAC-SHA256(secret, `<t>.<raw body>`); during a secret rotation the header carries one `v1` per valid secret. Reject a signature older than 5 minutes. Any 2xx within 10 s acknowledges; redirects are not followed. A failed delivery is retried after 1 min, 5 min, 30 min, 2 h, 6 h, 12 h, 24 h (8 attempts in all, the same delivery id each time). A subscription is disabled after 8 consecutive dead-lettered deliveries (a final `ping` with `notice: subscription_disabled` is sent). Deliveries are at-least-once and unordered: dedupe on the delivery id, order by `created_at`. ## Licensing | Tier | display | redistribute | rag | train | audio | resell | | --- | --- | --- | --- | --- | --- | --- | | FREE | ✓ | – | – | – | – | – | | LITE | ✓ | – | – | – | – | – | | STANDARD | ✓ | – | ✓ | – | – | – | | PRO | ✓ | ✓ | ✓ | – | ✓ | – | Invinite data may be shown and, from PRO, redistributed inside the licensee\'s own product with attribution (\"Source: Invinite\" on screen or in the API response that carries it). It may never be resold, relicensed, white-labelled or offered as a data feed as the licensee\'s own data, at any tier, under any contract. Policy version: 2026-10-draft. Draft — pending counsel sign-off. Audio files carry a forensic watermark that identifies the recording. Audio is subject to per-company takedown and may not be re-hosted. SEC data: Figures and filings originate from SEC EDGAR; the standardisation, mapping and derived metrics are Invinite\'s. News: Issuer and SEC text is served in full with its attribution; the licensee shows publisher, source URL and date next to it and may forward it unmodified; the resale rule applies. PDF documents: Branded PDFs of transcripts and news items are permanent URLs to one shared file per version. They may be shown, downloaded and forwarded unmodified with the notice page intact; the resale rule applies unchanged. News PDFs reproduce issuer or SEC text under the attribution stated on their notice page; a PDF disappears when the item is taken down or its source\'s reuse is denied. Every `/v1/_*` data operation carries `x-license`, the minimum use right its data ships with; `GET /status/licensing` serves the same matrix per route, rendered at [data.invinite.com/docs/licensing](https://data.invinite.com/docs/licensing). `/v1/account/usage` serves no licensed data and carries none. ## Status [`/status`](/status) reports whether each product family works (a status and its uptime over 7, 30 and 90 days); [`/status/licensing`](/status/licensing) serves the licensing matrix per route. The status routes need no API key and are cached for 5 minutes. The public status page is [status.data.invinite.com](https://status.data.invinite.com): a snapshot of `/status` every 15 minutes plus an external reachability probe of the API. Uptime is the share of requests answered without a server error, measured by the API per product family; a window with too little traffic to judge shows no figure. Status reflects the last 24 hours. Product families: Company, Financials, SEC Filings, Insider Trades, Institutional Ownership, IPOs, Market, Metadata, Earnings Calls, News, WebSocket, Account.
4
+ *
5
+ * The version of the OpenAPI document: 1.0.0
6
+ *
7
+ *
8
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
9
+ * https://openapi-generator.tech
10
+ * Do not edit the class manually.
11
+ */
12
+ /**
13
+ * The selectivity cap of a search WITHOUT any filter (null for a filtered search, which is never capped): at most `cap` matching passages are read from the index, in index order (not ranked, not newest-first), then ranked and cited
14
+ * @export
15
+ * @interface SecSearchCoverageMatches
16
+ */
17
+ export interface SecSearchCoverageMatches {
18
+ [key: string]: any | any;
19
+ /**
20
+ * true = more passages match than were examined: the answer is partial (`too_many_matches`)
21
+ * @type {boolean}
22
+ * @memberof SecSearchCoverageMatches
23
+ */
24
+ capped: boolean;
25
+ /**
26
+ * The most matching passages an unfiltered search reads
27
+ * @type {number}
28
+ * @memberof SecSearchCoverageMatches
29
+ */
30
+ cap: number;
31
+ /**
32
+ * Matching passages read from the index (at most `cap`)
33
+ * @type {number}
34
+ * @memberof SecSearchCoverageMatches
35
+ */
36
+ examined: number;
37
+ /**
38
+ * Of them, passages in searchable documents: the set the hits are ranked from
39
+ * @type {number}
40
+ * @memberof SecSearchCoverageMatches
41
+ */
42
+ examined_in_scope: number;
43
+ /**
44
+ * Every matching passage when not capped; null when capped (the total is unknown)
45
+ * @type {number}
46
+ * @memberof SecSearchCoverageMatches
47
+ */
48
+ total: number | null;
49
+ /**
50
+ * When capped: the total is at least this (cap + 1); never an estimate. null when not capped
51
+ * @type {number}
52
+ * @memberof SecSearchCoverageMatches
53
+ */
54
+ total_at_least: number | null;
55
+ /**
56
+ * Which passages were examined: the first ones the index returned (not newest-first)
57
+ * @type {SecSearchCoverageMatchesOrderEnum}
58
+ * @memberof SecSearchCoverageMatches
59
+ */
60
+ order: SecSearchCoverageMatchesOrderEnum;
61
+ /**
62
+ * Earliest filing date among the examined passages in searchable documents
63
+ * @type {Date}
64
+ * @memberof SecSearchCoverageMatches
65
+ */
66
+ filed_from: Date | null;
67
+ /**
68
+ * Latest filing date among the examined passages in searchable documents
69
+ * @type {Date}
70
+ * @memberof SecSearchCoverageMatches
71
+ */
72
+ filed_to: Date | null;
73
+ /**
74
+ * What makes the search complete: filer (`cik`), entity (`entity_id`), form (`form`), filed_from / filed_to (`filed_from` / `filed_to`), accession (`accession`)
75
+ * @type {Array<string>}
76
+ * @memberof SecSearchCoverageMatches
77
+ */
78
+ narrow_with: Array<string>;
79
+ }
80
+ /**
81
+ * @export
82
+ */
83
+ export declare const SecSearchCoverageMatchesOrderEnum: {
84
+ readonly IndexOrder: "index_order";
85
+ };
86
+ export type SecSearchCoverageMatchesOrderEnum = typeof SecSearchCoverageMatchesOrderEnum[keyof typeof SecSearchCoverageMatchesOrderEnum];
87
+ /**
88
+ * Check if a given object implements the SecSearchCoverageMatches interface.
89
+ */
90
+ export declare function instanceOfSecSearchCoverageMatches(value: object): value is SecSearchCoverageMatches;
91
+ export declare function SecSearchCoverageMatchesFromJSON(json: any): SecSearchCoverageMatches;
92
+ export declare function SecSearchCoverageMatchesFromJSONTyped(json: any, ignoreDiscriminator: boolean): SecSearchCoverageMatches;
93
+ export declare function SecSearchCoverageMatchesToJSON(json: any): SecSearchCoverageMatches;
94
+ export declare function SecSearchCoverageMatchesToJSONTyped(value?: SecSearchCoverageMatches | null, ignoreDiscriminator?: boolean): any;
@@ -0,0 +1,73 @@
1
+ "use strict";
2
+ /* tslint:disable */
3
+ /* eslint-disable */
4
+ /**
5
+ * Invinite API
6
+ * Invinite financial data API. Each endpoint has a base credit cost: `x-credits` is the base cost; responses add 1 credit per started 1,000 rows beyond the first 1,000; `X-Credits-Charged` reports the final debit and `X-Credits-Included-Remaining` what is left of the plan\'s included credits. `GET /v1/account/usage` returns your account\'s usage by day, endpoint family and key (it costs no credits). SEC filing search has a 100-credit base cost. **Coverage.** Financial data covers SEC registrants and US listings; a foreign suffix (`SAP.DE`, `VOD.L`) or a crypto pair (`X:BTCUSD`) is not a known company and answers 404. A known company with no data in a family (for example no statements yet) answers 404 with `code: not_covered`; an empty page of a covered company stays 200 with an empty list. `GET /v1/company/available-companies` lists every known company. ## Webhooks Accounts on LITE and above subscribe with `POST /v1/earnings-calls/webhooks` to the `earnings_call.*` lifecycle events (filtered by CIK) and, on STANDARD and above, to `news.published` (one delivery per new news item, filtered by the CIKs it mentions); see `x-webhooks` for each `data` object. What a subscription may hold depends on the plan (a create / update beyond it is refused with the plan\'s limit; `ping` needs no subscription — the test route and the disabled notice send it to any subscription): | Plan | Webhooks | Events | CIKs per webhook | Keywords per webhook | |---|---|---|---|---| | FREE | 0 | — | — | — | | LITE | 5 | `.scheduled`, `.rescheduled`, `.started`, `.ended`, `.transcript_ready`, `.assets_ready` | ≤ 10 | — | | STANDARD | 15 | LITE + `.transcript_provisional`, `.transcript_corrected`, `.documents_updated`, `news.published` | ≤ 25 | — | | PRO / ENTERPRISE | 50 | STANDARD + `.guidance_flash`, `.keyword_hit` | ≤ 100 | ≤ 20 (on ≤ 10 webhooks) | Every delivery is a `POST` with `Content-Type: application/json`, `X-Invinite-Event`, `X-Invinite-Delivery` and `X-Invinite-Signature: t=<unix seconds>,v1=<hex>` where `v1` = HMAC-SHA256(secret, `<t>.<raw body>`); during a secret rotation the header carries one `v1` per valid secret. Reject a signature older than 5 minutes. Any 2xx within 10 s acknowledges; redirects are not followed. A failed delivery is retried after 1 min, 5 min, 30 min, 2 h, 6 h, 12 h, 24 h (8 attempts in all, the same delivery id each time). A subscription is disabled after 8 consecutive dead-lettered deliveries (a final `ping` with `notice: subscription_disabled` is sent). Deliveries are at-least-once and unordered: dedupe on the delivery id, order by `created_at`. ## Licensing | Tier | display | redistribute | rag | train | audio | resell | | --- | --- | --- | --- | --- | --- | --- | | FREE | ✓ | – | – | – | – | – | | LITE | ✓ | – | – | – | – | – | | STANDARD | ✓ | – | ✓ | – | – | – | | PRO | ✓ | ✓ | ✓ | – | ✓ | – | Invinite data may be shown and, from PRO, redistributed inside the licensee\'s own product with attribution (\"Source: Invinite\" on screen or in the API response that carries it). It may never be resold, relicensed, white-labelled or offered as a data feed as the licensee\'s own data, at any tier, under any contract. Policy version: 2026-10-draft. Draft — pending counsel sign-off. Audio files carry a forensic watermark that identifies the recording. Audio is subject to per-company takedown and may not be re-hosted. SEC data: Figures and filings originate from SEC EDGAR; the standardisation, mapping and derived metrics are Invinite\'s. News: Issuer and SEC text is served in full with its attribution; the licensee shows publisher, source URL and date next to it and may forward it unmodified; the resale rule applies. PDF documents: Branded PDFs of transcripts and news items are permanent URLs to one shared file per version. They may be shown, downloaded and forwarded unmodified with the notice page intact; the resale rule applies unchanged. News PDFs reproduce issuer or SEC text under the attribution stated on their notice page; a PDF disappears when the item is taken down or its source\'s reuse is denied. Every `/v1/_*` data operation carries `x-license`, the minimum use right its data ships with; `GET /status/licensing` serves the same matrix per route, rendered at [data.invinite.com/docs/licensing](https://data.invinite.com/docs/licensing). `/v1/account/usage` serves no licensed data and carries none. ## Status [`/status`](/status) reports whether each product family works (a status and its uptime over 7, 30 and 90 days); [`/status/licensing`](/status/licensing) serves the licensing matrix per route. The status routes need no API key and are cached for 5 minutes. The public status page is [status.data.invinite.com](https://status.data.invinite.com): a snapshot of `/status` every 15 minutes plus an external reachability probe of the API. Uptime is the share of requests answered without a server error, measured by the API per product family; a window with too little traffic to judge shows no figure. Status reflects the last 24 hours. Product families: Company, Financials, SEC Filings, Insider Trades, Institutional Ownership, IPOs, Market, Metadata, Earnings Calls, News, WebSocket, Account.
7
+ *
8
+ * The version of the OpenAPI document: 1.0.0
9
+ *
10
+ *
11
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
12
+ * https://openapi-generator.tech
13
+ * Do not edit the class manually.
14
+ */
15
+ Object.defineProperty(exports, "__esModule", { value: true });
16
+ exports.SecSearchCoverageMatchesOrderEnum = void 0;
17
+ exports.instanceOfSecSearchCoverageMatches = instanceOfSecSearchCoverageMatches;
18
+ exports.SecSearchCoverageMatchesFromJSON = SecSearchCoverageMatchesFromJSON;
19
+ exports.SecSearchCoverageMatchesFromJSONTyped = SecSearchCoverageMatchesFromJSONTyped;
20
+ exports.SecSearchCoverageMatchesToJSON = SecSearchCoverageMatchesToJSON;
21
+ exports.SecSearchCoverageMatchesToJSONTyped = SecSearchCoverageMatchesToJSONTyped;
22
+ /**
23
+ * @export
24
+ */
25
+ exports.SecSearchCoverageMatchesOrderEnum = {
26
+ IndexOrder: 'index_order'
27
+ };
28
+ /**
29
+ * Check if a given object implements the SecSearchCoverageMatches interface.
30
+ */
31
+ function instanceOfSecSearchCoverageMatches(value) {
32
+ if (!('capped' in value) || value['capped'] === undefined)
33
+ return false;
34
+ if (!('cap' in value) || value['cap'] === undefined)
35
+ return false;
36
+ if (!('examined' in value) || value['examined'] === undefined)
37
+ return false;
38
+ if (!('examined_in_scope' in value) || value['examined_in_scope'] === undefined)
39
+ return false;
40
+ if (!('total' in value) || value['total'] === undefined)
41
+ return false;
42
+ if (!('total_at_least' in value) || value['total_at_least'] === undefined)
43
+ return false;
44
+ if (!('order' in value) || value['order'] === undefined)
45
+ return false;
46
+ if (value['order'] !== 'index_order')
47
+ return false;
48
+ if (!('filed_from' in value) || value['filed_from'] === undefined)
49
+ return false;
50
+ if (!('filed_to' in value) || value['filed_to'] === undefined)
51
+ return false;
52
+ if (!('narrow_with' in value) || value['narrow_with'] === undefined)
53
+ return false;
54
+ return true;
55
+ }
56
+ function SecSearchCoverageMatchesFromJSON(json) {
57
+ return SecSearchCoverageMatchesFromJSONTyped(json, false);
58
+ }
59
+ function SecSearchCoverageMatchesFromJSONTyped(json, ignoreDiscriminator) {
60
+ if (json == null) {
61
+ return json;
62
+ }
63
+ return Object.assign(Object.assign({}, json), { 'capped': json['capped'], 'cap': json['cap'], 'examined': json['examined'], 'examined_in_scope': json['examined_in_scope'], 'total': json['total'], 'total_at_least': json['total_at_least'], 'order': json['order'], 'filed_from': (json['filed_from'] == null ? null : new Date(json['filed_from'])), 'filed_to': (json['filed_to'] == null ? null : new Date(json['filed_to'])), 'narrow_with': json['narrow_with'] });
64
+ }
65
+ function SecSearchCoverageMatchesToJSON(json) {
66
+ return SecSearchCoverageMatchesToJSONTyped(json, false);
67
+ }
68
+ function SecSearchCoverageMatchesToJSONTyped(value, ignoreDiscriminator = false) {
69
+ if (value == null) {
70
+ return value;
71
+ }
72
+ return Object.assign(Object.assign({}, value), { 'capped': value['capped'], 'cap': value['cap'], 'examined': value['examined'], 'examined_in_scope': value['examined_in_scope'], 'total': value['total'], 'total_at_least': value['total_at_least'], 'order': value['order'], 'filed_from': value['filed_from'] == null ? value['filed_from'] : value['filed_from'].toISOString().substring(0, 10), 'filed_to': value['filed_to'] == null ? value['filed_to'] : value['filed_to'].toISOString().substring(0, 10), 'narrow_with': value['narrow_with'] });
73
+ }
@@ -221,6 +221,7 @@ export * from './SecSearch200Response';
221
221
  export * from './SecSearch200ResponseHitsInner';
222
222
  export * from './SecSearchCoverage';
223
223
  export * from './SecSearchCoverageLexical';
224
+ export * from './SecSearchCoverageMatches';
224
225
  export * from './SecStoreError';
225
226
  export * from './SegmentedFinancials200Response';
226
227
  export * from './SegmentedFinancials200ResponseCompaniesInner';
@@ -239,6 +239,7 @@ __exportStar(require("./SecSearch200Response"), exports);
239
239
  __exportStar(require("./SecSearch200ResponseHitsInner"), exports);
240
240
  __exportStar(require("./SecSearchCoverage"), exports);
241
241
  __exportStar(require("./SecSearchCoverageLexical"), exports);
242
+ __exportStar(require("./SecSearchCoverageMatches"), exports);
242
243
  __exportStar(require("./SecStoreError"), exports);
243
244
  __exportStar(require("./SegmentedFinancials200Response"), exports);
244
245
  __exportStar(require("./SegmentedFinancials200ResponseCompaniesInner"), exports);
package/docs/SECApi.md CHANGED
@@ -2526,7 +2526,7 @@ example().catch(console.error);
2526
2526
 
2527
2527
  Search SEC documents
2528
2528
 
2529
- Find passages in SEC documents, with citations: &#x60;mode&#x3D;lexical&#x60; (default; keywords and quoted phrases, English stemming, ranked) or &#x60;mode&#x3D;literal&#x60; (the exact characters; &#x60;case_sensitive&#x3D;false&#x60; folds case). The earnings search contract: every hit carries &#x60;match&#x60; (&#x60;type&#x60;, &#x60;lexical_rank&#x60;, &#x60;spans&#x60; &#x3D; code-point offsets into &#x60;text&#x60;), &#x60;document_spans&#x60; (offsets into the document text and each block), the cited blocks with neighbors and footnotes, and &#x60;citation&#x60; (version, block, the original\&#39;s permanent URL). &#x60;coverage&#x60; says how complete the answer is: &#x60;forms_indexed&#x60; / &#x60;years_indexed&#x60; state the index policy; empty hits with &#x60;completeness: complete&#x60; is a genuine no-result, anything else is not. A stale or expired cursor answers 409 &#x60;restart_required&#x60;. Read from Invinite\&#39;s SEC document store: every answer carries &#x60;readiness&#x60; (&#x60;ready&#x60; / &#x60;partial&#x60; 200, &#x60;pending&#x60; 202 — retry later, not billed — &#x60;excluded&#x60; 403, &#x60;unknown&#x60; 404, &#x60;failed&#x60; 424, &#x60;not_ready&#x60; 503 while the capability is switched off). Originals, figures and PDFs are permanent public URLs; nothing is fetched from SEC on request. Minimum tier for rag: STANDARD.
2529
+ Find passages in SEC documents, with citations: &#x60;mode&#x3D;lexical&#x60; (default; keywords and quoted phrases, English stemming, ranked) or &#x60;mode&#x3D;literal&#x60; (the exact characters; &#x60;case_sensitive&#x3D;false&#x60; folds case). The earnings search contract: every hit carries &#x60;match&#x60; (&#x60;type&#x60;, &#x60;lexical_rank&#x60;, &#x60;spans&#x60; &#x3D; code-point offsets into &#x60;text&#x60;), &#x60;document_spans&#x60; (offsets into the document text and each block), the cited blocks with neighbors and footnotes, and &#x60;citation&#x60; (version, block, the original\&#39;s permanent URL). &#x60;coverage&#x60; says how complete the answer is: &#x60;forms_indexed&#x60; / &#x60;years_indexed&#x60; state the index policy; empty hits with &#x60;completeness: complete&#x60; is a genuine no-result, anything else is not. A search WITHOUT any filter (no &#x60;cik&#x60; / &#x60;entity_id&#x60; / &#x60;accession&#x60; / &#x60;form&#x60; / date) reads at most &#x60;coverage.matches.cap&#x60; matching passages (index order, not newest-first): when more match, &#x60;readiness&#x60; is &#x60;partial&#x60; / &#x60;too_many_matches&#x60;, &#x60;coverage.matches&#x60; states how many passages were examined, that the total is unknown (&#x60;total: null&#x60;, &#x60;total_at_least&#x60;) and the filing dates the examined passages span, and &#x60;coverage.hint&#x60; says how to get complete results (narrow by filer, form or filing-date range); the hits returned are still ranked and cited. A filtered search is never capped. A capped search costs the same 100 credits (hits are returned). A stale or expired cursor answers 409 &#x60;restart_required&#x60;. Read from Invinite\&#39;s SEC document store: every answer carries &#x60;readiness&#x60; (&#x60;ready&#x60; / &#x60;partial&#x60; 200, &#x60;pending&#x60; 202 — retry later, not billed — &#x60;excluded&#x60; 403, &#x60;unknown&#x60; 404, &#x60;failed&#x60; 424, &#x60;not_ready&#x60; 503 while the capability is switched off). Originals, figures and PDFs are permanent public URLs; nothing is fetched from SEC on request. Minimum tier for rag: STANDARD.
2530
2530
 
2531
2531
  ### Example
2532
2532
 
@@ -11,6 +11,8 @@ Name | Type
11
11
  `lexical` | [SecSearchCoverageLexical](SecSearchCoverageLexical.md)
12
12
  `reasons` | Array&lt;string&gt;
13
13
  `forms_indexed` | Array&lt;string&gt;
14
+ `matches` | [SecSearchCoverageMatches](SecSearchCoverageMatches.md)
15
+ `hint` | string
14
16
 
15
17
  ## Example
16
18
 
@@ -23,6 +25,8 @@ const example = {
23
25
  "lexical": null,
24
26
  "reasons": null,
25
27
  "forms_indexed": null,
28
+ "matches": null,
29
+ "hint": null,
26
30
  } satisfies SecSearchCoverage
27
31
 
28
32
  console.log(example)
@@ -0,0 +1,53 @@
1
+
2
+ # SecSearchCoverageMatches
3
+
4
+ The selectivity cap of a search WITHOUT any filter (null for a filtered search, which is never capped): at most `cap` matching passages are read from the index, in index order (not ranked, not newest-first), then ranked and cited
5
+
6
+ ## Properties
7
+
8
+ Name | Type
9
+ ------------ | -------------
10
+ `capped` | boolean
11
+ `cap` | number
12
+ `examined` | number
13
+ `examined_in_scope` | number
14
+ `total` | number
15
+ `total_at_least` | number
16
+ `order` | string
17
+ `filed_from` | Date
18
+ `filed_to` | Date
19
+ `narrow_with` | Array&lt;string&gt;
20
+
21
+ ## Example
22
+
23
+ ```typescript
24
+ import type { SecSearchCoverageMatches } from '@invinite-org/data-api-client'
25
+
26
+ // TODO: Update the object below with actual values
27
+ const example = {
28
+ "capped": null,
29
+ "cap": null,
30
+ "examined": null,
31
+ "examined_in_scope": null,
32
+ "total": null,
33
+ "total_at_least": null,
34
+ "order": null,
35
+ "filed_from": null,
36
+ "filed_to": null,
37
+ "narrow_with": null,
38
+ } satisfies SecSearchCoverageMatches
39
+
40
+ console.log(example)
41
+
42
+ // Convert the instance to a JSON string
43
+ const exampleJSON: string = JSON.stringify(example)
44
+ console.log(exampleJSON)
45
+
46
+ // Parse the JSON string back to an object
47
+ const exampleParsed = JSON.parse(exampleJSON) as SecSearchCoverageMatches
48
+ console.log(exampleParsed)
49
+ ```
50
+
51
+ [[Back to top]](#) [[Back to API list]](../README.md#api-endpoints) [[Back to Model list]](../README.md#models) [[Back to README]](../README.md)
52
+
53
+
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@invinite-org/data-api-client",
3
- "version": "1.0.0",
3
+ "version": "1.1.0",
4
4
  "description": "Typed TypeScript/JavaScript client for the Invinite Data API",
5
5
  "author": "OpenAPI-Generator",
6
6
  "repository": {
@@ -2364,7 +2364,7 @@ export class SECApi extends runtime.BaseAPI {
2364
2364
  }
2365
2365
 
2366
2366
  /**
2367
- * Find passages in SEC documents, with citations: `mode=lexical` (default; keywords and quoted phrases, English stemming, ranked) or `mode=literal` (the exact characters; `case_sensitive=false` folds case). The earnings search contract: every hit carries `match` (`type`, `lexical_rank`, `spans` = code-point offsets into `text`), `document_spans` (offsets into the document text and each block), the cited blocks with neighbors and footnotes, and `citation` (version, block, the original\'s permanent URL). `coverage` says how complete the answer is: `forms_indexed` / `years_indexed` state the index policy; empty hits with `completeness: complete` is a genuine no-result, anything else is not. A stale or expired cursor answers 409 `restart_required`. Read from Invinite\'s SEC document store: every answer carries `readiness` (`ready` / `partial` 200, `pending` 202 — retry later, not billed — `excluded` 403, `unknown` 404, `failed` 424, `not_ready` 503 while the capability is switched off). Originals, figures and PDFs are permanent public URLs; nothing is fetched from SEC on request. Minimum tier for rag: STANDARD.
2367
+ * Find passages in SEC documents, with citations: `mode=lexical` (default; keywords and quoted phrases, English stemming, ranked) or `mode=literal` (the exact characters; `case_sensitive=false` folds case). The earnings search contract: every hit carries `match` (`type`, `lexical_rank`, `spans` = code-point offsets into `text`), `document_spans` (offsets into the document text and each block), the cited blocks with neighbors and footnotes, and `citation` (version, block, the original\'s permanent URL). `coverage` says how complete the answer is: `forms_indexed` / `years_indexed` state the index policy; empty hits with `completeness: complete` is a genuine no-result, anything else is not. A search WITHOUT any filter (no `cik` / `entity_id` / `accession` / `form` / date) reads at most `coverage.matches.cap` matching passages (index order, not newest-first): when more match, `readiness` is `partial` / `too_many_matches`, `coverage.matches` states how many passages were examined, that the total is unknown (`total: null`, `total_at_least`) and the filing dates the examined passages span, and `coverage.hint` says how to get complete results (narrow by filer, form or filing-date range); the hits returned are still ranked and cited. A filtered search is never capped. A capped search costs the same 100 credits (hits are returned). A stale or expired cursor answers 409 `restart_required`. Read from Invinite\'s SEC document store: every answer carries `readiness` (`ready` / `partial` 200, `pending` 202 — retry later, not billed — `excluded` 403, `unknown` 404, `failed` 424, `not_ready` 503 while the capability is switched off). Originals, figures and PDFs are permanent public URLs; nothing is fetched from SEC on request. Minimum tier for rag: STANDARD.
2368
2368
  * Search SEC documents
2369
2369
  */
2370
2370
  async secSearchRaw(requestParameters: SecSearchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SecSearch200Response>> {
@@ -2375,7 +2375,7 @@ export class SECApi extends runtime.BaseAPI {
2375
2375
  }
2376
2376
 
2377
2377
  /**
2378
- * Find passages in SEC documents, with citations: `mode=lexical` (default; keywords and quoted phrases, English stemming, ranked) or `mode=literal` (the exact characters; `case_sensitive=false` folds case). The earnings search contract: every hit carries `match` (`type`, `lexical_rank`, `spans` = code-point offsets into `text`), `document_spans` (offsets into the document text and each block), the cited blocks with neighbors and footnotes, and `citation` (version, block, the original\'s permanent URL). `coverage` says how complete the answer is: `forms_indexed` / `years_indexed` state the index policy; empty hits with `completeness: complete` is a genuine no-result, anything else is not. A stale or expired cursor answers 409 `restart_required`. Read from Invinite\'s SEC document store: every answer carries `readiness` (`ready` / `partial` 200, `pending` 202 — retry later, not billed — `excluded` 403, `unknown` 404, `failed` 424, `not_ready` 503 while the capability is switched off). Originals, figures and PDFs are permanent public URLs; nothing is fetched from SEC on request. Minimum tier for rag: STANDARD.
2378
+ * Find passages in SEC documents, with citations: `mode=lexical` (default; keywords and quoted phrases, English stemming, ranked) or `mode=literal` (the exact characters; `case_sensitive=false` folds case). The earnings search contract: every hit carries `match` (`type`, `lexical_rank`, `spans` = code-point offsets into `text`), `document_spans` (offsets into the document text and each block), the cited blocks with neighbors and footnotes, and `citation` (version, block, the original\'s permanent URL). `coverage` says how complete the answer is: `forms_indexed` / `years_indexed` state the index policy; empty hits with `completeness: complete` is a genuine no-result, anything else is not. A search WITHOUT any filter (no `cik` / `entity_id` / `accession` / `form` / date) reads at most `coverage.matches.cap` matching passages (index order, not newest-first): when more match, `readiness` is `partial` / `too_many_matches`, `coverage.matches` states how many passages were examined, that the total is unknown (`total: null`, `total_at_least`) and the filing dates the examined passages span, and `coverage.hint` says how to get complete results (narrow by filer, form or filing-date range); the hits returned are still ranked and cited. A filtered search is never capped. A capped search costs the same 100 credits (hits are returned). A stale or expired cursor answers 409 `restart_required`. Read from Invinite\'s SEC document store: every answer carries `readiness` (`ready` / `partial` 200, `pending` 202 — retry later, not billed — `excluded` 403, `unknown` 404, `failed` 424, `not_ready` 503 while the capability is switched off). Originals, figures and PDFs are permanent public URLs; nothing is fetched from SEC on request. Minimum tier for rag: STANDARD.
2379
2379
  * Search SEC documents
2380
2380
  */
2381
2381
  async secSearch(requestParameters: SecSearchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SecSearch200Response> {
@@ -20,6 +20,13 @@ import {
20
20
  SecSearchCoverageLexicalToJSON,
21
21
  SecSearchCoverageLexicalToJSONTyped,
22
22
  } from './SecSearchCoverageLexical';
23
+ import type { SecSearchCoverageMatches } from './SecSearchCoverageMatches';
24
+ import {
25
+ SecSearchCoverageMatchesFromJSON,
26
+ SecSearchCoverageMatchesFromJSONTyped,
27
+ SecSearchCoverageMatchesToJSON,
28
+ SecSearchCoverageMatchesToJSONTyped,
29
+ } from './SecSearchCoverageMatches';
23
30
 
24
31
  /**
25
32
  * How much of the searched SEC scope the text index covers (the earnings search vocabulary). `forms_indexed` / `years_indexed` / `indexed_since` state the index policy; documents of other forms are counted in `lexical.not_indexed_by_policy` (by design, not a gap). For exactly one `cik`, `held` / `mirror` say how much of the filer's history is held (`held_through`).
@@ -41,7 +48,7 @@ export interface SecSearchCoverage {
41
48
  */
42
49
  lexical: SecSearchCoverageLexical | null;
43
50
  /**
44
- * Why the answer may be incomplete: not_projected, projection_failed, not_published, not_held, held_not_verified, candidate_cap_reached, scan_budget_reached, scope_needs_review, scope_not_current, form_not_indexed, older_than_index_window, no_forms_indexed, held_gap, search_provider_not_registered, search_projection_empty, search_timeout, scope_excluded, documents_not_held
51
+ * Why the answer may be incomplete: not_projected, projection_failed, not_published, not_held, held_not_verified, too_many_matches, candidate_cap_reached, scan_budget_reached, scope_needs_review, scope_not_current, form_not_indexed, older_than_index_window, no_forms_indexed, held_gap, search_provider_not_registered, search_projection_empty, search_timeout, scope_excluded, documents_not_held
45
52
  * @type {Array<string>}
46
53
  * @memberof SecSearchCoverage
47
54
  */
@@ -52,6 +59,18 @@ export interface SecSearchCoverage {
52
59
  * @memberof SecSearchCoverage
53
60
  */
54
61
  forms_indexed?: Array<string> | null;
62
+ /**
63
+ *
64
+ * @type {SecSearchCoverageMatches}
65
+ * @memberof SecSearchCoverage
66
+ */
67
+ matches?: SecSearchCoverageMatches | null;
68
+ /**
69
+ * What to do for a complete answer (set when `matches.capped`; null otherwise)
70
+ * @type {string}
71
+ * @memberof SecSearchCoverage
72
+ */
73
+ hint?: string | null;
55
74
  }
56
75
 
57
76
 
@@ -91,6 +110,8 @@ export function SecSearchCoverageFromJSONTyped(json: any, ignoreDiscriminator: b
91
110
  'lexical': SecSearchCoverageLexicalFromJSON(json['lexical']),
92
111
  'reasons': json['reasons'],
93
112
  'forms_indexed': json['forms_indexed'] == null ? undefined : json['forms_indexed'],
113
+ 'matches': json['matches'] == null ? undefined : SecSearchCoverageMatchesFromJSON(json['matches']),
114
+ 'hint': json['hint'] == null ? undefined : json['hint'],
94
115
  };
95
116
  }
96
117
 
@@ -110,6 +131,8 @@ export function SecSearchCoverageToJSONTyped(value?: SecSearchCoverage | null, i
110
131
  'lexical': SecSearchCoverageLexicalToJSON(value['lexical']),
111
132
  'reasons': value['reasons'],
112
133
  'forms_indexed': value['forms_indexed'],
134
+ 'matches': SecSearchCoverageMatchesToJSON(value['matches']),
135
+ 'hint': value['hint'],
113
136
  };
114
137
  }
115
138
 
@@ -0,0 +1,162 @@
1
+ /* tslint:disable */
2
+ /* eslint-disable */
3
+ /**
4
+ * Invinite API
5
+ * Invinite financial data API. Each endpoint has a base credit cost: `x-credits` is the base cost; responses add 1 credit per started 1,000 rows beyond the first 1,000; `X-Credits-Charged` reports the final debit and `X-Credits-Included-Remaining` what is left of the plan\'s included credits. `GET /v1/account/usage` returns your account\'s usage by day, endpoint family and key (it costs no credits). SEC filing search has a 100-credit base cost. **Coverage.** Financial data covers SEC registrants and US listings; a foreign suffix (`SAP.DE`, `VOD.L`) or a crypto pair (`X:BTCUSD`) is not a known company and answers 404. A known company with no data in a family (for example no statements yet) answers 404 with `code: not_covered`; an empty page of a covered company stays 200 with an empty list. `GET /v1/company/available-companies` lists every known company. ## Webhooks Accounts on LITE and above subscribe with `POST /v1/earnings-calls/webhooks` to the `earnings_call.*` lifecycle events (filtered by CIK) and, on STANDARD and above, to `news.published` (one delivery per new news item, filtered by the CIKs it mentions); see `x-webhooks` for each `data` object. What a subscription may hold depends on the plan (a create / update beyond it is refused with the plan\'s limit; `ping` needs no subscription — the test route and the disabled notice send it to any subscription): | Plan | Webhooks | Events | CIKs per webhook | Keywords per webhook | |---|---|---|---|---| | FREE | 0 | — | — | — | | LITE | 5 | `.scheduled`, `.rescheduled`, `.started`, `.ended`, `.transcript_ready`, `.assets_ready` | ≤ 10 | — | | STANDARD | 15 | LITE + `.transcript_provisional`, `.transcript_corrected`, `.documents_updated`, `news.published` | ≤ 25 | — | | PRO / ENTERPRISE | 50 | STANDARD + `.guidance_flash`, `.keyword_hit` | ≤ 100 | ≤ 20 (on ≤ 10 webhooks) | Every delivery is a `POST` with `Content-Type: application/json`, `X-Invinite-Event`, `X-Invinite-Delivery` and `X-Invinite-Signature: t=<unix seconds>,v1=<hex>` where `v1` = HMAC-SHA256(secret, `<t>.<raw body>`); during a secret rotation the header carries one `v1` per valid secret. Reject a signature older than 5 minutes. Any 2xx within 10 s acknowledges; redirects are not followed. A failed delivery is retried after 1 min, 5 min, 30 min, 2 h, 6 h, 12 h, 24 h (8 attempts in all, the same delivery id each time). A subscription is disabled after 8 consecutive dead-lettered deliveries (a final `ping` with `notice: subscription_disabled` is sent). Deliveries are at-least-once and unordered: dedupe on the delivery id, order by `created_at`. ## Licensing | Tier | display | redistribute | rag | train | audio | resell | | --- | --- | --- | --- | --- | --- | --- | | FREE | ✓ | – | – | – | – | – | | LITE | ✓ | – | – | – | – | – | | STANDARD | ✓ | – | ✓ | – | – | – | | PRO | ✓ | ✓ | ✓ | – | ✓ | – | Invinite data may be shown and, from PRO, redistributed inside the licensee\'s own product with attribution (\"Source: Invinite\" on screen or in the API response that carries it). It may never be resold, relicensed, white-labelled or offered as a data feed as the licensee\'s own data, at any tier, under any contract. Policy version: 2026-10-draft. Draft — pending counsel sign-off. Audio files carry a forensic watermark that identifies the recording. Audio is subject to per-company takedown and may not be re-hosted. SEC data: Figures and filings originate from SEC EDGAR; the standardisation, mapping and derived metrics are Invinite\'s. News: Issuer and SEC text is served in full with its attribution; the licensee shows publisher, source URL and date next to it and may forward it unmodified; the resale rule applies. PDF documents: Branded PDFs of transcripts and news items are permanent URLs to one shared file per version. They may be shown, downloaded and forwarded unmodified with the notice page intact; the resale rule applies unchanged. News PDFs reproduce issuer or SEC text under the attribution stated on their notice page; a PDF disappears when the item is taken down or its source\'s reuse is denied. Every `/v1/_*` data operation carries `x-license`, the minimum use right its data ships with; `GET /status/licensing` serves the same matrix per route, rendered at [data.invinite.com/docs/licensing](https://data.invinite.com/docs/licensing). `/v1/account/usage` serves no licensed data and carries none. ## Status [`/status`](/status) reports whether each product family works (a status and its uptime over 7, 30 and 90 days); [`/status/licensing`](/status/licensing) serves the licensing matrix per route. The status routes need no API key and are cached for 5 minutes. The public status page is [status.data.invinite.com](https://status.data.invinite.com): a snapshot of `/status` every 15 minutes plus an external reachability probe of the API. Uptime is the share of requests answered without a server error, measured by the API per product family; a window with too little traffic to judge shows no figure. Status reflects the last 24 hours. Product families: Company, Financials, SEC Filings, Insider Trades, Institutional Ownership, IPOs, Market, Metadata, Earnings Calls, News, WebSocket, Account.
6
+ *
7
+ * The version of the OpenAPI document: 1.0.0
8
+ *
9
+ *
10
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
11
+ * https://openapi-generator.tech
12
+ * Do not edit the class manually.
13
+ */
14
+
15
+ import { mapValues } from '../runtime';
16
+ /**
17
+ * The selectivity cap of a search WITHOUT any filter (null for a filtered search, which is never capped): at most `cap` matching passages are read from the index, in index order (not ranked, not newest-first), then ranked and cited
18
+ * @export
19
+ * @interface SecSearchCoverageMatches
20
+ */
21
+ export interface SecSearchCoverageMatches {
22
+ [key: string]: any | any;
23
+ /**
24
+ * true = more passages match than were examined: the answer is partial (`too_many_matches`)
25
+ * @type {boolean}
26
+ * @memberof SecSearchCoverageMatches
27
+ */
28
+ capped: boolean;
29
+ /**
30
+ * The most matching passages an unfiltered search reads
31
+ * @type {number}
32
+ * @memberof SecSearchCoverageMatches
33
+ */
34
+ cap: number;
35
+ /**
36
+ * Matching passages read from the index (at most `cap`)
37
+ * @type {number}
38
+ * @memberof SecSearchCoverageMatches
39
+ */
40
+ examined: number;
41
+ /**
42
+ * Of them, passages in searchable documents: the set the hits are ranked from
43
+ * @type {number}
44
+ * @memberof SecSearchCoverageMatches
45
+ */
46
+ examined_in_scope: number;
47
+ /**
48
+ * Every matching passage when not capped; null when capped (the total is unknown)
49
+ * @type {number}
50
+ * @memberof SecSearchCoverageMatches
51
+ */
52
+ total: number | null;
53
+ /**
54
+ * When capped: the total is at least this (cap + 1); never an estimate. null when not capped
55
+ * @type {number}
56
+ * @memberof SecSearchCoverageMatches
57
+ */
58
+ total_at_least: number | null;
59
+ /**
60
+ * Which passages were examined: the first ones the index returned (not newest-first)
61
+ * @type {SecSearchCoverageMatchesOrderEnum}
62
+ * @memberof SecSearchCoverageMatches
63
+ */
64
+ order: SecSearchCoverageMatchesOrderEnum;
65
+ /**
66
+ * Earliest filing date among the examined passages in searchable documents
67
+ * @type {Date}
68
+ * @memberof SecSearchCoverageMatches
69
+ */
70
+ filed_from: Date | null;
71
+ /**
72
+ * Latest filing date among the examined passages in searchable documents
73
+ * @type {Date}
74
+ * @memberof SecSearchCoverageMatches
75
+ */
76
+ filed_to: Date | null;
77
+ /**
78
+ * What makes the search complete: filer (`cik`), entity (`entity_id`), form (`form`), filed_from / filed_to (`filed_from` / `filed_to`), accession (`accession`)
79
+ * @type {Array<string>}
80
+ * @memberof SecSearchCoverageMatches
81
+ */
82
+ narrow_with: Array<string>;
83
+ }
84
+
85
+
86
+ /**
87
+ * @export
88
+ */
89
+ export const SecSearchCoverageMatchesOrderEnum = {
90
+ IndexOrder: 'index_order'
91
+ } as const;
92
+ export type SecSearchCoverageMatchesOrderEnum = typeof SecSearchCoverageMatchesOrderEnum[keyof typeof SecSearchCoverageMatchesOrderEnum];
93
+
94
+
95
+ /**
96
+ * Check if a given object implements the SecSearchCoverageMatches interface.
97
+ */
98
+ export function instanceOfSecSearchCoverageMatches(value: object): value is SecSearchCoverageMatches {
99
+ if (!('capped' in value) || value['capped'] === undefined) return false;
100
+ if (!('cap' in value) || value['cap'] === undefined) return false;
101
+ if (!('examined' in value) || value['examined'] === undefined) return false;
102
+ if (!('examined_in_scope' in value) || value['examined_in_scope'] === undefined) return false;
103
+ if (!('total' in value) || value['total'] === undefined) return false;
104
+ if (!('total_at_least' in value) || value['total_at_least'] === undefined) return false;
105
+ if (!('order' in value) || value['order'] === undefined) return false;
106
+ if (value['order'] !== 'index_order') return false;
107
+
108
+ if (!('filed_from' in value) || value['filed_from'] === undefined) return false;
109
+ if (!('filed_to' in value) || value['filed_to'] === undefined) return false;
110
+ if (!('narrow_with' in value) || value['narrow_with'] === undefined) return false;
111
+ return true;
112
+ }
113
+
114
+ export function SecSearchCoverageMatchesFromJSON(json: any): SecSearchCoverageMatches {
115
+ return SecSearchCoverageMatchesFromJSONTyped(json, false);
116
+ }
117
+
118
+ export function SecSearchCoverageMatchesFromJSONTyped(json: any, ignoreDiscriminator: boolean): SecSearchCoverageMatches {
119
+ if (json == null) {
120
+ return json;
121
+ }
122
+ return {
123
+
124
+ ...json,
125
+ 'capped': json['capped'],
126
+ 'cap': json['cap'],
127
+ 'examined': json['examined'],
128
+ 'examined_in_scope': json['examined_in_scope'],
129
+ 'total': json['total'],
130
+ 'total_at_least': json['total_at_least'],
131
+ 'order': json['order'],
132
+ 'filed_from': (json['filed_from'] == null ? null : new Date(json['filed_from'])),
133
+ 'filed_to': (json['filed_to'] == null ? null : new Date(json['filed_to'])),
134
+ 'narrow_with': json['narrow_with'],
135
+ };
136
+ }
137
+
138
+ export function SecSearchCoverageMatchesToJSON(json: any): SecSearchCoverageMatches {
139
+ return SecSearchCoverageMatchesToJSONTyped(json, false);
140
+ }
141
+
142
+ export function SecSearchCoverageMatchesToJSONTyped(value?: SecSearchCoverageMatches | null, ignoreDiscriminator: boolean = false): any {
143
+ if (value == null) {
144
+ return value;
145
+ }
146
+
147
+ return {
148
+
149
+ ...value,
150
+ 'capped': value['capped'],
151
+ 'cap': value['cap'],
152
+ 'examined': value['examined'],
153
+ 'examined_in_scope': value['examined_in_scope'],
154
+ 'total': value['total'],
155
+ 'total_at_least': value['total_at_least'],
156
+ 'order': value['order'],
157
+ 'filed_from': value['filed_from'] == null ? value['filed_from'] : value['filed_from'].toISOString().substring(0,10),
158
+ 'filed_to': value['filed_to'] == null ? value['filed_to'] : value['filed_to'].toISOString().substring(0,10),
159
+ 'narrow_with': value['narrow_with'],
160
+ };
161
+ }
162
+
@@ -223,6 +223,7 @@ export * from './SecSearch200Response';
223
223
  export * from './SecSearch200ResponseHitsInner';
224
224
  export * from './SecSearchCoverage';
225
225
  export * from './SecSearchCoverageLexical';
226
+ export * from './SecSearchCoverageMatches';
226
227
  export * from './SecStoreError';
227
228
  export * from './SegmentedFinancials200Response';
228
229
  export * from './SegmentedFinancials200ResponseCompaniesInner';