using Salad.Cloud.SDK;
using Salad.Cloud.SDK.Config;
using Salad.Cloud.SDK.Models;

var config = new SaladCloudSdkConfig{};

var client = new SaladCloudSdkClient(config);

var command = new List<string>() { "command" };
var axiom = new AxiomLoggingConfiguration("api_token", "dataset", "host");
var tagsItem = new DatadogTagForContainerLogging("name", "value");
var tags = new List<DatadogTagForContainerLogging>() { tagsItem };
var datadog = new DatadogLoggingConfiguration("api_key", "host", tags);
var headersItem = new ContainerLoggingHttpHeader("name", "value");
var headers = new List<ContainerLoggingHttpHeader>() { headersItem };
var http = new ContainerLoggingConfigurationHttp1(ContainerLoggingHttpCompression.None, ContainerLoggingHttpFormat.Json, headers, "host", 55354, "password", "path", "user");
var newRelic = new NewRelicLoggingConfiguration("host", "ingestion_key");
var splunk = new ContainerLoggingSplunkConfiguration("host", "token");
var tcp = new TcpLoggingConfiguration("host", 44671);
var logging = new UpdateContainerLogging(axiom, datadog, http, newRelic, splunk, tcp);
var awsEcr = new ContainerRegistryAuthenticationAwsEcr("access_key_id", "secret_access_key");
var basic = new ContainerRegistryAuthenticationBasic("password", "username");
var dockerHub = new ContainerRegistryAuthenticationDockerHub("personal_access_token", "username");
var gcpGar = new ContainerRegistryAuthenticationGcpGar("service_key");
var gcpGcr = new ContainerRegistryAuthenticationGcpGcr("service_key");
var registryAuthentication = new ContainerRegistryAuthentication(awsEcr, basic, dockerHub, gcpGar, gcpGcr);
var gpuClasses = new List<string>() { "gpu_classes" };
var resources = new ContainerResourceUpdateSchema(191, gpuClasses, 909130690, 64, 699558298076245);
var container = new UpdateContainer(command, new object(), "image", true, logging, ContainerGroupPriority.High, registryAuthentication, resources);
var countryCodes = new List<CountryCode>() { CountryCode.Af };
var command = new List<string>() { "command" };
var exec = new ContainerGroupProbeExec(command);
var grpc = new ContainerGroupGRpcProbe(37648, "service");
var headersItem = new ContainerGroupProbeHttpHeader("name", "value");
var headers = new List<ContainerGroupProbeHttpHeader>() { headersItem };
var http = new ContainerGroupHttpProbeConfiguration(headers, "path", 29069, HttpScheme.Http);
var tcp = new ContainerGroupTcpProbe(13817);
var livenessProbe = new ContainerGroupLivenessProbe(3, 670, 10, 1, 30, exec, grpc, http, tcp);
var networking = new UpdateContainerGroupNetworking(17025);
var queueAutoscaler = new QueueBasedAutoscalerConfiguration(53, 321, 54, 59, 100, 140);
var command = new List<string>() { "command" };
var exec = new ContainerGroupProbeExec(command);
var grpc = new ContainerGroupGRpcProbe(37648, "service");
var headersItem = new ContainerGroupProbeHttpHeader("name", "value");
var headers = new List<ContainerGroupProbeHttpHeader>() { headersItem };
var http = new ContainerGroupHttpProbeConfiguration(headers, "path", 29069, HttpScheme.Http);
var tcp = new ContainerGroupTcpProbe(13817);
var readinessProbe = new ContainerGroupReadinessProbe(3, 262, 1, 1, 1, exec, grpc, http, tcp);
var scalingActionsItem = new ContainerGroupScalingAction(461, "7kwC/T8C   da       x6Ci   bM-rgGYn     bDY6,vT");
var scalingActions = new List<ContainerGroupScalingAction>() { scalingActionsItem };
var command = new List<string>() { "command" };
var exec = new ContainerGroupProbeExec(command);
var grpc = new ContainerGroupGRpcProbe(37648, "service");
var headersItem = new ContainerGroupProbeHttpHeader("name", "value");
var headers = new List<ContainerGroupProbeHttpHeader>() { headersItem };
var http = new ContainerGroupHttpProbeConfiguration(headers, "path", 29069, HttpScheme.Http);
var tcp = new ContainerGroupTcpProbe(13817);
var startupProbe = new ContainerGroupStartupProbe(15, 503, 3, 2, 10, exec, grpc, http, tcp);
var input = new ContainerGroupPatch(container, countryCodes, "ykW8yoj HBQ", livenessProbe, networking, queueAutoscaler, readinessProbe, 102, scalingActions, true, startupProbe);

var response = await client.ContainerGroups.UpdateContainerGroupAsync(input, "acme-corp", "dev-env", "mandlebrot");

Console.WriteLine(response);

import com.salad.cloud.sdk.SaladCloudSdk;
import com.salad.cloud.sdk.config.ApiKeyAuthConfig;
import com.salad.cloud.sdk.config.SaladCloudSdkConfig;
import com.salad.cloud.sdk.models.AxiomLoggingConfiguration;
import com.salad.cloud.sdk.models.ContainerGroup;
import com.salad.cloud.sdk.models.ContainerGroupGRpcProbe;
import com.salad.cloud.sdk.models.ContainerGroupHttpProbeConfiguration;
import com.salad.cloud.sdk.models.ContainerGroupLivenessProbe;
import com.salad.cloud.sdk.models.ContainerGroupPatch;
import com.salad.cloud.sdk.models.ContainerGroupPriority;
import com.salad.cloud.sdk.models.ContainerGroupProbeExec;
import com.salad.cloud.sdk.models.ContainerGroupProbeHttpHeader;
import com.salad.cloud.sdk.models.ContainerGroupReadinessProbe;
import com.salad.cloud.sdk.models.ContainerGroupScalingAction;
import com.salad.cloud.sdk.models.ContainerGroupStartupProbe;
import com.salad.cloud.sdk.models.ContainerGroupTcpProbe;
import com.salad.cloud.sdk.models.ContainerLoggingConfigurationHttp1;
import com.salad.cloud.sdk.models.ContainerLoggingHttpCompression;
import com.salad.cloud.sdk.models.ContainerLoggingHttpFormat;
import com.salad.cloud.sdk.models.ContainerLoggingHttpHeader;
import com.salad.cloud.sdk.models.ContainerLoggingSplunkConfiguration;
import com.salad.cloud.sdk.models.ContainerRegistryAuthentication;
import com.salad.cloud.sdk.models.ContainerRegistryAuthenticationAwsEcr;
import com.salad.cloud.sdk.models.ContainerRegistryAuthenticationBasic;
import com.salad.cloud.sdk.models.ContainerRegistryAuthenticationDockerHub;
import com.salad.cloud.sdk.models.ContainerRegistryAuthenticationGcpGar;
import com.salad.cloud.sdk.models.ContainerRegistryAuthenticationGcpGcr;
import com.salad.cloud.sdk.models.ContainerResourceUpdateSchema;
import com.salad.cloud.sdk.models.CountryCode;
import com.salad.cloud.sdk.models.DatadogLoggingConfiguration;
import com.salad.cloud.sdk.models.DatadogTagForContainerLogging;
import com.salad.cloud.sdk.models.HttpScheme;
import com.salad.cloud.sdk.models.NewRelicLoggingConfiguration;
import com.salad.cloud.sdk.models.QueueBasedAutoscalerConfiguration;
import com.salad.cloud.sdk.models.TcpLoggingConfiguration;
import com.salad.cloud.sdk.models.UpdateContainer;
import com.salad.cloud.sdk.models.UpdateContainerGroupNetworking;
import com.salad.cloud.sdk.models.UpdateContainerLogging;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;

