curl --request POST \
  --url 'https://analytics.us.algolia.com/3/patterns/timeseries?index=lorem' \
  --header 'accept: application/json' \
  --header 'content-type: application/json' \
  --header 'x-algolia-api-key: ALGOLIA_API_KEY' \
  --header 'x-algolia-application-id: ALGOLIA_APPLICATION_ID' \
  --data '
{
  "domain": "core",
  "metrics": [
    {
      "domain": "core",
      "kind": "searchesCount"
    }
  ],
  "groupBy": [
    {
      "domain": "core",
      "kind": "searchesCount"
    }
  ],
  "filters": [
    {
      "domain": "lorem",
      "kind": "country",
      "operator": "=",
      "parameter": {
        "domain": "core",
        "kind": "country"
      }
    }
  ],
  "parameters": [
    {
      "domain": "lorem",
      "kind": "indices",
      "value": "lorem"
    }
  ],
  "limit": 100,
  "offset": 0
}
'

// Initialize the client
var client = new AnalyticsClient(
  new AnalyticsConfig("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY", "ALGOLIA_APPLICATION_REGION")
);

// Call the API
var response = await client.QueryPatternsTimeseriesAsync(
  new TimeseriesPayload
  {
    Metrics = new List<FieldReference> { new FieldReference { Kind = "searchesCount" } },
    Parameters = new List<ParameterDefinition>
    {
      new ParameterDefinition
      {
        Kind = "indices",
        Value = new ParameterValue(new List<string> { "index" }),
      },
    },
  },
  "index"
);

// print the response
Console.WriteLine(response);

// Initialize the client with your application region, eg. analytics.ALGOLIA_APPLICATION_REGION
client, err := analytics.NewClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY", analytics.US)
if err != nil {
  // The client can fail to initialize if you pass an invalid parameter.
  panic(err)
}

// Call the API
response, err := client.QueryPatternsTimeseries(client.NewApiQueryPatternsTimeseriesRequest(

  analytics.NewEmptyTimeseriesPayload().SetMetrics(
    []analytics.FieldReference{*analytics.NewEmptyFieldReference().SetKind("searchesCount")}).SetParameters(
    []analytics.ParameterDefinition{
      *analytics.NewEmptyParameterDefinition().SetKind("indices").SetValue(analytics.ArrayOfStringAsParameterValue(
        []string{"index"})),
    }),
).WithIndex("index"))
if err != nil {
  // handle the eventual error
  panic(err)
}


// print the response
print(response)

// Initialize the client
AnalyticsClient client = new AnalyticsClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY", "ALGOLIA_APPLICATION_REGION");

// Call the API
TimeseriesResponse response = client.queryPatternsTimeseries(
  new TimeseriesPayload()
    .setMetrics(Arrays.asList(new FieldReference().setKind("searchesCount")))
    .setParameters(Arrays.asList(new ParameterDefinition().setKind("indices").setValue(ParameterValue.of(Arrays.asList("index"))))),
  "index"
);

// print the response
System.out.println(response);

// Initialize the client
// Replace 'us' with your Algolia Application Region
const client = algoliasearch('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY').initAnalytics({ region: 'us' });

// Call the API
const response = await client.queryPatternsTimeseries({
  timeseriesPayload: { metrics: [{ kind: 'searchesCount' }], parameters: [{ kind: 'indices', value: ['index'] }] },
  index: 'index',
});


// print the response
console.log(response);

// Initialize the client
val client =
  AnalyticsClient(
    appId = "ALGOLIA_APPLICATION_ID",
    apiKey = "ALGOLIA_API_KEY",
    region = "ALGOLIA_APPLICATION_REGION",
  )

// Call the API
var response =
  client.queryPatternsTimeseries(
    timeseriesPayload =
      TimeseriesPayload(
        metrics = listOf(FieldReference(kind = "searchesCount")),
        parameters =
          listOf(
            ParameterDefinition(kind = "indices", value = ParameterValue.of(listOf("index")))
          ),
      ),
    index = "index",
  )


// print the response
println(response)

// Initialize the client
$client = AnalyticsClient::create('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY', 'ALGOLIA_APPLICATION_REGION');

// Call the API
$response = $client->queryPatternsTimeseries(
    ['metrics' => [
        ['kind' => 'searchesCount',
        ],
    ],
        'parameters' => [
            ['kind' => 'indices',
                'value' => [
                    'index',
                ],
            ],
        ],
    ],
    'index',
);


// print the response
var_dump($response);

# Initialize the client
# In an asynchronous context, you can use AnalyticsClient instead, which exposes the exact same methods.
client = AnalyticsClientSync(
    "ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY", "ALGOLIA_APPLICATION_REGION"
)

# Call the API
response = client.query_patterns_timeseries(
    timeseries_payload={
        "metrics": [
            {
                "kind": "searchesCount",
            },
        ],
        "parameters": [
            {
                "kind": "indices",
                "value": [
                    "index",
                ],
            },
        ],
    },
    index="index",
)


# print the response
print(response)

# Initialize the client
client = Algolia::AnalyticsClient.create("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY", "ALGOLIA_APPLICATION_REGION")

# Call the API
response = client.query_patterns_timeseries(
  Algolia::Analytics::TimeseriesPayload.new(
    metrics: [Algolia::Analytics::FieldReference.new(kind: "searchesCount")],
    parameters: [Algolia::Analytics::ParameterDefinition.new(kind: "indices", value: ["index"])]
  ),
  "index"
)


# print the response
puts(response)

// Initialize the client
val client = AnalyticsClient(
  appId = "ALGOLIA_APPLICATION_ID",
  apiKey = "ALGOLIA_API_KEY",
  region = Option("ALGOLIA_APPLICATION_REGION")
)

// Call the API
val response = Await.result(
  client.queryPatternsTimeseries(
    timeseriesPayload = TimeseriesPayload(
      metrics = Seq(
        FieldReference(
          kind = "searchesCount"
        )
      ),
      parameters = Seq(
        ParameterDefinition(
          kind = "indices",
          value = ParameterValue(Seq("index"))
        )
      )
    ),
    index = Some("index")
  ),
  Duration(100, "sec")
)

// print the response
println(response)

// Initialize the client
let client = try AnalyticsClient(appID: "ALGOLIA_APPLICATION_ID", apiKey: "ALGOLIA_API_KEY", region: .us)

// Call the API
let response = try await client.queryPatternsTimeseries(
    timeseriesPayload: TimeseriesPayload(
        metrics: [FieldReference(kind: "searchesCount")],
        parameters: [ParameterDefinition(
            kind: "indices",
            value: ParameterValue.arrayOfString(["index"])
        )]
    ),
    index: "index"
)

// print the response
print(response)

{
  "series": [
    {
      "dates": [
        {
          "date": "<string>",
          "metrics": {}
        }
      ],
      "totals": {},
      "key": {}
    }
  ]
}

{
  "message": "Invalid Application-Id or API-Key"
}

{
  "message": "Invalid Application-Id or API-Key"
}

{
  "message": "Invalid Application-Id or API-Key"
}

{
  "message": "Invalid Application-Id or API-Key"
}