@grepr/cli 1.8.4-b895a9f → 1.8.6-7c73069

package/build/dist/docs-index/857511c9-f614-4d3d-9231-edc07c3fa7b4.txt

@@ -0,0 +1,111 @@
+Process data in Grepr pipelines using built-in tools for parsing, filtering, enrichment, and transformation of log events.
+
+# Transform data in a Grepr pipeline
+
+A Grepr transform is a processing step that modifies, enriches, or restructures data as it flows through a pipeline. As records move through a pipeline, transforms allow you to parse structured and semi-structured data, filter records, and use a familiar SQL interface to perform more complex transformation of records as they move through a pipeline. Transforms are configured as pipeline steps that process data sequentially. Each transform receives input data, applies its logic, and passes the result to the next step in the pipeline.
+
+Most transforms are available in the Grepr pipelines UI. Some transforms are available only in the Grepr REST API or provide more capabilities when used with the API, such as [filters](#filter) and [branching the processing of records](#message-routing) based on query matches.
+
+The following sections describe the transforms available in Grepr pipelines.
+
+## Transform semi-structured records with the Grok parser \[#grok-parser]
+
+The Grok transform parses unstructured text using pattern matching with regular expressions and named capture groups. Use this transform to extract fields from log lines, error messages, and other text-based data where you need to identify specific patterns and convert them to structured fields.
+
+See [Grok parser](/transforms/grok).
+
+## Convert JSON messages into structured objects \[#json-parser]
+
+The JSON parser transforms JSON strings into structured JSON objects. This transform handles nested objects, arrays, and various data types, making it useful for processing API responses, configuration data, and structured log entries.
+
+See [Transform JSON strings into JSON objects](/transforms/json-parsing).
+
+## Restructure JSON objects with a remapper \[#remapper]
+
+The remapper transform moves or copies attributes to top-level fields or to tags in a JSON object. You can also use rename rules to move attribute values from one path to another within the same event. In the pipelines UI, a remapper with customizable default attributes is automatically added to a pipeline.
+
+See [Remap JSON attribute fields to top-level log event fields](/transforms/remapper).
+
+## Transform records with SQL \[#sql-transform]
+
+The SQL transform allows you to use ANSI standard SQL queries to filter, transform, and enrich data records. The SQL transform provides a familiar SQL interface to perform a number of data processing and transformation tasks.
+
+You can use the SQL transform in the Grepr UI or REST API. In the UI, the SQL transform is available when you configure filters.
+
+To learn about using the SQL transform in the Grepr API, see the [SQL Operation specification](/apis/api-spec#schema/SQLOperation).
+
+For a complete reference and examples, see [Transform events with SQL](/transforms/sql-transform).
+
+## Filter records based on conditions \[#filter]
+
+The Filter transform includes or excludes data records based on specified conditions. You can create filters using familiar query interfaces, such as SQL, as well as Datadog and New Relic log query-like syntaxes.
+
+In the Grepr pipelines UI, filters are located in predefined locations in the pipeline. To learn how to configure filters, see [Filter events in a Grepr pipeline](/transforms/filter-events).
+
+To have more flexibility for where filters are included in a pipeline, use the REST API. See [LogsFilter](/apis/api-spec#schema/LogsFilter).
+
+## Reduce log volumes with dynamic aggregation \[#reducer]
+
+The Grepr log reducer uses clustering algorithms to identify patterns in your log data and aggregate similar log messages. The output of this aggregation includes summaries and samples of similar messages. The log reducer is a core step in a log reduction pipeline, where it runs before processed log events are sent to your configured sinks. By sending summaries of similar messages rather than multiple events with redundant information, Grepr significantly reduces the volume of shipped logs and your observability costs. The log reduction pipeline also persists the complete set of raw logs to a low-cost data lake, enabling you to analyze and troubleshoot issues when necessary.
+
+To learn more about how Grepr reduces log volumes with dynamic aggregation, see [Reduce noise and improve the usability of your logs with the log reducer](/transforms/reducer).
+
+To learn how to create a log reduction pipeline, see [Tutorial: Build your first Grepr pipeline](/tutorials/first-pipeline).
+
+To learn how to use the resulting summarized log events in your observability platform along with raw logs stored in Grepr, see [Troubleshoot incidents with Grepr-processed data and your observability tool](/tutorials/troubleshooting-example).
+
+## Transform and enrich log messages with the REST API \[#log-transform-action]
+
+You can use the LogTransformAction in the REST API to specify actions that transform log messages, such as adding or removing attributes and tags. See [LogTransformAction](/apis/api-spec#schema/LogTransformAction).
+
+## Route the processing of messages based on query matches \[#message-routing]
+
+You can route log messages to be processed by different pipelines based on query matches. Because the pipelines UI doesn't support branching, Grepr recommends creating multiple pipelines that ingest data using the same source, and then use filters to route data to the correct pipeline.
+
+You can also use the REST API to create more complex pipeline configurations. See [LogsBranch](/apis/api-spec#schema/LogsBranch).
+
+## Frequently Asked Questions
+
+### What transforms are available in Grepr pipelines?
+
+Grepr provides several transform types: Grok parser for parsing unstructured text with pattern matching, JSON parser for converting JSON strings into structured objects, remapper for restructuring JSON fields and attributes, SQL transform for complex filtering and enrichment using SQL queries, and Filter transform for conditional record processing. Most transforms are available in the UI, while some advanced options are available via REST API.
+
+### When should I use the Grok parser transform?
+
+Use the Grok parser when you need to extract structured data from unstructured text logs. It's ideal for parsing error messages, application logs, system logs, and other text-based data where you need to identify specific patterns and convert them into structured fields using regular expressions and named capture groups.
+
+### When should I use the JSON parser transform?
+
+Use the JSON parser when your log messages contain JSON strings that need to be converted into structured JSON objects. This is useful for processing API responses, configuration data, and structured log entries. The JSON parser handles nested objects, arrays, and various data types automatically.
+
+### What is the remapper transform and when is it used?
+
+The remapper transform moves or copies attributes to top-level fields or to tags in a JSON object. It's useful for standardizing log event structure by moving well-known fields like message, severity, and host from nested attributes to top-level fields. You can configure whether the source attribute is preserved or removed after remapping. The remapper also supports rename rules for moving attribute values from one path to another. The remapper is automatically added to pipelines in the UI with customizable default attributes.
+
+### When should I use the SQL transform?
+
+Use the SQL transform when you need complex filtering, transformation, or enrichment of log records. SQL provides a familiar interface for advanced operations like conditional logic, string manipulation, aggregations, and joining data. It's available in the UI for filters and via REST API for more flexibility.
+
+### Can I combine multiple transforms in a pipeline?
+
+Yes, transforms are configured as sequential pipeline steps. Each transform receives input from the previous step, applies its logic, and passes the result to the next step. This allows you to create complex data processing workflows by combining parsing (Grok), restructuring (remapper), and filtering/enrichment (SQL) transforms.
+
+### What is the Filter transform used for?
+
+The Filter transform includes or excludes data records based on specified conditions. You can use filters with SQL, Datadog, and New Relic-like query syntaxes. In the UI, filters are located in predefined pipeline positions, while the REST API provides more flexibility for filter placement.
+
+### Can I use the REST API for more advanced transform options?
+
+Yes, the REST API provides access to advanced transform options not available in the UI. For example, you can use LogTransformAction to add or remove attributes and tags, LogsBranch for complex message routing based on query matches, and more flexible filter placement. See the API specification for complete details on transform capabilities.
+
+### How do I choose between Grok and SQL transforms?
+
+Use Grok when you need pattern-based parsing of unstructured text to extract specific fields. Use SQL when you need complex conditional logic, calculations, string transformations, or filtering. Grok is specialized for text parsing, while SQL is more general-purpose for data manipulation and enrichment.
+
+### How does Grepr reduce log volumes and observability costs?
+
+Grepr uses clustering algorithms to identify patterns in log data and aggregates similar log messages. Instead of sending multiple redundant log events, Grepr sends summaries and samples of similar messages to your observability platform. This significantly reduces the volume of shipped logs while retaining the ability to analyze and troubleshoot issues. Raw logs are retained in a low-cost data lake for future reference.
+
+### What happens if a transform fails on a record?
+
+Transform behavior depends on the specific transform type and configuration. Parsing errors (like Grok or JSON parsing) typically skip records or add error attributes depending on your configuration. SQL transforms filter out records that don't match conditions. Review transform-specific documentation for error handling details.

package/build/dist/docs-index/86e892c6-2755-4460-b8b2-c4ff088ccdff.json

@@ -0,0 +1 @@
+{"docType":"api"}

package/build/dist/docs-index/86e892c6-2755-4460-b8b2-c4ff088ccdff.txt

@@ -0,0 +1,29 @@
+# Get a Gemini integration
+
+**GET** `/v1/integrations/gemini/{id}`
+
+**Operation ID**: `get_5`
+**Summary**: Get a Gemini integration
+Get a Gemini integration by ID.
+
+## Tags
+- Gemini Integration
+## Parameters
+
+- **id** (required) - path
+  - Type: string
+
+## Responses
+
+### 200
+
+Integration retrieved successfully
+
+- **Content-Type**: `application/json` / `ReadGemini`
+### 401
+
+Unauthorized
+
+### 404
+
+Integration not found.

package/build/dist/docs-index/86f7c276-7f73-4f7d-9d1b-bc9b5ffc97fe.json

@@ -0,0 +1 @@
+{"docType":"api"}

package/build/dist/docs-index/86f7c276-7f73-4f7d-9d1b-bc9b5ffc97fe.txt

@@ -0,0 +1,35 @@
+# getAnomaliesForJobRuleEngineAndTriggers
+
+**GET** `/v1/anomalies/{jobId}/{ruleEngineName}`
+
+**Operation ID**: `getAnomaliesForJobRuleEngineAndTriggers`
+**Summary**: No summary provided.
+## Tags
+- Job Anomalies
+## Parameters
+
+- **jobId** (required) - path
+  - Type: string
+- **ruleEngineName** (required) - path
+  - Type: string
+- **triggerIds** (optional) - query
+  - Type: array of string
+
+## Responses
+
+### 200
+
+Anomalies retrieved successfully
+
+- **Content-Type**: `application/json` / array of `JobAnomaly`
+### 400
+
+Invalid request parameters
+
+### 401
+
+Unauthorized
+
+### 404
+
+Job not found

package/build/dist/docs-index/874b2883-df79-4764-8597-5d8b37023da2.json

@@ -0,0 +1 @@
+{"docType":"api"}

package/build/dist/docs-index/874b2883-df79-4764-8597-5d8b37023da2.txt

@@ -0,0 +1,20 @@
+# List all S3 Vector Index integrations
+
+**GET** `/v1/integrations/s3-vector-index`
+
+**Operation ID**: `list_14`
+**Summary**: List all S3 Vector Index integrations
+Retrieves all S3 Vector Index integrations for the organization.
+
+## Tags
+- S3 Vector Index Integration
+## Responses
+
+### 200
+
+S3 Vector Index integrations retrieved successfully
+
+- **Content-Type**: `application/json` / `ItemsCollectionReadS3VectorIndex`
+### 401
+
+Unauthorized

package/build/dist/docs-index/87ad3f33-316b-40ff-8040-3377a752cfd3.json

@@ -0,0 +1 @@
+{"docType":"doc"}

package/build/dist/docs-index/87ad3f33-316b-40ff-8040-3377a752cfd3.txt

@@ -0,0 +1,264 @@
+Learn how to configure a Grepr OpenTelemetry integration to connect with Grafana Cloud, enabling you to ingest logs to a Grepr pipeline for processing and send the processed logs to your Grafana Cloud instance.
+
+# Configure Grafana Cloud connections with a Grepr integration
+
+To connect Grepr to Grafana Cloud, use the Grepr OpenTelemetry integration to ingest logs into your Grepr pipelines for processing and send the processed logs to an OTLP endpoint in your Grafana Cloud account.
+
+To send logs to a Grepr pipeline before forwarding them to Grafana Cloud, you change your collector configuration to send the logs to a Grepr endpoint URL instead of the Grafana Cloud OTLP endpoint. The Grepr OpenTelemetry integration supports several Grafana-compatible collectors, including the Grafana Alloy collector, the OpenTelemetry Collector, and Grafana Agent (EOL).
+
+You can use the Grepr UI or REST API to create an OpenTelemetry integration configured for Grafana Cloud. To learn how to create an OpenTelemetry integration in the Grepr UI and configure collectors to send logs to Grepr, see [Use an OpenTelemetry integration in a Grepr pipeline](#use-otel-integration-with-grafana).
+
+> Although this page describes using an integration to create a pipeline for sourcing and sending data with a single observability platform, your pipelines can use multiple integrations to source and sink data for different platforms. For example, you can create a pipeline with a Datadog integration that's used to source data from Datadog agents, and a Splunk integration and sink that sends the pipeline output to Splunk.
+
+## Requirements
+
+To connect Grepr with Grafana Cloud using an OpenTelemetry integration, you need:
+
+* A Grafana Cloud Access Policy token with write access to logs. See [Grafana Cloud Access Policies](https://grafana.com/docs/grafana-cloud/security-and-account-management/authentication-and-permissions/access-policies/).
+* A Grafana Cloud OTLP Endpoint. See [Send data to the Grafana Cloud OTLP endpoint](https://grafana.com/docs/grafana-cloud/send-data/otlp/send-data-otlp/).
+
+## Use an OpenTelemetry integration with Grafana in a Grepr pipeline \[#use-otel-integration-with-grafana]
+
+### Step 1: Create an OpenTelemetry integration
+
+To create an OpenTelemetry integration configured for Grafana Cloud in the Grepr UI:
+
+1. Go to the **Integrations** page in the Grepr UI and click **Add new** next to **Observability Vendors**.
+
+2. In the **Add Observability Vendor** dialog:
+
+   * In the **Type** menu, select **Open Telemetry**.
+
+   * In the **Name** field, enter a name for the integration. Grepr recommends naming it descriptively so it's easy to identify. For example, `grafana-cloud-prod-logs`.
+
+   * In the **Base Endpoint URL** field, enter your Grafana Cloud OTLP endpoint URL.
+
+   * Click **Add Header**.
+
+     * In the **Header Name** field, enter `Authorization`.
+     * In the **Header Value** field, enter `Bearer <your-grafana-access-token>`. Replace `<your-grafana-access-token>` with the token generated from your Grafana Cloud Access Policy.
+     * Select the **Make header secret** checkbox.
+
+3. Click **Create**.
+
+4. Save the `GREPR TOKEN` displayed in the confirmation dialog securely.
+
+   #### Optional: Grant team access to the integration
+
+   When you have teams in your Grepr organization, you can grant access to the integration to one or more of those teams. To configure team access when you create or edit an integration:
+
+   1. In the **Grant Team Access** section, click the plus sign icon (+).
+
+   2. Select the team or teams that should be granted access to the integration.
+
+   3. Click **Create**.
+
+   To learn more, see [Manage teams in the Grepr platform](/admin/manage-teams) and [Permissions in the Grepr platform](/grepr-platform/permissions).
+
+### Step 2: Add a source to your pipeline
+
+To add a source to your pipeline that uses the OpenTelemetry integration:
+
+1. In the Grepr UI, go to the details page of an existing pipeline or create a new pipeline from the homepage.
+2. In the left-hand navigation menu, click **Sources**.
+3. In the **Add source** dialog, select your OpenTelemetry integration in the **Source** menu.
+4. Click **Submit**.
+
+### Step 3: Configure log forwarding to Grepr
+
+To send data to Grepr, you configure your collector or agent to send it to the ingestion URL for your Grepr integration, rather than to your observability vendor's platform. To find the ingestion URL when using the Grepr UI to configure your pipeline, go to the details page for the pipeline, click **Sources** in the left pane, and copy the **Ingest URL**.
+
+
+
+If you connect to Grepr through AWS PrivateLink, copy the private ingestion URL and use it in place of the public ingestion URL. To learn more about sending data to Grepr over AWS PrivateLink, see [Securely forward observability data to Grepr with AWS PrivateLink](/admin/private-link).
+
+When you use the API, you can construct the ingestion URL using the following format:
+
+`https://<integration-id>-<org-id>.ingest.grepr.ai/otlp/<grepr-token>`
+
+Replace `<integration-id>` with the identifier of the vendor integration used by your pipeline and replace `<org-id>` with the identifier for your organization.
+
+To use the PrivateLink endpoint service, insert `.private` after the `ingest` host segment.
+
+Although all sources created from the same integration share the same ingestion URL, you can use a single integration to create sources for multiple pipelines. The Grepr platform ensures events are routed to the correct pipelines.
+
+Replace `<grepr-token>` with the token you saved after creating the OpenTelemetry integration in Step 1.
+
+To see more information and configuration examples, select the tab for your preferred log collector:
+
+Grafana Alloy is the recommended collector for connecting to Grafana Cloud. It replaces the end-of-life Grafana Agent and provides enhanced performance and capabilities.
+
+To configure Grafana Alloy to send logs to Grepr, use the OTLP exporter pointing to Grepr's ingestion endpoint.
+
+Configuration (`config.alloy`):
+
+```shell
+otelcol.exporter.otlphttp "grepr" {
+  client {
+    endpoint = "<ingestion-url>"
+  }
+}
+
+otelcol.receiver.otlp "default" {
+  http {}
+  grpc {}
+
+  output {
+    logs = [otelcol.exporter.otlphttp.grepr.input]
+  }
+}
+```
+
+Replace `<ingestion-url>` with the full ingestion URL provided by the Grepr UI.
+
+To configure dual shipping, create two exporters:
+
+```shell
+otelcol.exporter.otlphttp "grepr" {
+  client {
+    endpoint = "<ingestion-url>"
+  }
+}
+
+otelcol.exporter.otlphttp "grafana" {
+  client {
+    endpoint = "<your-grafana-otlp-endpoint>"
+    headers = {
+      "Authorization" = "Bearer <your-grafana-access-token>"
+    }
+  }
+}
+
+otelcol.receiver.otlp "default" {
+  http {}
+  grpc {}
+
+  output {
+    logs    = [
+      otelcol.exporter.otlphttp.grepr.input,
+      otelcol.exporter.otlphttp.grafana.input
+    ]
+  }
+}
+```
+
+Replace `<your-grafana-otlp-endpoint>` with your Grafana Cloud OTLP endpoint and `<your-grafana-access-token>` with your Grafana Cloud access token.
+
+To learn more about Grafana Alloy configuration, see the [Grafana Alloy documentation](https://grafana.com/docs/alloy/latest/).
+
+The OpenTelemetry Collector can send logs to Grepr using the `otlphttp` exporter.
+
+To configure the OpenTelemetry Collector to send logs to Grepr's ingestion endpoint, update your collector configuration (`collector.yaml`):
+
+```yaml
+exporters:
+  otlphttp:
+    endpoint: <ingestion-url>
+
+service:
+  pipelines:
+    logs:
+      receivers: [otlp]
+      processors: [batch]
+      exporters: [otlphttp]
+```
+
+Replace `<ingestion-url>` with the full ingestion URL provided by the Grepr UI.
+
+To configure dual shipping:
+
+```yaml
+exporters:
+  otlphttp/grepr:
+    endpoint: <ingestion-url>
+
+  otlphttp/grafana:
+    endpoint: <your-grafana-otlp-endpoint>
+    headers:
+      Authorization: Bearer <your-grafana-access-token>
+
+service:
+  pipelines:
+    logs:
+      receivers: [otlp]
+      processors: [batch]
+      exporters: [otlphttp/grepr, otlphttp/grafana]
+```
+
+Replace `<your-grafana-otlp-endpoint>` with your Grafana Cloud OTLP endpoint and `<your-grafana-access-token>` with your Grafana Cloud access token.
+
+To learn more about OpenTelemetry Collector configuration, see the [OpenTelemetry Collector documentation](https://opentelemetry.io/docs/collector/).
+
+> Grafana Agent is end-of-life as of November 1, 2025. Grepr recommends migrating to Grafana Alloy for new and existing deployments.
+
+To configure Grafana Agent to send logs to Grepr, use the OTLP exporter in your agent configuration.
+
+Configuration (`agent.yaml`):
+
+```yaml
+logs:
+  configs:
+    - name: default
+      clients:
+        - url: <ingestion-url>
+```
+
+Replace `<ingestion-url>` with the full ingestion URL provided by the Grepr UI.
+
+## Advanced configuration
+
+### Custom headers
+
+If your Grafana Cloud setup requires additional headers other than the Authorization header, you can add them in the Grepr UI when creating your OpenTelemetry integration:
+
+* Non-secret headers: Add in the **HTTP Headers** section.
+* Secret headers: Add in the **HTTP Headers** section and select the **Make header secret** checkbox.
+
+### Endpoint overrides
+
+For advanced use cases, you can use the **Advanced** mode in the Grepr UI to specify separate endpoints for logs and traces:
+
+* **Logs Endpoint Override**: Specify a custom logs endpoint (if different from base endpoint + `/v1/logs`).
+* **Traces Endpoint Override**: Specify a custom traces endpoint (if different from base endpoint + `/v1/traces`).
+
+## Frequently Asked Questions
+
+### How do I connect Grepr to Grafana Cloud?
+
+Create an OpenTelemetry integration in Grepr with your Grafana Cloud OTLP endpoint and configure an Authorization header with your Grafana Cloud Access Policy token. The ingestion URL format is https\://\<integration-id>-\<org-id>.ingest.grepr.ai/otlp/\<grepr-token>. Configure your collector to send logs to this URL.
+
+### What is required to set up Grafana Cloud integration with Grepr?
+
+You need a Grafana Cloud Access Policy token with write access to logs and your Grafana Cloud OTLP endpoint URL. The token is used for authentication between Grepr and Grafana Cloud. You can create access policies in Grafana Cloud under Home > Administration > Users and access > Cloud access policies.
+
+### How do I configure Grafana Alloy to send logs to Grepr?
+
+Grafana Alloy is the recommended collector for Grafana Cloud. Configure the otelcol.exporter.otlphttp component with your Grepr ingestion endpoint. For dual-shipping, add a second exporter pointing to your Grafana Cloud OTLP endpoint with the Authorization header containing your Grafana access token.
+
+### Can I use OpenTelemetry Collector with Grafana Cloud and Grepr?
+
+Yes, the OpenTelemetry Collector can be used with Grafana Cloud. Configure the otlphttp exporter with your Grepr ingestion endpoint. For dual-shipping to both Grepr and Grafana Cloud, add multiple exporters to your logs pipeline with appropriate endpoint URLs and headers.
+
+### What is Grafana Agent and why is it end-of-life?
+
+Grafana Agent is an older collector that has reached end-of-life as of November 1, 2025. Grepr recommends migrating to Grafana Alloy, which provides enhanced performance, better feature support, and ongoing maintenance. Grafana Alloy is the successor and recommended collector for new deployments.
+
+### How do I migrate from Grafana Agent to Grafana Alloy with Grepr?
+
+Update your collector configuration to use Grafana Alloy and configure the otelcol.exporter.otlphttp component to point to your Grepr ingestion endpoint. Grafana Alloy uses the same OTLP protocol as the OpenTelemetry Collector, making migration straightforward.
+
+### What custom headers can I add to my Grafana Cloud OpenTelemetry integration?
+
+You can add non-secret headers in the HTTP Headers section and secret headers (like API keys or authentication tokens) in the HTTP Headers section with the Make header secret checkbox selected. Secret headers are stored securely and masked in the UI.
+
+### Can I use different endpoints for logs and traces with Grafana Cloud?
+
+Yes, for advanced use cases, you can use Advanced mode in the Grepr UI to specify separate Logs Endpoint Override and Traces Endpoint Override if your Grafana Cloud setup requires different endpoints for different signal types.
+
+### How do I reduce Grafana Cloud storage costs with Grepr?
+
+Configure your Grepr pipeline with a Grafana Cloud source and sink. Use Grepr's transformation and log reducer features to filter, enrich, and aggregate logs before sending them back to Grafana Cloud. This reduces the volume of data stored in Grafana Cloud.
+
+### What is the advantage of using Grepr with Grafana Cloud?
+
+Grepr enables advanced log processing, filtering, and aggregation using its log reducer and transformation features. By processing logs through Grepr before storing in Grafana Cloud, you can reduce storage costs, improve log quality, and gain deeper insights into your logs without additional Grafana expense.

package/build/dist/docs-index/87c5c58c-dc20-4c36-afcd-c8df8ef405f4.json

@@ -0,0 +1 @@
+{"docType":"schema"}

package/build/dist/docs-index/87c5c58c-dc20-4c36-afcd-c8df8ef405f4.txt

@@ -0,0 +1,23 @@
+# PresignedUploadUrlResponse
+
+Presigned URL for uploading a file
+
+**Type**: `object`
+
+## Properties
+
+- name: expiresAt (optional)
+  type: string
+  description: Timestamp when the presigned URL expires
+
+- name: orgId (optional)
+  type: string
+  description: Organization ID that owns this upload
+
+- name: presignedUrl (optional)
+  type: string
+  description: Presigned URL that can be used to upload files
+
+- name: uploadId (optional)
+  type: string
+  description: Unique identifier for this upload

package/build/dist/docs-index/88521862-34d9-45e9-acdd-d054dbb4a5b8.json

@@ -0,0 +1 @@
+{"docType":"schema"}

package/build/dist/docs-index/88521862-34d9-45e9-acdd-d054dbb4a5b8.txt

@@ -0,0 +1,24 @@
+# WriteS3VectorIndex
+
+**Type**: `object`
+
+## Properties
+
+- name: name (required)
+  type: string
+  description: Name of the integration.
+
+- name: payload (required)
+  type: `S3VectorIndex`
+
+- name: teamIds (optional)
+  type: array of string
+  description: The team IDs that this integration is associated with.
+
+- name: type (required)
+  type: enum: `s3-vector-index`
+  description: The type of the integration. This is used to determine the payload type.
+
+- name: version (required)
+  type: integer
+  description: Version of the integration. Should be increased by one for every new update in order for the write to succeed. Otherwise, a '409 Conflict' will be returned.

package/build/dist/docs-index/88dd42a9-cbfc-446a-b675-c76aa356b62a.json

@@ -0,0 +1 @@
+{"docType":"schema"}

package/build/dist/docs-index/88dd42a9-cbfc-446a-b675-c76aa356b62a.txt

@@ -0,0 +1,35 @@
+# LogEvent
+
+A log event.
+
+**Type**: `object`
+
+## Properties
+
+- name: attributes (optional)
+  type: object
+  description: Attributes associated with the event, a map from attribute name to attribute value, which may be a nested map or list.
+
+- name: eventTimestamp (required)
+  type: integer
+  description: Event timestamp that is in the record. Milliseconds from epoch.
+
+- name: id (required)
+  type: string
+  description: Id of the event.
+
+- name: message (optional)
+  type: string
+  description: The log message.
+
+- name: receivedTimestamp (required)
+  type: integer
+  description: Timestamp when the event was received by Grepr. Milliseconds from epoch.
+
+- name: severity (optional)
+  type: integer
+  description: The log severity. Higher numbers mean higher severity, following the OTel format 1-24.
+
+- name: tags (optional)
+  type: object
+  description: Tags associated with the event, a map from tag name to set of tag values.

package/build/dist/docs-index/89192f91-70ff-4957-9255-f76df5aefafa.json

@@ -0,0 +1 @@
+{"docType":"schema"}

package/build/dist/docs-index/89192f91-70ff-4957-9255-f76df5aefafa.txt

@@ -0,0 +1,23 @@
+# MetricAggSpec
+
+The metrics aggregation to apply to the source data.
+
+**Type**: `object`
+
+## Properties
+
+- name: groupByTags (optional)
+  type: array of string
+  description: The tags to group the results by. If unspecified, all series are grouped together. Only applicable when spaceAggregation is set.
+
+- name: spaceAggregation (optional)
+  type: enum: `LATEST`, `SUM`, `AVG`, `MAX`
+  description: The space aggregation to use for the query. If null, no grouping is done and the timeseries are returned with full tags.
+
+- name: timeAggregation (optional)
+  type: enum: `LATEST`, `SUM`, `AVG`, `MAX`
+  description: The time aggregation to use for the query. If this is set, timeGranularity must also be provided. If null, no time aggregation is done and the raw datapoints are returned.
+
+- name: timeGranularity (optional)
+  type: string
+  description: The time granularity to use for the query. Only applicable when timeAggregation is set.

package/build/dist/docs-index/891aba63-4749-491b-b50d-6b2ac388499f.json

@@ -0,0 +1 @@
+{"docType":"schema"}

package/build/dist/docs-index/891aba63-4749-491b-b50d-6b2ac388499f.txt

@@ -0,0 +1,27 @@
+# ServiceAccountWithSecret
+
+Service account with client secret (only returned on creation)
+
+**Type**: `object`
+
+## Properties
+
+- name: clientId (required)
+  type: string
+  description: OAuth2 client ID for authentication
+
+- name: id (required)
+  type: string
+  description: Unique identifier
+
+- name: name (required)
+  type: string
+  description: Display name of the service account
+
+- name: roles (required)
+  type: array of `Role`
+  description: List of assigned roles
+
+- name: secret (required)
+  type: string
+  description: The OAuth2 client secret for authentication

package/build/dist/docs-index/89d5fa95-0e22-43c1-8fb4-3ea0bfffe53f.json

@@ -0,0 +1 @@
+{"docType":"schema"}

package/build/dist/docs-index/89d5fa95-0e22-43c1-8fb4-3ea0bfffe53f.txt

@@ -0,0 +1,13 @@
+# MessagePrefixNode
+
+**Type**: `object`
+
+## Properties
+
+- name: prefix (required)
+  type: string
+  description: The prefix to match a message.
+
+- name: type (required)
+  type: enum: `message-prefix-node`
+  description: A node that represents a message prefix in a parsed query.

package/build/dist/docs-index/8abcae90-f6af-406e-8bcd-79e85c945c3a.json

@@ -0,0 +1 @@
+{"docType":"schema"}

package/build/dist/docs-index/8abcae90-f6af-406e-8bcd-79e85c945c3a.txt

@@ -0,0 +1,8 @@
+# QueryParsingError
+
+**Type**: `object`
+
+## Properties
+
+- name: message (required)
+  type: string