public class Main {

  public static void main(String[] args) {
    SaladCloudSdkConfig config = SaladCloudSdkConfig.builder()
      .apiKeyAuthConfig(ApiKeyAuthConfig.builder().apiKey("YOUR_API_KEY").build())
      .build();

    SaladCloudSdk saladCloudSdk = new SaladCloudSdk(config);

    List<String> commandList = Arrays.asList("command");

    AxiomLoggingConfiguration axiomLoggingConfiguration = AxiomLoggingConfiguration.builder()
      .apiToken("api_token")
      .dataset("dataset")
      .host("host")
      .build();

    DatadogTagForContainerLogging datadogTagForContainerLogging = DatadogTagForContainerLogging.builder()
      .name("name")
      .value("value")
      .build();

    List<DatadogTagForContainerLogging> tagsList = Arrays.asList(datadogTagForContainerLogging);

    DatadogLoggingConfiguration datadogLoggingConfiguration = DatadogLoggingConfiguration.builder()
      .apiKey("api_key")
      .host("host")
      .tags(tagsList)
      .build();

    ContainerLoggingHttpHeader containerLoggingHttpHeader = ContainerLoggingHttpHeader.builder()
      .name("name")
      .value("value")
      .build();

    List<ContainerLoggingHttpHeader> headersList = Arrays.asList(containerLoggingHttpHeader);

    ContainerLoggingConfigurationHttp1 containerLoggingConfigurationHttp1 = ContainerLoggingConfigurationHttp1.builder()
      .compression(ContainerLoggingHttpCompression.NONE)
      .format(ContainerLoggingHttpFormat.JSON)
      .headers(headersList)
      .host("host")
      .password("password")
      .path("path")
      .port(55354L)
      .user("user")
      .build();

    NewRelicLoggingConfiguration newRelicLoggingConfiguration = NewRelicLoggingConfiguration.builder()
      .host("host")
      .ingestionKey("ingestion_key")
      .build();

    ContainerLoggingSplunkConfiguration containerLoggingSplunkConfiguration =
      ContainerLoggingSplunkConfiguration.builder().host("host").token("token").build();

    TcpLoggingConfiguration tcpLoggingConfiguration = TcpLoggingConfiguration.builder()
      .host("host")
      .port(44671L)
      .build();

    UpdateContainerLogging updateContainerLogging = UpdateContainerLogging.builder()
      .axiom(axiomLoggingConfiguration)
      .datadog(datadogLoggingConfiguration)
      .http(containerLoggingConfigurationHttp1)
      .newRelic(newRelicLoggingConfiguration)
      .splunk(containerLoggingSplunkConfiguration)
      .tcp(tcpLoggingConfiguration)
      .build();

    ContainerRegistryAuthenticationAwsEcr containerRegistryAuthenticationAwsEcr =
      ContainerRegistryAuthenticationAwsEcr.builder()
        .accessKeyId("access_key_id")
        .secretAccessKey("secret_access_key")
        .build();

    ContainerRegistryAuthenticationBasic containerRegistryAuthenticationBasic =
      ContainerRegistryAuthenticationBasic.builder().password("password").username("username").build();

    ContainerRegistryAuthenticationDockerHub containerRegistryAuthenticationDockerHub =
      ContainerRegistryAuthenticationDockerHub.builder()
        .personalAccessToken("personal_access_token")
        .username("username")
        .build();

    ContainerRegistryAuthenticationGcpGar containerRegistryAuthenticationGcpGar =
      ContainerRegistryAuthenticationGcpGar.builder().serviceKey("service_key").build();

    ContainerRegistryAuthenticationGcpGcr containerRegistryAuthenticationGcpGcr =
      ContainerRegistryAuthenticationGcpGcr.builder().serviceKey("service_key").build();

    ContainerRegistryAuthentication containerRegistryAuthentication = ContainerRegistryAuthentication.builder()
      .awsEcr(containerRegistryAuthenticationAwsEcr)
      .basic(containerRegistryAuthenticationBasic)
      .dockerHub(containerRegistryAuthenticationDockerHub)
      .gcpGar(containerRegistryAuthenticationGcpGar)
      .gcpGcr(containerRegistryAuthenticationGcpGcr)
      .build();

    List<String> gpuClassesList = Arrays.asList("gpu_classes");

    ContainerResourceUpdateSchema containerResourceUpdateSchema = ContainerResourceUpdateSchema.builder()
      .cpu(191L)
      .gpuClasses(gpuClassesList)
      .memory(909130690L)
      .shmSize(64L)
      .storageAmount(699558298076245L)
      .build();

    UpdateContainer updateContainer = UpdateContainer.builder()
      .command(commandList)
      .environmentVariables(new HashMap())
      .image("image")
      .imageCaching(true)
      .logging(updateContainerLogging)
      .priority(ContainerGroupPriority.HIGH)
      .registryAuthentication(containerRegistryAuthentication)
      .resources(containerResourceUpdateSchema)
      .build();

    List<CountryCode> countryCodesList = Arrays.asList(CountryCode.AF);

    List<String> commandList1 = Arrays.asList("command");

    ContainerGroupProbeExec containerGroupProbeExec = ContainerGroupProbeExec.builder().command(commandList1).build();

    ContainerGroupGRpcProbe containerGroupGRpcProbe = ContainerGroupGRpcProbe.builder()
      .port(37648L)
      .service("service")
      .build();

    ContainerGroupProbeHttpHeader containerGroupProbeHttpHeader = ContainerGroupProbeHttpHeader.builder()
      .name("name")
      .value("value")
      .build();

    List<ContainerGroupProbeHttpHeader> headersList1 = Arrays.asList(containerGroupProbeHttpHeader);

    ContainerGroupHttpProbeConfiguration containerGroupHttpProbeConfiguration =
      ContainerGroupHttpProbeConfiguration.builder()
        .headers(headersList1)
        .path("path")
        .port(29069L)
        .scheme(HttpScheme.HTTP)
        .build();

    ContainerGroupTcpProbe containerGroupTcpProbe = ContainerGroupTcpProbe.builder().port(13817L).build();

    ContainerGroupLivenessProbe containerGroupLivenessProbe = ContainerGroupLivenessProbe.builder()
      .exec(containerGroupProbeExec)
      .failureThreshold(3L)
      .grpc(containerGroupGRpcProbe)
      .http(containerGroupHttpProbeConfiguration)
      .initialDelaySeconds(670L)
      .periodSeconds(10L)
      .successThreshold(1L)
      .tcp(containerGroupTcpProbe)
      .timeoutSeconds(30L)
      .build();

    UpdateContainerGroupNetworking updateContainerGroupNetworking = UpdateContainerGroupNetworking.builder()
      .port(17025L)
      .build();

    QueueBasedAutoscalerConfiguration queueBasedAutoscalerConfiguration = QueueBasedAutoscalerConfiguration.builder()
      .desiredQueueLength(53L)
      .maxDownscalePerMinute(59L)
      .maxReplicas(321L)
      .maxUpscalePerMinute(100L)
      .minReplicas(54L)
      .pollingPeriod(140L)
      .build();

    ContainerGroupReadinessProbe containerGroupReadinessProbe = ContainerGroupReadinessProbe.builder()
      .exec(containerGroupProbeExec)
      .failureThreshold(3L)
      .grpc(containerGroupGRpcProbe)
      .http(containerGroupHttpProbeConfiguration)
      .initialDelaySeconds(262L)
      .periodSeconds(1L)
      .successThreshold(1L)
      .tcp(containerGroupTcpProbe)
      .timeoutSeconds(1L)
      .build();

    ContainerGroupScalingAction containerGroupScalingAction = ContainerGroupScalingAction.builder()
      .replicas(461L)
      .schedule("7kwC/T8C   da       x6Ci   bM-rgGYn     bDY6,vT")
      .build();

    List<ContainerGroupScalingAction> scalingActionsList = Arrays.asList(containerGroupScalingAction);

    ContainerGroupStartupProbe containerGroupStartupProbe = ContainerGroupStartupProbe.builder()
      .exec(containerGroupProbeExec)
      .failureThreshold(15L)
      .grpc(containerGroupGRpcProbe)
      .http(containerGroupHttpProbeConfiguration)
      .initialDelaySeconds(503L)
      .periodSeconds(3L)
      .successThreshold(2L)
      .tcp(containerGroupTcpProbe)
      .timeoutSeconds(10L)
      .build();

    ContainerGroupPatch containerGroupPatch = ContainerGroupPatch.builder()
      .container(updateContainer)
      .countryCodes(countryCodesList)
      .displayName("ykW8yoj HBQ")
      .livenessProbe(containerGroupLivenessProbe)
      .networking(updateContainerGroupNetworking)
      .queueAutoscaler(queueBasedAutoscalerConfiguration)
      .readinessProbe(containerGroupReadinessProbe)
      .replicas(102L)
      .scalingActions(scalingActionsList)
      .scheduledScalingEnabled(true)
      .startupProbe(containerGroupStartupProbe)
      .build();

    ContainerGroup response = saladCloudSdk.containerGroups.updateContainerGroup(
      "acme-corp",
      "dev-env",
      "mandlebrot",
      containerGroupPatch
    );

    System.out.println(response);
  }
}

