curl --request POST \
  --url 'https://analytics.us.algolia.com/3/patterns/distribution?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",
  "distributions": [
    {
      "domain": "lorem",
      "kind": "clickPosition",
      "continuous": false,
      "bins": [
        1,
        2,
        3,
        4,
        5,
        6,
        7,
        8,
        9,
        10,
        11,
        21,
        -1
      ]
    }
  ],
  "filters": [
    {
      "domain": "lorem",
      "kind": "country",
      "operator": "=",
      "parameter": {
        "domain": "core",
        "kind": "country"
      }
    }
  ],
  "parameters": [
    {
      "domain": "lorem",
      "kind": "indices",
      "value": "lorem"
    }
  ]
}
'

// 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.QueryPatternsDistributionAsync(
  new DistributionPayload
  {
    Distributions = new List<DistributionDefinition>
    {
      new DistributionDefinition
      {
        Kind = "clickPosition",
        Bins = new List<BinEdge>
        {
          new BinEdge(1),
          new BinEdge(2),
          new BinEdge(3),
          new BinEdge(4),
          new BinEdge(5),
        },
      },
    },
    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.QueryPatternsDistribution(client.NewApiQueryPatternsDistributionRequest(

  analytics.NewEmptyDistributionPayload().SetDistributions(
    []analytics.DistributionDefinition{*analytics.NewEmptyDistributionDefinition().SetKind("clickPosition").SetBins(
      []analytics.BinEdge{*analytics.Int32AsBinEdge(1), *analytics.Int32AsBinEdge(2), *analytics.Int32AsBinEdge(3), *analytics.Int32AsBinEdge(4), *analytics.Int32AsBinEdge(5)})}).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
Map response = client.queryPatternsDistribution(
  new DistributionPayload()
    .setDistributions(
      Arrays.asList(
        new DistributionDefinition()
          .setKind("clickPosition")
          .setBins(Arrays.asList(BinEdge.of(1), BinEdge.of(2), BinEdge.of(3), BinEdge.of(4), BinEdge.of(5)))
      )
    )
    .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.queryPatternsDistribution({
  distributionPayload: {
    distributions: [{ kind: 'clickPosition', bins: [1, 2, 3, 4, 5] }],
    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.queryPatternsDistribution(
    distributionPayload =
      DistributionPayload(
        distributions =
          listOf(
            DistributionDefinition(
              kind = "clickPosition",
              bins =
                listOf(
                  BinEdge.of(1),
                  BinEdge.of(2),
                  BinEdge.of(3),
                  BinEdge.of(4),
                  BinEdge.of(5),
                ),
            )
          ),
        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->queryPatternsDistribution(
    ['distributions' => [
        ['kind' => 'clickPosition',
            'bins' => [
                1,

                2,

                3,

                4,

                5,
            ],
        ],
    ],
        '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_distribution(
    distribution_payload={
        "distributions": [
            {
                "kind": "clickPosition",
                "bins": [
                    1,
                    2,
                    3,
                    4,
                    5,
                ],
            },
        ],
        "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_distribution(
  Algolia::Analytics::DistributionPayload.new(
    distributions: [Algolia::Analytics::DistributionDefinition.new(kind: "clickPosition", bins: [1, 2, 3, 4, 5])],
    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.queryPatternsDistribution(
    distributionPayload = DistributionPayload(
      distributions = Seq(
        DistributionDefinition(
          kind = "clickPosition",
          bins = Seq(BinEdge(1), BinEdge(2), BinEdge(3), BinEdge(4), BinEdge(5))
        )
      ),
      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.queryPatternsDistribution(
    distributionPayload: DistributionPayload(distributions: [DistributionDefinition(
        kind: "clickPosition",
        bins: [BinEdge.int(1), BinEdge.int(2), BinEdge.int(3), BinEdge.int(4), BinEdge.int(5)]
    )], parameters: [ParameterDefinition(kind: "indices", value: ParameterValue.arrayOfString(["index"]))]),
    index: "index"
)

// print the response
print(response)

{}

{
  "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"
}