import (
  "fmt"
  "encoding/json"
  "context"
  "github.com/saladtechnologies/salad-cloud-sdk-go/pkg/saladcloudsdkconfig"
  "github.com/saladtechnologies/salad-cloud-sdk-go/pkg/saladcloudsdk"
  "github.com/saladtechnologies/salad-cloud-sdk-go/pkg/util"
  "github.com/saladtechnologies/salad-cloud-sdk-go/pkg/containergroups"
)

config := saladcloudsdkconfig.NewConfig()
config.SetApiKey("API_KEY")
client := saladcloudsdk.NewSaladCloudSdk(config)


axiomLoggingConfiguration := shared.AxiomLoggingConfiguration{
  ApiToken: util.ToPointer("api_token"),
  Dataset: util.ToPointer("dataset"),
  Host: util.ToPointer("host"),
}


datadogTagForContainerLogging := shared.DatadogTagForContainerLogging{
  Name: util.ToPointer("name"),
  Value: util.ToPointer("value"),
}

datadogLoggingConfiguration := shared.DatadogLoggingConfiguration{
  ApiKey: util.ToPointer("api_key"),
  Host: util.ToPointer("host"),
  Tags: []shared.DatadogTagForContainerLogging{datadogTagForContainerLogging},
}

containerLoggingHttpCompression := shared.CONTAINER_LOGGING_HTTP_COMPRESSION_NONE

containerLoggingHttpFormat := shared.CONTAINER_LOGGING_HTTP_FORMAT_JSON


containerLoggingHttpHeader := shared.ContainerLoggingHttpHeader{
  Name: util.ToPointer("name"),
  Value: util.ToPointer("value"),
}

containerLoggingConfigurationHttp1 := shared.ContainerLoggingConfigurationHttp1{
  Compression: &containerLoggingHttpCompression,
  Format: &containerLoggingHttpFormat,
  Headers: []shared.ContainerLoggingHttpHeader{containerLoggingHttpHeader},
  Host: util.ToPointer("host"),
  Password: util.ToPointer(util.Nullable[string]{ Value: "password" }),
  Path: util.ToPointer(util.Nullable[string]{ Value: "path" }),
  Port: util.ToPointer(int64(55354)),
  User: util.ToPointer(util.Nullable[string]{ Value: "user" }),
}


newRelicLoggingConfiguration := shared.NewRelicLoggingConfiguration{
  Host: util.ToPointer("host"),
  IngestionKey: util.ToPointer("ingestion_key"),
}


containerLoggingSplunkConfiguration := shared.ContainerLoggingSplunkConfiguration{
  Host: util.ToPointer("host"),
  Token: util.ToPointer("token"),
}


tcpLoggingConfiguration := shared.TcpLoggingConfiguration{
  Host: util.ToPointer("host"),
  Port: util.ToPointer(int64(44671)),
}

updateContainerLogging := containergroups.UpdateContainerLogging{
  Axiom: &axiomLoggingConfiguration,
  Datadog: &datadogLoggingConfiguration,
  Http: &containerLoggingConfigurationHttp1,
  NewRelic: &newRelicLoggingConfiguration,
  Splunk: &containerLoggingSplunkConfiguration,
  Tcp: &tcpLoggingConfiguration,
}

containerGroupPriority := shared.CONTAINER_GROUP_PRIORITY_HIGH


containerRegistryAuthenticationAwsEcr := containergroups.ContainerRegistryAuthenticationAwsEcr{
  AccessKeyId: util.ToPointer("access_key_id"),
  SecretAccessKey: util.ToPointer("secret_access_key"),
}


containerRegistryAuthenticationBasic := containergroups.ContainerRegistryAuthenticationBasic{
  Password: util.ToPointer("password"),
  Username: util.ToPointer("username"),
}


containerRegistryAuthenticationDockerHub := containergroups.ContainerRegistryAuthenticationDockerHub{
  PersonalAccessToken: util.ToPointer("personal_access_token"),
  Username: util.ToPointer("username"),
}


containerRegistryAuthenticationGcpGar := containergroups.ContainerRegistryAuthenticationGcpGar{
  ServiceKey: util.ToPointer("service_key"),
}


containerRegistryAuthenticationGcpGcr := containergroups.ContainerRegistryAuthenticationGcpGcr{
  ServiceKey: util.ToPointer("service_key"),
}

containerRegistryAuthentication := containergroups.ContainerRegistryAuthentication{
  AwsEcr: &containerRegistryAuthenticationAwsEcr,
  Basic: &containerRegistryAuthenticationBasic,
  DockerHub: &containerRegistryAuthenticationDockerHub,
  GcpGar: &containerRegistryAuthenticationGcpGar,
  GcpGcr: &containerRegistryAuthenticationGcpGcr,
}


containerResourceUpdateSchema := containergroups.ContainerResourceUpdateSchema{
  Cpu: util.ToPointer(util.Nullable[int64]{ Value: int64(191) }),
  GpuClasses: []string{},
  Memory: util.ToPointer(util.Nullable[int64]{ Value: int64(909130690) }),
  ShmSize: util.ToPointer(util.Nullable[int64]{ Value: int64(64) }),
  StorageAmount: util.ToPointer(util.Nullable[int64]{ Value: int64(699558298076245) }),
}

updateContainer := containergroups.UpdateContainer{
  Command: []string{},
  EnvironmentVariables: map[string]string{},
  Image: util.ToPointer(util.Nullable[string]{ Value: "image" }),
  ImageCaching: util.ToPointer(true),
  Logging: &updateContainerLogging,
  Priority: &containerGroupPriority,
  RegistryAuthentication: &containerRegistryAuthentication,
  Resources: &containerResourceUpdateSchema,
}

countryCode := shared.COUNTRY_CODE_AF


containerGroupProbeExec := shared.ContainerGroupProbeExec{
  Command: []string{},
}


containerGroupGRpcProbe := shared.ContainerGroupGRpcProbe{
  Port: util.ToPointer(int64(37648)),
  Service: util.ToPointer("service"),
}


containerGroupProbeHttpHeader := shared.ContainerGroupProbeHttpHeader{
  Name: util.ToPointer("name"),
  Value: util.ToPointer("value"),
}

httpScheme := shared.HTTP_SCHEME_HTTP

containerGroupHttpProbeConfiguration := shared.ContainerGroupHttpProbeConfiguration{
  Headers: []shared.ContainerGroupProbeHttpHeader{containerGroupProbeHttpHeader},
  Path: util.ToPointer("path"),
  Port: util.ToPointer(int64(29069)),
  Scheme: &httpScheme,
}


containerGroupTcpProbe := shared.ContainerGroupTcpProbe{
  Port: util.ToPointer(int64(13817)),
}

containerGroupLivenessProbe := shared.ContainerGroupLivenessProbe{
  Exec: &containerGroupProbeExec,
  FailureThreshold: util.ToPointer(int64(3)),
  Grpc: &containerGroupGRpcProbe,
  Http: &containerGroupHttpProbeConfiguration,
  InitialDelaySeconds: util.ToPointer(int64(670)),
  PeriodSeconds: util.ToPointer(int64(10)),
  SuccessThreshold: util.ToPointer(int64(1)),
  Tcp: &containerGroupTcpProbe,
  TimeoutSeconds: util.ToPointer(int64(30)),
}


updateContainerGroupNetworking := containergroups.UpdateContainerGroupNetworking{
  Port: util.ToPointer(util.Nullable[int64]{ Value: int64(17025) }),
}


queueBasedAutoscalerConfiguration := shared.QueueBasedAutoscalerConfiguration{
  DesiredQueueLength: util.ToPointer(int64(53)),
  MaxDownscalePerMinute: util.ToPointer(int64(59)),
  MaxReplicas: util.ToPointer(int64(321)),
  MaxUpscalePerMinute: util.ToPointer(int64(100)),
  MinReplicas: util.ToPointer(int64(54)),
  PollingPeriod: util.ToPointer(int64(140)),
}


containerGroupProbeExec := shared.ContainerGroupProbeExec{
  Command: []string{},
}


containerGroupGRpcProbe := shared.ContainerGroupGRpcProbe{
  Port: util.ToPointer(int64(37648)),
  Service: util.ToPointer("service"),
}


containerGroupProbeHttpHeader := shared.ContainerGroupProbeHttpHeader{
  Name: util.ToPointer("name"),
  Value: util.ToPointer("value"),
}

httpScheme := shared.HTTP_SCHEME_HTTP

containerGroupHttpProbeConfiguration := shared.ContainerGroupHttpProbeConfiguration{
  Headers: []shared.ContainerGroupProbeHttpHeader{containerGroupProbeHttpHeader},
  Path: util.ToPointer("path"),
  Port: util.ToPointer(int64(29069)),
  Scheme: &httpScheme,
}


containerGroupTcpProbe := shared.ContainerGroupTcpProbe{
  Port: util.ToPointer(int64(13817)),
}

containerGroupReadinessProbe := shared.ContainerGroupReadinessProbe{
  Exec: &containerGroupProbeExec,
  FailureThreshold: util.ToPointer(int64(3)),
  Grpc: &containerGroupGRpcProbe,
  Http: &containerGroupHttpProbeConfiguration,
  InitialDelaySeconds: util.ToPointer(int64(262)),
  PeriodSeconds: util.ToPointer(int64(1)),
  SuccessThreshold: util.ToPointer(int64(1)),
  Tcp: &containerGroupTcpProbe,
  TimeoutSeconds: util.ToPointer(int64(1)),
}


containerGroupScalingAction := shared.ContainerGroupScalingAction{
  Replicas: util.ToPointer(int64(461)),
  Schedule: util.ToPointer("7kwC/T8C   da       x6Ci   bM-rgGYn     bDY6,vT"),
}


containerGroupProbeExec := shared.ContainerGroupProbeExec{
  Command: []string{},
}


containerGroupGRpcProbe := shared.ContainerGroupGRpcProbe{
  Port: util.ToPointer(int64(37648)),
  Service: util.ToPointer("service"),
}


containerGroupProbeHttpHeader := shared.ContainerGroupProbeHttpHeader{
  Name: util.ToPointer("name"),
  Value: util.ToPointer("value"),
}

httpScheme := shared.HTTP_SCHEME_HTTP

containerGroupHttpProbeConfiguration := shared.ContainerGroupHttpProbeConfiguration{
  Headers: []shared.ContainerGroupProbeHttpHeader{containerGroupProbeHttpHeader},
  Path: util.ToPointer("path"),
  Port: util.ToPointer(int64(29069)),
  Scheme: &httpScheme,
}


containerGroupTcpProbe := shared.ContainerGroupTcpProbe{
  Port: util.ToPointer(int64(13817)),
}

containerGroupStartupProbe := shared.ContainerGroupStartupProbe{
  Exec: &containerGroupProbeExec,
  FailureThreshold: util.ToPointer(int64(15)),
  Grpc: &containerGroupGRpcProbe,
  Http: &containerGroupHttpProbeConfiguration,
  InitialDelaySeconds: util.ToPointer(int64(503)),
  PeriodSeconds: util.ToPointer(int64(3)),
  SuccessThreshold: util.ToPointer(int64(2)),
  Tcp: &containerGroupTcpProbe,
  TimeoutSeconds: util.ToPointer(int64(10)),
}

request := containergroups.ContainerGroupPatch{
  Container: &updateContainer,
  CountryCodes: []shared.CountryCode{countryCode},
  DisplayName: util.ToPointer(util.Nullable[string]{ Value: "ykW8yoj HBQ" }),
  LivenessProbe: &containerGroupLivenessProbe,
  Networking: &updateContainerGroupNetworking,
  QueueAutoscaler: &queueBasedAutoscalerConfiguration,
  ReadinessProbe: &containerGroupReadinessProbe,
  Replicas: util.ToPointer(util.Nullable[int64]{ Value: int64(102) }),
  ScalingActions: []shared.ContainerGroupScalingAction{containerGroupScalingAction},
  ScheduledScalingEnabled: util.ToPointer(true),
  StartupProbe: &containerGroupStartupProbe,
}

response, err := client.ContainerGroups.UpdateContainerGroup(context.Background(), "acme-corp", "dev-env", "mandlebrot", request)
if err != nil {
  panic(err)
}

fmt.Println(response)

import {
  AxiomLoggingConfiguration,
  ContainerGroupGRpcProbe,
  ContainerGroupHttpProbeConfiguration,
  ContainerGroupLivenessProbe,
  ContainerGroupPatch,
  ContainerGroupPriority,
  ContainerGroupProbeExec,
  ContainerGroupProbeHttpHeader,
  ContainerGroupReadinessProbe,
  ContainerGroupScalingAction,
  ContainerGroupStartupProbe,
  ContainerGroupTcpProbe,
  ContainerLoggingConfigurationHttp1,
  ContainerLoggingHttpCompression,
  ContainerLoggingHttpFormat,
  ContainerLoggingHttpHeader,
  ContainerLoggingSplunkConfiguration,
  ContainerRegistryAuthentication,
  ContainerRegistryAuthenticationAwsEcr,
  ContainerRegistryAuthenticationBasic,
  ContainerRegistryAuthenticationDockerHub,
  ContainerRegistryAuthenticationGcpGar,
  ContainerRegistryAuthenticationGcpGcr,
  ContainerResourceUpdateSchema,
  CountryCode,
  DatadogLoggingConfiguration,
  DatadogTagForContainerLogging,
  HttpScheme,
  NewRelicLoggingConfiguration,
  QueueBasedAutoscalerConfiguration,
  SaladCloudSdk,
  TcpLoggingConfiguration,
  UpdateContainer,
  UpdateContainerGroupNetworking,
  UpdateContainerLogging,
} from '@saladtechnologies-oss/salad-cloud-sdk';

(async () => {
  const saladCloudSdk = new SaladCloudSdk({
    apiKey: 'YOUR_API_KEY',
  });

  const axiomLoggingConfiguration: AxiomLoggingConfiguration = {
    apiToken: 'api_token',
    dataset: 'dataset',
    host: 'host',
  };

  const datadogTagForContainerLogging: DatadogTagForContainerLogging = {
    name: 'name',
    value: 'value',
  };

  const datadogLoggingConfiguration: DatadogLoggingConfiguration = {
    apiKey: 'api_key',
    host: 'host',
    tags: [datadogTagForContainerLogging],
  };

  const containerLoggingHttpCompression = ContainerLoggingHttpCompression.NONE;

  const containerLoggingHttpFormat = ContainerLoggingHttpFormat.JSON;

  const containerLoggingHttpHeader: ContainerLoggingHttpHeader = {
    name: 'name',
    value: 'value',
  };

  const containerLoggingConfigurationHttp1: ContainerLoggingConfigurationHttp1 = {
    compression: containerLoggingHttpCompression,
    format: containerLoggingHttpFormat,
    headers: [containerLoggingHttpHeader],
    host: 'host',
    password: 'password',
    path: 'path',
    port: 55354,
    user: 'user',
  };

  const newRelicLoggingConfiguration: NewRelicLoggingConfiguration = {
    host: 'host',
    ingestionKey: 'ingestion_key',
  };

  const containerLoggingSplunkConfiguration: ContainerLoggingSplunkConfiguration = {
    host: 'host',
    token: 'token',
  };

  const tcpLoggingConfiguration: TcpLoggingConfiguration = {
    host: 'host',
    port: 44671,
  };

  const updateContainerLogging: UpdateContainerLogging = {
    axiom: axiomLoggingConfiguration,
    datadog: datadogLoggingConfiguration,
    http: containerLoggingConfigurationHttp1,
    newRelic: newRelicLoggingConfiguration,
    splunk: containerLoggingSplunkConfiguration,
    tcp: tcpLoggingConfiguration,
  };

  const containerGroupPriority = ContainerGroupPriority.HIGH;

  const containerRegistryAuthenticationAwsEcr: ContainerRegistryAuthenticationAwsEcr = {
    accessKeyId: 'access_key_id',
    secretAccessKey: 'secret_access_key',
  };

  const containerRegistryAuthenticationBasic: ContainerRegistryAuthenticationBasic = {
    password: 'password',
    username: 'username',
  };

  const containerRegistryAuthenticationDockerHub: ContainerRegistryAuthenticationDockerHub = {
    personalAccessToken: 'personal_access_token',
    username: 'username',
  };

  const containerRegistryAuthenticationGcpGar: ContainerRegistryAuthenticationGcpGar = {
    serviceKey: 'service_key',
  };

  const containerRegistryAuthenticationGcpGcr: ContainerRegistryAuthenticationGcpGcr = {
    serviceKey: 'service_key',
  };

  const containerRegistryAuthentication: ContainerRegistryAuthentication = {
    awsEcr: containerRegistryAuthenticationAwsEcr,
    basic: containerRegistryAuthenticationBasic,
    dockerHub: containerRegistryAuthenticationDockerHub,
    gcpGar: containerRegistryAuthenticationGcpGar,
    gcpGcr: containerRegistryAuthenticationGcpGcr,
  };

  const containerResourceUpdateSchema: ContainerResourceUpdateSchema = {
    cpu: 191,
    gpuClasses: ['gpu_classes'],
    memory: 909130690,
    shmSize: 64,
    storageAmount: 699558298076245,
  };

  const updateContainer: UpdateContainer = {
    command: ['command'],
    environmentVariables: [],
    image: 'image',
    imageCaching: true,
    logging: updateContainerLogging,
    priority: containerGroupPriority,
    registryAuthentication: containerRegistryAuthentication,
    resources: containerResourceUpdateSchema,
  };

  const countryCode = CountryCode.AF;

  const containerGroupProbeExec: ContainerGroupProbeExec = {
    command: ['command'],
  };

  const containerGroupGRpcProbe: ContainerGroupGRpcProbe = {
    port: 37648,
    service: 'service',
  };

  const containerGroupProbeHttpHeader: ContainerGroupProbeHttpHeader = {
    name: 'name',
    value: 'value',
  };

  const httpScheme = HttpScheme.HTTP;

  const containerGroupHttpProbeConfiguration: ContainerGroupHttpProbeConfiguration = {
    headers: [containerGroupProbeHttpHeader],
    path: 'path',
    port: 29069,
    scheme: httpScheme,
  };

  const containerGroupTcpProbe: ContainerGroupTcpProbe = {
    port: 13817,
  };

  const containerGroupLivenessProbe: ContainerGroupLivenessProbe = {
    exec: containerGroupProbeExec,
    failureThreshold: 3,
    grpc: containerGroupGRpcProbe,
    http: containerGroupHttpProbeConfiguration,
    initialDelaySeconds: 670,
    periodSeconds: 10,
    successThreshold: 1,
    tcp: containerGroupTcpProbe,
    timeoutSeconds: 30,
  };

  const updateContainerGroupNetworking: UpdateContainerGroupNetworking = {
    port: 17025,
  };

  const queueBasedAutoscalerConfiguration: QueueBasedAutoscalerConfiguration = {
    desiredQueueLength: 53,
    maxDownscalePerMinute: 59,
    maxReplicas: 321,
    maxUpscalePerMinute: 100,
    minReplicas: 54,
    pollingPeriod: 140,
  };

  const containerGroupReadinessProbe: ContainerGroupReadinessProbe = {
    exec: containerGroupProbeExec,
    failureThreshold: 3,
    grpc: containerGroupGRpcProbe,
    http: containerGroupHttpProbeConfiguration,
    initialDelaySeconds: 262,
    periodSeconds: 1,
    successThreshold: 1,
    tcp: containerGroupTcpProbe,
    timeoutSeconds: 1,
  };

  const containerGroupScalingAction: ContainerGroupScalingAction = {
    replicas: 461,
    schedule: '7kwC/T8C   da       x6Ci   bM-rgGYn     bDY6,vT',
  };

  const containerGroupStartupProbe: ContainerGroupStartupProbe = {
    exec: containerGroupProbeExec,
    failureThreshold: 15,
    grpc: containerGroupGRpcProbe,
    http: containerGroupHttpProbeConfiguration,
    initialDelaySeconds: 503,
    periodSeconds: 3,
    successThreshold: 2,
    tcp: containerGroupTcpProbe,
    timeoutSeconds: 10,
  };

  const containerGroupPatch: ContainerGroupPatch = {
    container: updateContainer,
    countryCodes: [countryCode],
    displayName: 'ykW8yoj HBQ',
    livenessProbe: containerGroupLivenessProbe,
    networking: updateContainerGroupNetworking,
    queueAutoscaler: queueBasedAutoscalerConfiguration,
    readinessProbe: containerGroupReadinessProbe,
    replicas: 102,
    scalingActions: [containerGroupScalingAction],
    scheduledScalingEnabled: true,
    startupProbe: containerGroupStartupProbe,
  };

  const { data } = await saladCloudSdk.containerGroups.updateContainerGroup(
    'acme-corp',
    'dev-env',
    'mandlebrot',
    containerGroupPatch,
  );

  console.log(data);
})();

from salad_cloud_sdk import SaladCloudSdk
from salad_cloud_sdk.models import ContainerGroupPatch

sdk = SaladCloudSdk(
    api_key="YOUR_API_KEY",
    api_key_header="YOUR_API_KEY_HEADER",
    timeout=10000
)

request_body = ContainerGroupPatch(
    container={
        "command": [
            "command"
        ],
        "environment_variables": {},
        "image": "image",
        "image_caching": True,
        "logging": {
            "axiom": {
                "api_token": "api_token",
                "dataset": "dataset",
                "host": "host"
            },
            "datadog": {
                "api_key": "api_key",
                "host": "host",
                "tags": [
                    {
                        "name": "name",
                        "value": "value"
                    }
                ]
            },
            "http": {
                "compression": "none",
                "format": "json",
                "headers": [
                    {
                        "name": "name",
                        "value": "value"
                    }
                ],
                "host": "host",
                "password": "password",
                "path": "path",
                "port": 55354,
                "user": "user"
            },
            "new_relic": {
                "host": "host",
                "ingestion_key": "ingestion_key"
            },
            "splunk": {
                "host": "host",
                "token": "token"
            },
            "tcp": {
                "host": "host",
                "port": 44671
            }
        },
        "priority": "high",
        "registry_authentication": {
            "aws_ecr": {
                "access_key_id": "access_key_id",
                "secret_access_key": "secret_access_key"
            },
            "basic": {
                "password": "password",
                "username": "username"
            },
            "docker_hub": {
                "personal_access_token": "personal_access_token",
                "username": "username"
            },
            "gcp_gar": {
                "service_key": "service_key"
            },
            "gcp_gcr": {
                "service_key": "service_key"
            }
        },
        "resources": {
            "cpu": 191,
            "gpu_classes": [
                "gpu_classes"
            ],
            "memory": 909130690,
            "shm_size": 64,
            "storage_amount": 699558298076245
        }
    },
    country_codes=[
        "af"
    ],
    display_name="ykW8yoj HBQ",
    liveness_probe={
        "exec_": {
            "command": [
                "command"
            ]
        },
        "failure_threshold": 3,
        "grpc": {
            "port": 37648,
            "service": "service"
        },
        "http": {
            "headers": [
                {
                    "name": "name",
                    "value": "value"
                }
            ],
            "path": "path",
            "port": 29069,
            "scheme": "http"
        },
        "initial_delay_seconds": 670,
        "period_seconds": 10,
        "success_threshold": 1,
        "tcp": {
            "port": 13817
        },
        "timeout_seconds": 30
    },
    networking={
        "port": 17025
    },
    queue_autoscaler={
        "desired_queue_length": 53,
        "max_downscale_per_minute": 59,
        "max_replicas": 321,
        "max_upscale_per_minute": 100,
        "min_replicas": 54,
        "polling_period": 140
    },
    readiness_probe={
        "exec_": {
            "command": [
                "command"
            ]
        },
        "failure_threshold": 3,
        "grpc": {
            "port": 37648,
            "service": "service"
        },
        "http": {
            "headers": [
                {
                    "name": "name",
                    "value": "value"
                }
            ],
            "path": "path",
            "port": 29069,
            "scheme": "http"
        },
        "initial_delay_seconds": 262,
        "period_seconds": 1,
        "success_threshold": 1,
        "tcp": {
            "port": 13817
        },
        "timeout_seconds": 1
    },
    replicas=102,
    scaling_actions=[
        {
            "replicas": 461,
            "schedule": "7kwC/T8C   da       x6Ci   bM-rgGYn     bDY6,vT"
        }
    ],
    scheduled_scaling_enabled=True,
    startup_probe={
        "exec_": {
            "command": [
                "command"
            ]
        },
        "failure_threshold": 15,
        "grpc": {
            "port": 37648,
            "service": "service"
        },
        "http": {
            "headers": [
                {
                    "name": "name",
                    "value": "value"
                }
            ],
            "path": "path",
            "port": 29069,
            "scheme": "http"
        },
        "initial_delay_seconds": 503,
        "period_seconds": 3,
        "success_threshold": 2,
        "tcp": {
            "port": 13817
        },
        "timeout_seconds": 10
    }
)

result = sdk.container_groups.update_container_group(
    request_body=request_body,
    organization_name="acme-corp",
    project_name="dev-env",
    container_group_name="mandlebrot"
)

print(result)

curl --request PATCH \
  --url https://api.salad.com/api/public/organizations/{organization_name}/projects/{project_name}/containers/{container_group_name} \
  --header 'Content-Type: application/merge-patch+json' \
  --header 'Salad-Api-Key: <api-key>' \
  --data '
{
  "container": {
    "command": [
      "<string>"
    ],
    "environment_variables": {},
    "image": "<string>",
    "image_caching": true,
    "logging": {},
    "registry_authentication": {
      "aws_ecr": {
        "access_key_id": "<string>",
        "secret_access_key": "<string>"
      }
    },
    "resources": {
      "cpu": 512,
      "gpu_classes": [
        "3c90c3cc-0d44-4b50-8888-8dd25736052a"
      ],
      "memory": 536871424,
      "shm_size": 64,
      "storage_amount": 562950490292224
    }
  },
  "country_codes": [
    "us"
  ],
  "display_name": "<string>",
  "liveness_probe": {
    "failure_threshold": 3,
    "initial_delay_seconds": 0,
    "period_seconds": 10,
    "success_threshold": 1,
    "timeout_seconds": 30
  },
  "networking": {
    "port": 32768
  },
  "readiness_probe": {
    "failure_threshold": 3,
    "initial_delay_seconds": 0,
    "period_seconds": 1,
    "success_threshold": 1,
    "timeout_seconds": 1
  },
  "replicas": 250,
  "scaling-actions": [
    {
      "replicas": 250,
      "schedule": "<string>"
    }
  ],
  "scheduled-scaling-enabled": true,
  "startup_probe": {
    "failure_threshold": 15,
    "initial_delay_seconds": 0,
    "period_seconds": 3,
    "success_threshold": 2,
    "timeout_seconds": 10
  }
}
'

const options = {
  method: 'PATCH',
  headers: {'Salad-Api-Key': '<api-key>', 'Content-Type': 'application/merge-patch+json'},
  body: JSON.stringify({
    container: {
      command: ['<string>'],
      environment_variables: {},
      image: '<string>',
      image_caching: true,
      logging: {},
      registry_authentication: {aws_ecr: {access_key_id: '<string>', secret_access_key: '<string>'}},
      resources: {
        cpu: 512,
        gpu_classes: ['3c90c3cc-0d44-4b50-8888-8dd25736052a'],
        memory: 536871424,
        shm_size: 64,
        storage_amount: 562950490292224
      }
    },
    country_codes: ['us'],
    display_name: '<string>',
    liveness_probe: {
      failure_threshold: 3,
      initial_delay_seconds: 0,
      period_seconds: 10,
      success_threshold: 1,
      timeout_seconds: 30
    },
    networking: {port: 32768},
    readiness_probe: {
      failure_threshold: 3,
      initial_delay_seconds: 0,
      period_seconds: 1,
      success_threshold: 1,
      timeout_seconds: 1
    },
    replicas: 250,
    'scaling-actions': [{replicas: 250, schedule: '<string>'}],
    'scheduled-scaling-enabled': true,
    startup_probe: {
      failure_threshold: 15,
      initial_delay_seconds: 0,
      period_seconds: 3,
      success_threshold: 2,
      timeout_seconds: 10
    }
  })
};

fetch('https://api.salad.com/api/public/organizations/{organization_name}/projects/{project_name}/containers/{container_group_name}', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.salad.com/api/public/organizations/{organization_name}/projects/{project_name}/containers/{container_group_name}",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'container' => [
        'command' => [
                '<string>'
        ],
        'environment_variables' => [
                
        ],
        'image' => '<string>',
        'image_caching' => true,
        'logging' => [
                
        ],
        'registry_authentication' => [
                'aws_ecr' => [
                                'access_key_id' => '<string>',
                                'secret_access_key' => '<string>'
                ]
        ],
        'resources' => [
                'cpu' => 512,
                'gpu_classes' => [
                                '3c90c3cc-0d44-4b50-8888-8dd25736052a'
                ],
                'memory' => 536871424,
                'shm_size' => 64,
                'storage_amount' => 562950490292224
        ]
    ],
    'country_codes' => [
        'us'
    ],
    'display_name' => '<string>',
    'liveness_probe' => [
        'failure_threshold' => 3,
        'initial_delay_seconds' => 0,
        'period_seconds' => 10,
        'success_threshold' => 1,
        'timeout_seconds' => 30
    ],
    'networking' => [
        'port' => 32768
    ],
    'readiness_probe' => [
        'failure_threshold' => 3,
        'initial_delay_seconds' => 0,
        'period_seconds' => 1,
        'success_threshold' => 1,
        'timeout_seconds' => 1
    ],
    'replicas' => 250,
    'scaling-actions' => [
        [
                'replicas' => 250,
                'schedule' => '<string>'
        ]
    ],
    'scheduled-scaling-enabled' => true,
    'startup_probe' => [
        'failure_threshold' => 15,
        'initial_delay_seconds' => 0,
        'period_seconds' => 3,
        'success_threshold' => 2,
        'timeout_seconds' => 10
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/merge-patch+json",
    "Salad-Api-Key: <api-key>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

require 'uri'
require 'net/http'

url = URI("https://api.salad.com/api/public/organizations/{organization_name}/projects/{project_name}/containers/{container_group_name}")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["Salad-Api-Key"] = '<api-key>'
request["Content-Type"] = 'application/merge-patch+json'
request.body = "{\n  \"container\": {\n    \"command\": [\n      \"<string>\"\n    ],\n    \"environment_variables\": {},\n    \"image\": \"<string>\",\n    \"image_caching\": true,\n    \"logging\": {},\n    \"registry_authentication\": {\n      \"aws_ecr\": {\n        \"access_key_id\": \"<string>\",\n        \"secret_access_key\": \"<string>\"\n      }\n    },\n    \"resources\": {\n      \"cpu\": 512,\n      \"gpu_classes\": [\n        \"3c90c3cc-0d44-4b50-8888-8dd25736052a\"\n      ],\n      \"memory\": 536871424,\n      \"shm_size\": 64,\n      \"storage_amount\": 562950490292224\n    }\n  },\n  \"country_codes\": [\n    \"us\"\n  ],\n  \"display_name\": \"<string>\",\n  \"liveness_probe\": {\n    \"failure_threshold\": 3,\n    \"initial_delay_seconds\": 0,\n    \"period_seconds\": 10,\n    \"success_threshold\": 1,\n    \"timeout_seconds\": 30\n  },\n  \"networking\": {\n    \"port\": 32768\n  },\n  \"readiness_probe\": {\n    \"failure_threshold\": 3,\n    \"initial_delay_seconds\": 0,\n    \"period_seconds\": 1,\n    \"success_threshold\": 1,\n    \"timeout_seconds\": 1\n  },\n  \"replicas\": 250,\n  \"scaling-actions\": [\n    {\n      \"replicas\": 250,\n      \"schedule\": \"<string>\"\n    }\n  ],\n  \"scheduled-scaling-enabled\": true,\n  \"startup_probe\": {\n    \"failure_threshold\": 15,\n    \"initial_delay_seconds\": 0,\n    \"period_seconds\": 3,\n    \"success_threshold\": 2,\n    \"timeout_seconds\": 10\n  }\n}"

response = http.request(request)
puts response.read_body

{
  "autostart_policy": true,
  "container": {
    "command": [
      "<string>"
    ],
    "image": "<string>",
    "resources": {
      "cpu": 512,
      "gpu_classes": [
        "3c90c3cc-0d44-4b50-8888-8dd25736052a"
      ],
      "memory": 536871424,
      "shm_size": 64,
      "storage_amount": 562950490292224
    },
    "environment_variables": {},
    "hash": "<string>",
    "image_caching": true,
    "logging": {
      "axiom": {
        "api_token": "<string>",
        "dataset": "<string>",
        "host": "<string>"
      },
      "datadog": {
        "api_key": "<string>",
        "host": "<string>",
        "tags": [
          {
            "name": "<string>",
            "value": "<string>"
          }
        ]
      },
      "http": {
        "headers": [
          {
            "name": "<string>",
            "value": "<string>"
          }
        ],
        "host": "<string>",
        "port": 32768,
        "password": "<string>",
        "path": "<string>",
        "user": "<string>"
      },
      "new_relic": {
        "host": "<string>",
        "ingestion_key": "<string>"
      },
      "splunk": {
        "host": "<string>",
        "token": "<string>"
      },
      "tcp": {
        "host": "<string>",
        "port": 32768
      }
    },
    "size": 4611686018427388000
  },
  "country_codes": [
    "us"
  ],
  "create_time": "2023-11-07T05:31:56Z",
  "current_state": {
    "finish_time": "2023-11-07T05:31:56Z",
    "instance_status_counts": {
      "allocating_count": 1073741823,
      "creating_count": 1073741823,
      "running_count": 1073741823,
      "stopping_count": 1073741823
    },
    "start_time": "2023-11-07T05:31:56Z",
    "description": "<string>"
  },
  "display_name": "<string>",
  "id": "3c90c3cc-0d44-4b50-8888-8dd25736052a",
  "name": "<string>",
  "organization_name": "<string>",
  "pending_change": true,
  "project_name": "<string>",
  "replicas": 250,
  "scaling-actions": [
    {
      "replicas": 250,
      "schedule": "<string>"
    }
  ],
  "scheduled-scaling-enabled": true,
  "update_time": "2023-11-07T05:31:56Z",
  "version": 1073741824,
  "liveness_probe": {
    "failure_threshold": 3,
    "initial_delay_seconds": 0,
    "period_seconds": 10,
    "success_threshold": 1,
    "timeout_seconds": 30,
    "exec": {
      "command": [
        "<string>"
      ]
    },
    "grpc": {
      "port": 32768,
      "service": "<string>"
    },
    "http": {
      "headers": [
        {
          "name": "<string>",
          "value": "<string>"
        }
      ],
      "path": "<string>",
      "port": 32768
    },
    "tcp": {
      "port": 32767
    }
  },
  "networking": {
    "auth": true,
    "dns": "<string>",
    "load_balancer": "round_robin",
    "port": 32768,
    "protocol": "http",
    "client_request_timeout": 100000,
    "server_response_timeout": 100000,
    "single_connection_limit": false
  },
  "queue_autoscaler": {
    "desired_queue_length": 50,
    "max_replicas": 250,
    "min_replicas": 50,
    "max_downscale_per_minute": 50,
    "max_upscale_per_minute": 50,
    "polling_period": 907
  },
  "queue_connection": {
    "path": "<string>",
    "port": 32768,
    "queue_name": "<string>"
  },
  "readiness_probe": {
    "failure_threshold": 3,
    "initial_delay_seconds": 0,
    "period_seconds": 1,
    "success_threshold": 1,
    "timeout_seconds": 1,
    "exec": {
      "command": [
        "<string>"
      ]
    },
    "grpc": {
      "port": 32768,
      "service": "<string>"
    },
    "http": {
      "headers": [
        {
          "name": "<string>",
          "value": "<string>"
        }
      ],
      "path": "<string>",
      "port": 32768
    },
    "tcp": {
      "port": 32767
    }
  },
  "readme": "<string>",
  "startup_probe": {
    "failure_threshold": 15,
    "initial_delay_seconds": 0,
    "period_seconds": 3,
    "success_threshold": 2,
    "timeout_seconds": 10,
    "exec": {
      "command": [
        "<string>"
      ]
    },
    "grpc": {
      "port": 32768,
      "service": "<string>"
    },
    "http": {
      "headers": [
        {
          "name": "<string>",
          "value": "<string>"
        }
      ],
      "path": "<string>",
      "port": 32768
    },
    "tcp": {
      "port": 32767
    }
  }
}

{
  "detail": "<string>",
  "instance": "<string>",
  "status": 349,
  "title": "<string>",
  "type": "about:blank"
}

{
  "detail": "<string>",
  "instance": "<string>",
  "status": 349,
  "title": "<string>",
  "type": "about:blank"
}

{
  "detail": "<string>",
  "instance": "<string>",
  "status": 349,
  "title": "<string>",
  "type": "about:blank"
}

{
  "detail": "<string>",
  "instance": "<string>",
  "status": 349,
  "title": "<string>",
  "type": "about:blank"
}

{
  "detail": "<string>",
  "instance": "<string>",
  "status": 349,
  "title": "<string>",
  "type": "about:blank"
}