STACKIT SDK for Go

https://github.com/stackitcloud/stackit-sdk-go
Admin
The STACKIT SDK for Go provides service clients, authentication, and shared functionality to...
Tokens:884,063
Snippets:5,143
Trust Score:9.9
License:Apache-2.0
Update:6 days ago
Show doc for...
Tokens:
Raw
### Verify installation with DNS client

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/installation.md

This example demonstrates building a DNS client with default authentication and listing zones to verify the installation.

```go
package main

import (
    "context"
    "fmt"
    "os"

    dns "github.com/stackitcloud/stackit-sdk-go/services/dns"
)

func main() {
    dnsClient, err := dns.NewAPIClient()
    if err != nil {
        fmt.Fprintf(os.Stderr, "[DNS API] Creating API client: %v\n", err)
        os.Exit(1)
    }
    zones, err := dnsClient.DefaultAPI.ListZones(context.Background(), "PROJECT_ID").Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "[DNS API] Listing zones: %v\n", err)
        os.Exit(1)
    }
    fmt.Printf("Number of zones: %v\n", len(zones.Zones))
}
```

--------------------------------

### Install a service module

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/installation.md

Use this command to add a specific service module to your Go project.

```bash
go get github.com/stackitcloud/stackit-sdk-go/services/dns
```

--------------------------------

### Install the core module

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/installation.md

Use this command to add the core STACKIT SDK module to your Go project.

```bash
go get github.com/stackitcloud/stackit-sdk-go/core
```

--------------------------------

### Usage example

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/oidcadapters.md

Example of using the OIDC adapters with the workload identity federation auth flow to create an API client.

```APIDOC
## Usage example

### Description
Example of using the OIDC adapters with the workload identity federation auth flow to create an API client.

### Example
```go
import (
	"github.com/stackitcloud/stackit-sdk-go/core/config"
	"github.com/stackitcloud/stackit-sdk-go/core/oidcadapters"
	dns "github.com/stackitcloud/stackit-sdk-go/services/dns"
)

// federated token from a mounted file
client, err := dns.NewAPIClient(
	config.WithWorkloadIdentityFederationAuth(),
	config.WithWorkloadIdentityFederationFunc(
		oidcadapters.ReadJWTFromFileSystem("/var/run/secrets/token"),
	),
)
```
```

--------------------------------

### Interact with STACKIT DNS service

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/README.md

Example demonstrating how to initialize a DNS client, list zones, create a new zone, and retrieve a record set. Requires a valid STACKIT project ID.

```go
package main

import (
   "context"
   "fmt"
   "os"

   dns "github.com/stackitcloud/stackit-sdk-go/services/dns/v1api"
)

func main() {
   projectId := "PROJECT_ID" // the uuid of your STACKIT project

   // Create a new API client, that uses default authentication and configuration
   dnsClient, err := dns.NewAPIClient()
   if err != nil {
      fmt.Fprintf(os.Stderr, "[DNS API] Creating API client: %v\n", err)
      os.Exit(1)
   }

   // Get the DNS Zones for your project
   var getZoneResp *dns.ListZonesResponse
   getZoneResp, err = dnsClient.DefaultAPI.ListZones(context.Background(), projectId).Execute()

   // Get only active DNS Zones for your project by adding the filter "ActiveEq(true)" to the call. More filters are available and can be chained.
   // dnsRespGetZones, err := dnsClient.ZoneApi.GetZones(context.Background(), projectId).ActiveEq(true).Execute()

   if err != nil {
      fmt.Fprintf(os.Stderr, "[DNS API] Error when calling `ZoneApi.GetZones`: %v\n", err)
   } else {
      fmt.Printf("[DNS API] Number of zones: %v\n", len(getZoneResp.Zones))
   }

   // Create a DNS Zone
   createZonePayload := dns.CreateZonePayload{
      Name:    "myZone",
      DnsName: "testZone.com",
   }
   var createZoneResp *dns.ZoneResponse
   createZoneResp, err = dnsClient.DefaultAPI.CreateZone(context.Background(), projectId).CreateZonePayload(createZonePayload).Execute()
   if err != nil {
      fmt.Fprintf(os.Stderr, "[DNS API] Error when calling `ZoneApi.CreateZone`: %v\n", err)
   } else {
      var createdZone = createZoneResp.Zone
      fmt.Printf("[DNS API] Created zone \"%s\" with DNS name \"%s\" and zone id \"%s\".\n", createdZone.Name, createdZone.DnsName, createdZone.Id)
   }

   // Get a record set of a DNS zone.
   var recordSetResp *dns.RecordSetResponse
   recordSetResp, err = dnsClient.DefaultAPI.GetRecordSet(context.Background(), projectId, "zoneId", "recordSetId").Execute()
   if err != nil {
      fmt.Fprintf(os.Stderr, "[DNS API] Error when calling `GetRecordSet`: %v\n", err)
   } else {
      fmt.Printf("[DNS API] Got record set with name \"%s\".\n", recordSetResp.Rrset.Name)
   }
}
```

--------------------------------

### Usage of runtime capture helpers

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/runtime.md

Example demonstrating how to capture an HTTP response and retrieve the trace ID after executing a service call.

```go
import (
	"context"
	"net/http"

	"github.com/stackitcloud/stackit-sdk-go/core/runtime"
	dns "github.com/stackitcloud/stackit-sdk-go/services/dns"
)

var rawResp *http.Response
ctx := runtime.WithCaptureHTTPResponse(context.Background(), &rawResp)

dnsClient.DefaultAPI.ListZones(ctx, projectId).Execute()

if rawResp != nil {
	fmt.Println("trace id:", runtime.GetTraceId(ctx))
	fmt.Println("status:", rawResp.StatusCode)
}
```

--------------------------------

### Example usage with error handling

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/oapierror.md

Complete example of handling API errors, including checking for a 404 status code.

```APIDOC
## Example Usage

### Description
Demonstrates how to handle API errors in a function that lists zones.

### Example
```go
import (
	"errors"
	"fmt"

	dns "github.com/stackitcloud/stackit-sdk-go/services/dns"
	"github.com/stackitcloud/stackit-sdk-go/core/oapierror"
)

func listZonesOrDie(ctx context.Context, projectId string) {
	dnsClient, err := dns.NewAPIClient()
	if err != nil {
		panic(err)
	}
	resp, err := dnsClient.DefaultAPI.ListZones(ctx, projectId).Execute()
	if err != nil {
		var oapiErr *oapierror.GenericOpenAPIError
		if errors.As(err, &oapiErr) && oapiErr.StatusCode == 404 {
			fmt.Println("zones endpoint not available")
			return
		}
		fmt.Printf("unexpected error: %v (%d)\n", oapiErr.ErrorMessage, oapiErr.StatusCode)
		return
	}
	fmt.Printf("zones: %d\n", len(resp.Zones))
}
```
```

--------------------------------

### Usage with Workload Identity Federation

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/oidcadapters.md

Example of configuring a service client to use a filesystem-based OIDC adapter for authentication.

```go
import (
	"github.com/stackitcloud/stackit-sdk-go/core/config"
	"github.com/stackitcloud/stackit-sdk-go/core/oidcadapters"
	dns "github.com/stackitcloud/stackit-sdk-go/services/dns"
)

// federated token from a mounted file
client, err := dns.NewAPIClient(
	config.WithWorkloadIdentityFederationAuth(),
	config.WithWorkloadIdentityFederationFunc(
		oidcadapters.ReadJWTFromFileSystem("/var/run/secrets/token"),
	),
)
```

--------------------------------

### Handling specific API error status codes

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/oapierror.md

Example demonstrating how to check for specific status codes like 404 when handling API errors.

```go
import (
	"errors"
	"fmt"

	dns "github.com/stackitcloud/stackit-sdk-go/services/dns"
	"github.com/stackitcloud/stackit-sdk-go/core/oapierror"
)

func listZonesOrDie(ctx context.Context, projectId string) {
	dnsClient, err := dns.NewAPIClient()
	if err != nil {
		panic(err)
	}
	resp, err := dnsClient.DefaultAPI.ListZones(ctx, projectId).Execute()
	if err != nil {
		var oapiErr *oapierror.GenericOpenAPIError
		if errors.As(err, &oapiErr) && oapiErr.StatusCode == 404 {
			fmt.Println("zones endpoint not available")
			return
		}
		fmt.Printf("unexpected error: %v (%d)\n", oapiErr.ErrorMessage, oapiErr.StatusCode)
		return
	}
	fmt.Printf("zones: %d\n", len(resp.Zones))
}
```

--------------------------------

### Catching API errors with errors.As

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/oapierror.md

Example of using errors.As to type-assert an error to GenericOpenAPIError in consumer code.

```go
import "github.com/stackitcloud/stackit-sdk-go/core/oapierror"

zones, err := dnsClient.DefaultAPI.ListZones(ctx, projectId).Execute()
if err != nil {
	var oapiErr *oapierror.GenericOpenAPIError
	if errors.As(err, &oapiErr) {
		fmt.Printf("API error status=%d body=%s\n", oapiErr.StatusCode, oapiErr.Body)
		// Model holds the parsed error response if provided by the generator
	}
}
```

--------------------------------

### Waiter for Deletion with NotFound Status

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/CONTRIBUTING.md

Example of a waiter handler for deletion where the resource is expected to disappear, requiring the configuration of DeleteHttpErrorStatusCodes.

```go
// DeleteBarWaitHandler will wait for Bar deletion
func DeleteBarWaitHandler(ctx context.Context, a APIClientInterface, barId, projectId string) *wait.AsyncActionHandler[foo.ListBarsResponse] {
	  waitConfig := wait.WaiterHelper[foo.GetBarResponse, string]{
        FetchInstance: a.GetBar(ctx, projectId, barId).Execute,
        GetState: func(d *foo.GetBarResponse) (string, error) {
          if d == nil {
            return "", errors.New("could not get bar status from response")
          }
          return d.Status, nil
        },
        ActiveState: nil,
        ErrorState:  []string{DeleteFail},
		DeleteHttpErrorStatusCodes: []int{http.StatusNotFound},
	  }
  
      handler := wait.New(waitConfig.Wait())
      handler.SetTimeout(10 * time.Minute)
      return handler
  }
```

--------------------------------

### Catching API errors in consumer code

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/oapierror.md

Example of how to catch and handle GenericOpenAPIError in consumer code using errors.As.

```APIDOC
## Catching API Errors

### Description
Shows how to detect and handle GenericOpenAPIError when calling STACKIT service methods.

### Example
```go
import "github.com/stackitcloud/stackit-sdk-go/core/oapierror"

zones, err := dnsClient.DefaultAPI.ListZones(ctx, projectId).Execute()
if err != nil {
	var oapiErr *oapierror.GenericOpenAPIError
	if errors.As(err, &oapiErr) {
		fmt.Printf("API error status=%d body=%s\n", oapiErr.StatusCode, oapiErr.Body)
		// Model holds the parsed error response if provided by the generator
	}
}
```
```

--------------------------------

### AuthFlow interface

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/clients.md

The AuthFlow interface defines the contract for authentication flows in the STACKIT SDK. It implements the http.RoundTripper interface and provides methods for getting access tokens and refreshing them.

```APIDOC
## AuthFlow interface

### Description
The AuthFlow interface is implemented by all authentication flows in the STACKIT SDK. It extends the http.RoundTripper interface and provides methods for token management.

### Methods
- **RoundTrip(req *http.Request) (*http.Response, error)** - Executes a single HTTP transaction with authentication applied.
- **GetAccessToken() (string, error)** - Returns the current access token.
- **getBackgroundTokenRefreshContext() context.Context** - Returns the context for background token refresh.
- **refreshAccessToken() error** - Refreshes the access token.

### TokenResponseBody
```go
type TokenResponseBody struct {
	AccessToken string `json:"access_token"`
	ExpiresIn   int    `json:"expires_in"`
	// Deprecated: RefreshToken is no longer used. Will be removed after 2026-07-01.
	RefreshToken string `json:"refresh_token"`
	Scope        string `json:"scope"`
	TokenType    string `json:"token_type"`
}
```

### Helper Functions
- **parseTokenResponse** - Parses a token response.
- **parseTokenResponseWithRefreshToken** - Parses a token response including refresh token.
- **tokenExpired** - Checks if a token has expired.
- **continuousRefreshToken** - Continuously refreshes the token.
```

--------------------------------

### Service Client Initialization and Direct Auth Flow Usage

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/clients.md

Demonstrates the recommended service-level client initialization using a service account key and the alternative method for direct authentication flow usage.

```go
import (
	"github.com/stackitcloud/stackit-sdk-go/core/auth"
	"github.com/stackitcloud/stackit-sdk-go/core/config"
	dns "github.com/stackitcloud/stackit-sdk-go/services/dns"
)

// 1) Service-level client with key flow (recommended)
dnsClient, err := dns.NewAPIClient(
	config.WithServiceAccountKeyPath("/path/to/sa_key.json"),
	config.WithPrivateKeyPath("/path/to/private.pem"),
)

// 2) Direct flow use
rt, err := auth.KeyAuth(&config.Configuration{
	ServiceAccountKeyPath: "/path/to/sa_key.json",
})
customClient := &http.Client{Transport: rt}
```

--------------------------------

### SetupAuth(cfg *config.Configuration) (http.RoundTripper, error)

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/auth.md

Initializes authentication based on configuration. If cfg is nil, a fresh config.Configuration is created and the service account email is filled from getServiceAccountEmail.

```APIDOC
## SetupAuth(cfg *config.Configuration) (http.RoundTripper, error)

### Description
Initializes authentication based on configuration. The flow configs are taken from cfg. If cfg is nil, a fresh config.Configuration is created and the service account email is filled from getServiceAccountEmail.

### Parameters
- **cfg** (*config.Configuration) - Optional - Configuration object for authentication setup.

### Returns
- **http.RoundTripper** - Configured RoundTripper for authentication.
- **error** - Error if initialization fails.
```

--------------------------------

### Initialize basic authenticated client

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/auth.md

Uses the default authentication flow, which relies on environment variables and a credentials file.

```go
import (
	"context"
	"fmt"

	dns "github.com/stackitcloud/stackit-sdk-go/services/dns"
)

func main() {
	client, err := dns.NewAPIClient() // DefaultAuth: env vars + credentials file
	if err != nil {
		panic(fmt.Sprintf("creating client: %v", err))
	}

	zones, err := client.DefaultAPI.DefaultAPI.ListZones(context.Background(), "PROJECT_ID").Execute()
	if err != nil {
		panic(fmt.Sprintf("listing zones: %v", err))
	}
	fmt.Printf("got %d zones\n", len(zones.Zones))
}
```

--------------------------------

### Initialize a STACKIT service client

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/project-overview.md

The primary entry point for using a service is the NewAPIClient function, which handles default authentication and configuration.

```go
import (
    dns "github.com/stackitcloud/stackit-sdk-go/services/dns"
)
client, err := dns.NewAPIClient() // default authentication + default configuration
```

--------------------------------

### Initialize client with explicit token

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/auth.md

Configures the client using a specific access token via the config.WithToken option.

```go
import (
	config "github.com/stackitcloud/stackit-sdk-go/core/config"
	dns "github.com/stackitcloud/stackit-sdk-go/services/dns"
)

client, err := dns.NewAPIClient(config.WithToken("my-access-token"))
if err != nil {
	panic(err)
}
```

--------------------------------

### Configure Key Flow via Credentials File

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/README.md

The structure for the $HOME/.stackit/credentials.json file to configure Key Flow.

```json
{
  "STACKIT_SERVICE_ACCOUNT_KEY_PATH": "/path/to/sa_key.json",
  "STACKIT_PRIVATE_KEY_PATH": "/path/to/private.pem"
}
```

--------------------------------

### Configure authentication via code

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/README.md

Use the WithToken method to provide your access token directly within your Go code.

```go
config.WithToken("your-token")
```

--------------------------------

### Configure authentication via credentials file

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/README.md

Store your token in a JSON file located at $HOME/.stackit/credentials.json.

```json
{
  "STACKIT_SERVICE_ACCOUNT_TOKEN": "your-token"
}
```

--------------------------------

### KeyAuth(cfg *config.Configuration) (http.RoundTripper, error)

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/auth.md

Key flow. Requires a service account key JSON. Falls back to STACKIT_TOKEN_BASEURL env var for the token endpoint. Returns a configured *clients.KeyFlow.

```APIDOC
## KeyAuth(cfg *config.Configuration) (http.RoundTripper, error)

### Description
Key flow. Requires a service account key JSON (see Credentials). Falls back to STACKIT_TOKEN_BASEURL env var for the token endpoint. Returns a configured *clients.KeyFlow.

### Parameters
- **cfg** (*config.Configuration) - Required - Configuration object containing key settings.

### Returns
- **http.RoundTripper** - Configured RoundTripper for key authentication.
- **error** - Error if initialization fails.
```

--------------------------------

### Initialize client with workload identity federation

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/auth.md

Configures authentication for GitHub Actions using workload identity federation.

```go
import (
	"github.com/stackitcloud/stackit-sdk-go/core/config"
	"github.com/stackitcloud/stackit-sdk-go/core/oidcadapters"
	dns "github.com/stackitcloud/stackit-sdk-go/services/dns"
)

client, err := dns.NewAPIClient(
	config.WithWorkloadIdentityFederationAuth(),
	config.WithWorkloadIdentityFederationFunc(
		oidcadapters.RequestGHOIDCToken("https://token.actions.githubusercontent.com", "GH_TOKEN"),
	),
	config.WithEndpoint("https://dns.api.stackit.cloud"),
)
```

--------------------------------

### Configure authentication via environment variables

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/README.md

Set the STACKIT_SERVICE_ACCOUNT_TOKEN environment variable to authenticate your application.

```bash
STACKIT_SERVICE_ACCOUNT_TOKEN=your-token
```

--------------------------------

### Configure Key Flow in Go

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/README.md

Use these methods to configure the Key Flow authentication in your Go code, supporting both file paths and direct content.

```go
// Using service account key file
config.WithServiceAccountKeyPath("path/to/sa_key.json")
// Or using key content directly
config.WithServiceAccountKey(keyJSON)

// Optional: For custom key pairs
config.WithPrivateKeyPath("path/to/private.pem")
// Or using private key content directly
config.WithPrivateKey(privateKeyJSON)
```

--------------------------------

### Configure Key Flow via Environment Variables

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/README.md

Set these environment variables to configure the Key Flow authentication.

```bash
# Using service account key
STACKIT_SERVICE_ACCOUNT_KEY_PATH=/path/to/sa_key.json
# or
STACKIT_SERVICE_ACCOUNT_KEY=<sa-key-content>

# Optional: For custom key pairs
STACKIT_PRIVATE_KEY_PATH=/path/to/private.pem
# or
STACKIT_PRIVATE_KEY=<private-key-content>
```

--------------------------------

### Configure Workload Identity Federation via Environment Variables

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/README.md

Set these environment variables to configure the Workload Identity Federation flow.

```bash
# With the custom path for the external OIDC token
STACKIT_FEDERATED_TOKEN_FILE=/path/to/your/federated/token
# For the service account
STACKIT_SERVICE_ACCOUNT_EMAIL=my-sa@sa-stackit.cloud
```

--------------------------------

### Standard SDK Waiter Structure

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/CONTRIBUTING.md

A typical implementation of waiter handlers for create, update, and delete operations using the WaiterHelper utility.

```go
package wait

import (
	"context"
	"fmt"
	"time"

	"github.com/stackitcloud/stackit-sdk-go/core/wait"
	"github.com/stackitcloud/stackit-sdk-go/services/foo"
)

const (
	CreateSuccess = "CREATE_SUCCEEDED"
	CreateFail    = "CREATE_FAILED"
	UpdateSuccess = "UPDATE_SUCCEEDED"
	UpdateFail    = "UPDATE_FAILED"
	DeleteSuccess = "DELETE_SUCCEEDED"
	DeleteFail    = "DELETE_FAILED"
)

// APIClientInterface Interfaces needed for tests
type APIClientInterface interface {
	GetBarExecute(ctx context.Context, BarId, projectId string) (*foo.GetBarResponse, error)
}

// CreateBarWaitHandler will wait for Bar creation
func CreateBarWaitHandler(ctx context.Context, a APIClientInterface, projectId, barId string) *wait.AsyncActionHandler[foo.GetBarResponse] {
    waitConfig := wait.WaiterHelper[foo.GetBarResponse, string]{
      FetchInstance: a.GetBar(ctx, projectId, barId).Execute,
      GetState: func(d *foo.GetBarResponse) (string, error) {
        if d == nil {
          return "", errors.New("could not get bar status from response")
        }
        return d.Status, nil
      },
      ActiveState: []string{CreateSuccess},
      ErrorState:  []string{CreateFail},
    }

    handler := wait.New(waitConfig.Wait())
	handler.SetTimeout(45 * time.Minute)
	return handler
}

// UpdateBarWaitHandler will wait for Bar update
func UpdateBarWaitHandler(ctx context.Context, a APIClientInterface, BarId, projectId string) *wait.AsyncActionHandler[foo.GetBarResponse] {
    waitConfig := wait.WaiterHelper[foo.GetBarResponse, string]{
      FetchInstance: a.GetBar(ctx, projectId, barId).Execute,
      GetState: func(d *foo.GetBarResponse) (string, error) {
        if d == nil {
          return "", errors.New("could not get bar status from response")
        }
        return d.Status, nil
      },
      ActiveState: []string{UpdateSuccess},
      ErrorState:  []string{UpdateFail},
    }

    handler := wait.New(waitConfig.Wait())
	handler.SetTimeout(30 * time.Minute)
	return handler
}

// DeleteBarWaitHandler will wait for Bar deletion
func DeleteBarWaitHandler(ctx context.Context, a APIClientInterface, BarId, projectId string) *wait.AsyncActionHandler[foo.GetBarResponse] {
    waitConfig := wait.WaiterHelper[foo.GetBarResponse, string]{
      FetchInstance: a.GetBar(ctx, projectId, barId).Execute,
      GetState: func(d *foo.GetBarResponse) (string, error) {
        if d == nil {
          return "", errors.New("could not get bar status from response")
        }
        return d.Status, nil
      },
      ActiveState: []string{DeleteSuccess},
      ErrorState:  []string{DeleteFail},
    }

    handler := wait.New(waitConfig.Wait())
	handler.SetTimeout(20 * time.Minute)
	return handler
}
```

--------------------------------

### TokenAuth(cfg *config.Configuration) (http.RoundTripper, error)

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/auth.md

Token flow. Resolves the token from config.WithToken, STACKIT_SERVICE_ACCOUNT_TOKEN env var, or credentials file. Builds clients.TokenFlowConfig and returns a configured *clients.TokenFlow. Deprecated in favor of the key flow.

```APIDOC
## TokenAuth(cfg *config.Configuration) (http.RoundTripper, error)

### Description
Token flow. Resolves the token from (in order): config.WithToken → STACKIT_SERVICE_ACCOUNT_TOKEN env var → credentials file (STACKIT_SERVICE_ACCOUNT_TOKEN in STACKIT_CREDENTIALS_PATH or $HOME/.stackit/credentials.json). Builds clients.TokenFlowConfig{ServiceAccountToken: ...} and returns a configured *clients.TokenFlow. Deprecated in favor of the key flow; removed in a later update.

### Parameters
- **cfg** (*config.Configuration) - Required - Configuration object containing token settings.

### Returns
- **http.RoundTripper** - Configured RoundTripper for token authentication.
- **error** - Error if initialization fails.
```

--------------------------------

### WorkloadIdentityFederationAuth(cfg *config.Configuration) (http.RoundTripper, error)

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/auth.md

Workload identity federation flow. Creates clients.WorkloadIdentityFederationFlowConfig from cfg and returns a configured *clients.WorkloadIdentityFederationFlow.

```APIDOC
## WorkloadIdentityFederationAuth(cfg *config.Configuration) (http.RoundTripper, error)

### Description
Workload identity federation flow. Creates clients.WorkloadIdentityFederationFlowConfig from cfg and returns a configured *clients.WorkloadIdentityFederationFlow.

### Parameters
- **cfg** (*config.Configuration) - Required - Configuration object for workload identity federation.

### Returns
- **http.RoundTripper** - Configured RoundTripper for workload identity federation authentication.
- **error** - Error if initialization fails.
```

--------------------------------

### Import service modules

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/installation.md

Import the service-named package to access the generated API sub-packages transitively.

```go
import (
    dns "github.com/stackitcloud/stackit-sdk-go/services/dns"
    objectstorage "github.com/stackitcloud/stackit-sdk-go/services/objectstorage"
)
```

--------------------------------

### Filesystem Adapter

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/oidcadapters.md

Reads a raw JWT from a file system path to return an OIDCTokenFunc, typically used for mounted service account tokens.

```go
func ReadJWTFromFileSystem(tokenFilePath string) OIDCTokenFunc {
	return func(ctx context.Context) (string, error) { ... }
}
```

--------------------------------

### ServiceAccountKeyResponse and ServiceAccountKeyCredentials structures

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/clients.md

JSON types used for service account key configuration and credentials.

```go
type ServiceAccountKeyResponse struct {
	Active       bool                          `json:"active"`
	CreatedAt    time.Time                     `json:"createdAt"`
	Credentials  *ServiceAccountKeyCredentials `json:"credentials"`
	ID           uuid.UUID                     `json:"id"`
	KeyAlgorithm string                        `json:"keyAlgorithm"`
	KeyOrigin    string                        `json:"keyOrigin"`
	KeyType      string                        `json:"keyType"`
	PublicKey    string                        `json:"publicKey"`
	ValidUntil   *time.Time                    `json:"validUntil,omitempty"`
}

type ServiceAccountKeyCredentials struct {
	Aud           string    `json:"aud"`
	Iss           string    `json:"iss"`
	Kid           string    `json:"kid"`
	PrivateKey    *string   `json:"privateKey,omitempty"`
	Sub           uuid.UUID `json:"sub"`
	TokenEndpoint string    `json:"tokenEndpoint"`
}
```

--------------------------------

### Exported runtime functions

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/runtime.md

Functions for capturing HTTP requests and responses in a context and retrieving trace IDs.

```go
// Adds an annotation to parent context; after the request completes, resp points to the raw
// *http.Response. Replaces the deprecated config.WithCaptureHTTPResponse.
func WithCaptureHTTPResponse(parent context.Context, resp **http.Response) context.Context {
	return context.WithValue(parent, config.ContextHTTPResponse, resp)
}

// Same for the raw *http.Request.
func WithCaptureHTTPRequest(parent context.Context, req **http.Request) context.Context {
	return context.WithValue(parent, config.ContextHTTPRequest, req)
}

// Reads the X-trace-id header from the last captured response.
// Prerequisite: WithCaptureHTTPResponse was called for the same context.
func GetTraceId(ctx context.Context) string
```

--------------------------------

### Continuous Refresh Configuration in clients/continuous_refresh.go

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/clients.md

Defines the structure and middleware for enabling continuous token refreshing in the SDK.

```go
type RefreshConfig struct{ ... } // exported fields not documented here; controlled via continuousRefreshToken
func NewRefreshConfig() *RefreshConfig                     // deprecated stub
func AppendMiddleware(rt http.RoundTripper, ms ...Middleware) http.RoundTripper
```

--------------------------------

### KeyFlow and KeyFlowConfig structures

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/clients.md

Defines the KeyFlow struct and its configuration, used for service account key-based authentication.

```go
type KeyFlow struct{ ... } // contains token caching, private key, config; not exported fields

type KeyFlowConfig struct {
	ServiceAccountKey       *ServiceAccountKeyResponse
	PrivateKey              string
	TokenUrl                string // defaults to https://service-account.api.stackit.cloud/token
	ClientRetry             *RetryConfig // Deprecated
	BackgroundTokenRefreshContext context.Context // enables continuous refresh
	HTTPTransport    http.RoundTripper
	AuthHTTPClient   *http.Client
}
```

--------------------------------

### Configure Workload Identity Federation in Go

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/README.md

Use these methods to configure the Workload Identity Federation flow directly within your Go code.

```go
// Using wokload identity federation flow
config.WithWorkloadIdentityFederationAuth()
// With the custom path for the external OIDC token
config.WithWorkloadIdentityFederationPath("/path/to/your/federated/token")
// For the service account
config.WithServiceAccountEmail("my-sa@sa-stackit.cloud")
```

--------------------------------

### NoAuth(cfgs ...*config.Configuration) (http.RoundTripper, error)

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/auth.md

Returns a *clients.NoAuthFlow configured with clients.NoAuthFlowConfig. Uses cfg.HTTPClient.Transport if available, otherwise http.DefaultTransport. Equivalent to config.WithoutAuthentication().

```APIDOC
## NoAuth(cfgs ...*config.Configuration) (http.RoundTripper, error)

### Description
Returns a *clients.NoAuthFlow configured with clients.NoAuthFlowConfig. Uses cfg.HTTPClient.Transport if available, otherwise http.DefaultTransport. Equivalent option: config.WithoutAuthentication().

### Parameters
- **cfgs** (...*config.Configuration) - Optional - Configuration objects. If provided, the first one is used.

### Returns
- **http.RoundTripper** - Configured RoundTripper for no authentication.
- **error** - Error if initialization fails.
```

--------------------------------

### Credentials struct definition

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/auth.md

The Credentials struct defines the fields used for authentication, including paths to key files and inline key content.

```go
type Credentials struct {
	STACKIT_SERVICE_ACCOUNT_EMAIL    string // Deprecated
	STACKIT_SERVICE_ACCOUNT_TOKEN    string
	STACKIT_SERVICE_ACCOUNT_KEY_PATH string
	STACKIT_PRIVATE_KEY_PATH         string
	STACKIT_SERVICE_ACCOUNT_KEY      string
	STACKIT_PRIVATE_KEY              string
}
```

--------------------------------

### WithCaptureHTTPResponse

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/runtime.md

Adds an annotation to the parent context so that after the request completes, the provided pointer points to the raw *http.Response. This replaces the deprecated config.WithCaptureHTTPResponse.

```APIDOC
## WithCaptureHTTPResponse

### Description
Adds an annotation to the parent context; after the request completes, resp points to the raw *http.Response. Replaces the deprecated config.WithCaptureHTTPResponse.

### Function Signature
func WithCaptureHTTPResponse(parent context.Context, resp **http.Response) context.Context

### Parameters
- **parent** (context.Context) - Required - The parent context to which the annotation is added.
- **resp** (**http.Response) - Required - A pointer to a pointer to an http.Response that will be set after the request completes.

### Returns
- **context.Context** - The context with the annotation added.

### Usage Example
```go
var rawResp *http.Response
ctx := runtime.WithCaptureHTTPResponse(context.Background(), &rawResp)
```
```

--------------------------------

### WithCaptureHTTPRequest

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/runtime.md

Adds an annotation to the parent context to capture the raw *http.Request. This is similar to WithCaptureHTTPResponse but for the request object.

```APIDOC
## WithCaptureHTTPRequest

### Description
Adds an annotation to the parent context to capture the raw *http.Request.

### Function Signature
func WithCaptureHTTPRequest(parent context.Context, req **http.Request) context.Context

### Parameters
- **parent** (context.Context) - Required - The parent context to which the annotation is added.
- **req** (**http.Request) - Required - A pointer to a pointer to an http.Request that will be set after the request is created.

### Returns
- **context.Context** - The context with the annotation added.

### Usage Example
```go
var rawReq *http.Request
ctx := runtime.WithCaptureHTTPRequest(context.Background(), &rawReq)
```
```

--------------------------------

### GenericOpenAPIError constructor helpers

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/oapierror.md

Helper functions for creating instances of GenericOpenAPIError.

```go
// Constructor helper
func NewError(code int, status string) *GenericOpenAPIError
func NewErrorWithBody(code int, status string, body []byte, model any) *GenericOpenAPIError
```

--------------------------------

### WorkloadIdentityFederationFlow Configuration Structure

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/clients.md

Defines the WorkloadIdentityFederationFlow and its configuration, which supports OIDC-based workload identity federation.

```go
type WorkloadIdentityFederationFlow struct {
	// config, token cache, auth HTTP client, round tripper
}
type WorkloadIdentityFederationFlowConfig struct {
	TokenUrl                       string // defaults to https://accounts.stackit.cloud/oauth/v2/token
	ClientID                       string // defaults to STACKIT_SERVICE_ACCOUNT_EMAIL env
	FederatedTokenFunction          oidcadapters.OIDCTokenFunc
	BackgroundTokenRefreshContext   context.Context
	HTTPTransport                   http.RoundTripper
	AuthHTTPClient                  *http.Client
}
```

--------------------------------

### GitHub Actions Adapter

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/oidcadapters.md

Requests an OIDC token from the GitHub Actions endpoint using the provided request URL and token.

```go
func RequestGHOIDCToken(oidcRequestUrl, oidcRequestToken string) OIDCTokenFunc {
	return func(ctx context.Context) (string, error) { ... }
}
```

--------------------------------

### Service Account Key JSON Structure

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/README.md

The expected structure for the service account key JSON file used in the Key Flow.

```json
{
  "id": "uuid",
  "publicKey": "public key",
  "credentials": {
    "kid": "string",
    "iss": "my-sa@sa.stackit.cloud",
    "sub": "uuid",
    "aud": "string",
    "privateKey": "private key (if STACKIT-generated)"
  }
  // ... other fields ...
}
```

--------------------------------

### TokenFlow Configuration Structure

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/clients.md

Defines the TokenFlow struct and its configuration, which uses a pre-obtained static service-account access token.

```go
type TokenFlow struct{}
type TokenFlowConfig struct {
	ServiceAccountEmail string // Deprecated
	ServiceAccountToken string
	ClientRetry   *RetryConfig // Deprecated
	HTTPTransport http.RoundTripper
}
```

--------------------------------

### NoAuthFlow Configuration Structure

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/clients.md

Defines the NoAuthFlow struct and its configuration for clients that do not require authentication.

```go
type NoAuthFlow struct{}
type NoAuthFlowConfig struct {
	HTTPTransport http.RoundTripper
}
```

--------------------------------

### ReadJWTFromFileSystem

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/oidcadapters.md

Reads a raw JWT from a file and returns an OIDCTokenFunc. Commonly used with a mounted service account federated token file.

```APIDOC
## ReadJWTFromFileSystem

### Description
Reads a raw JWT from a file (commonly a mounted service account federated token file) and returns an OIDCTokenFunc.

### Function Signature
func ReadJWTFromFileSystem(tokenFilePath string) OIDCTokenFunc

### Parameters
- **tokenFilePath** (string) - Required - Path to the file containing the JWT.

### Returns
- **OIDCTokenFunc** - A function that reads the token from the file when called.

### Example
```go
func ReadJWTFromFileSystem(tokenFilePath string) OIDCTokenFunc {
	return func(ctx context.Context) (string, error) { ... }
}
```
```

--------------------------------

### Azure DevOps Adapter

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/oidcadapters.md

Requests an OIDC token from Azure DevOps using the pipeline environment variables and service connection ID.

```go
func RequestAzureDevOpsOIDCToken(oidcRequestUrl, oidcRequestToken, serviceConnectionId string) OIDCTokenFunc {
	return func(ctx context.Context) (string, error) { ... }
}
```

--------------------------------

### RequestGHOIDCToken

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/oidcadapters.md

Requests an OIDC token from the GitHub Actions OIDC endpoint using the provided request URL and token. Sets audience to sts.accounts.stackit.cloud if not provided.

```APIDOC
## RequestGHOIDCToken

### Description
Requests an OIDC token from the GitHub Actions OIDC endpoint (https://token.actions.githubusercontent.com) using a GitHub Actions ACTIONS_ID_TOKEN_REQUEST_URL and ACTIONS_ID_TOKEN_REQUEST_TOKEN. Sets audience=sts.accounts.stackit.cloud if not provided additions.

### Function Signature
func RequestGHOIDCToken(oidcRequestUrl, oidcRequestToken string) OIDCTokenFunc

### Parameters
- **oidcRequestUrl** (string) - Required - The OIDC request URL from GitHub Actions.
- **oidcRequestToken** (string) - Required - The OIDC request token from GitHub Actions.

### Returns
- **OIDCTokenFunc** - A function that requests the token when called.

### Example
```go
func RequestGHOIDCToken(oidcRequestUrl, oidcRequestToken string) OIDCTokenFunc {
	return func(ctx context.Context) (string, error) { ... }
}
```
```

--------------------------------

### TokenResponseBody structure

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/clients.md

Represents the parsed token response received from the STACKIT token endpoint.

```go
type TokenResponseBody struct {
	AccessToken string `json:"access_token"`
	ExpiresIn   int    `json:"expires_in"`
	// Deprecated: RefreshToken is no longer used. Will be removed after 2026-07-01.
	RefreshToken string `json:"refresh_token"`
	Scope        string `json:"scope"`
	TokenType    string `json:"token_type"`
}
```

--------------------------------

### RequestAzureDevOpsOIDCToken

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/oidcadapters.md

Requests an OIDC token from Azure DevOps using the OIDC request URL and token, with audience and service connection ID handling.

```APIDOC
## RequestAzureDevOpsOIDCToken

### Description
Requests an OIDC token from Azure DevOps using OIDC request URL + token (usually passed via the pipeline environment), with audience and service connection ID handling.

### Function Signature
func RequestAzureDevOpsOIDCToken(oidcRequestUrl, oidcRequestToken, serviceConnectionId string) OIDCTokenFunc

### Parameters
- **oidcRequestUrl** (string) - Required - The OIDC request URL from Azure DevOps.
- **oidcRequestToken** (string) - Required - The OIDC request token from Azure DevOps.
- **serviceConnectionId** (string) - Required - The service connection ID for Azure DevOps.

### Returns
- **OIDCTokenFunc** - A function that requests the token when called.

### Example
```go
func RequestAzureDevOpsOIDCToken(oidcRequestUrl, oidcRequestToken, serviceConnectionId string) OIDCTokenFunc {
	return func(ctx context.Context) (string, error) { ... }
}
```
```

--------------------------------

### GenericOpenAPIError methods

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/oapierror.md

Exported methods on GenericOpenAPIError for retrieving error details and formatting error messages.

```APIDOC
## GenericOpenAPIError Methods

### Description
Methods to access error information and format error messages.

### Methods
- `func (e *GenericOpenAPIError) Error() string` - Returns a formatted error message: "<status>, status code <code>, Body: <body>" (truncated to ApiErrorMaxCharacterLimit, default 500).
- `func (e *GenericOpenAPIError) GetStatusCode() int` - Returns the HTTP status code.
- `func (e *GenericOpenAPIError) GetBody() []byte` - Returns the raw response body.
- `func (e *GenericOpenAPIError) GetModel() interface{}` - Returns the parsed error response model.
- `func FormatErrorMessage(status string, v interface{}) string` - Renders the model description for RFC7807 error responses (reads Title/Detail fields if present).
```

--------------------------------

### AuthFlow interface definition

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/clients.md

The AuthFlow interface defines the required methods for authentication flows, including token retrieval and refresh mechanisms.

```go
type AuthFlow interface {
	RoundTrip(req *http.Request) (*http.Response, error)
	GetAccessToken() (string, error)
	getBackgroundTokenRefreshContext() context.Context
	refreshAccessToken() error
}
```

--------------------------------

### OIDC Adapter Types

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/oidcadapters.md

Defines the OIDCTokenFunc function type and OIDCAdapter interface used by all adapters in core/oidcadapters/types.go.

```go
package oidcadapters

type OIDCTokenFunc func(context.Context) (string, error)

type OIDCAdapter interface{ GetToken(ctx context.Context) (string, error) }
```

--------------------------------

### KeyFlow — clients.KeyFlow

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/clients.md

The KeyFlow uses a service account key (RSA) to obtain a short-lived access token via JWT bearer assertion. It implements the AuthFlow interface and can be plugged into a custom http.Client.

```APIDOC
## KeyFlow — clients.KeyFlow

### Description
The KeyFlow authentication flow uses a service account key (RSA) to obtain a short-lived access token via JWT bearer assertion. It implements the AuthFlow interface.

### Configuration
```go
type KeyFlowConfig struct {
	ServiceAccountKey       *ServiceAccountKeyResponse
	PrivateKey              string
	TokenUrl                string // defaults to https://service-account.api.stackit.cloud/token
	ClientRetry             *RetryConfig // Deprecated
	BackgroundTokenRefreshContext context.Context // enables continuous refresh
	HTTPTransport    http.RoundTripper
	AuthHTTPClient   *http.Client
}
```

### Exported Methods
- **Init(cfg *KeyFlowConfig) error** - Initializes the KeyFlow with the given configuration.
- **GetConfig() KeyFlowConfig** - Returns the current configuration.
- **SetToken(accessToken, refreshToken string) error** - Deprecated: Sets the access and refresh tokens.
- **GetAccessToken() (string, error)** - Returns the current access token.
- **RoundTrip(req *http.Request) (*http.Response, error)** - Executes a single HTTP transaction with authentication applied.

### ServiceAccountKeyResponse
```go
type ServiceAccountKeyResponse struct {
	Active       bool                          `json:"active"`
	CreatedAt    time.Time                     `json:"createdAt"`
	Credentials  *ServiceAccountKeyCredentials `json:"credentials"`
	ID           uuid.UUID                     `json:"id"`
	KeyAlgorithm string                        `json:"keyAlgorithm"`
	KeyOrigin    string                        `json:"keyOrigin"`
	KeyType      string                        `json:"keyType"`
	PublicKey    string                        `json:"publicKey"`
	ValidUntil   *time.Time                    `json:"validUntil,omitempty"`
}
```

### ServiceAccountKeyCredentials
```go
type ServiceAccountKeyCredentials struct {
	Aud           string    `json:"aud"`
	Iss           string    `json:"iss"`
	Kid           string    `json:"kid"`
	PrivateKey    *string   `json:"privateKey,omitempty"`
	Sub           uuid.UUID `json:"sub"`
	TokenEndpoint string    `json:"tokenEndpoint"`
}
```
```

--------------------------------

### GetTraceId

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/runtime.md

Reads the X-trace-id header from the last captured response. Requires that WithCaptureHTTPResponse was called for the same context.

```APIDOC
## GetTraceId

### Description
Reads the X-trace-id header from the last captured response. Prerequisite: WithCaptureHTTPResponse was called for the same context.

### Function Signature
func GetTraceId(ctx context.Context) string

### Parameters
- **ctx** (context.Context) - Required - The context that has the captured response annotation.

### Returns
- **string** - The trace ID from the X-trace-id header.

### Usage Example
```go
traceId := runtime.GetTraceId(ctx)
```
```

--------------------------------

### GenericOpenAPIError struct and constructors

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/oapierror.md

Defines the GenericOpenAPIError type and its constructor helpers for creating error instances with status code and optional body.

```APIDOC
## GenericOpenAPIError

### Description
Represents an error returned by STACKIT services when the upstream API responds with a non-2xx status. Implements the error interface.

### Type Definition
```go
type GenericOpenAPIError struct {
	StatusCode   int
	Body         []byte
	ErrorMessage string
	Model        interface{}
}
```

### Constructors
- `func NewError(code int, status string) *GenericOpenAPIError`
- `func NewErrorWithBody(code int, status string, body []byte, model any) *GenericOpenAPIError`

### Fields
- **StatusCode** (int) - The HTTP status code of the error response.
- **Body** ([]byte) - The raw response body.
- **ErrorMessage** (string) - A formatted error message.
- **Model** (interface{}) - The parsed error response model, if provided by the generator.
```

--------------------------------

### OIDCTokenFunc and OIDCAdapter types

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/oidcadapters.md

Defines the OIDCTokenFunc function type and the OIDCAdapter interface used for obtaining OIDC tokens.

```APIDOC
## OIDCTokenFunc and OIDCAdapter types

### Description
Defines the OIDCTokenFunc function type and the OIDCAdapter interface used for obtaining OIDC tokens.

### Type Definitions
- **OIDCTokenFunc** (func(context.Context) (string, error)) - Function type that returns an OIDC token string or an error.
- **OIDCAdapter** (interface) - Interface with method GetToken(ctx context.Context) (string, error).

### Usage
OIDCTokenFunc is consumed by config.WithWorkloadIdentityFederationFunc. OIDCAdapter implementations provide GetToken method.

### Example
```go
package oidcadapters

type OIDCTokenFunc func(context.Context) (string, error)

type OIDCAdapter interface{ GetToken(ctx context.Context) (string, error) }
```
```

--------------------------------

### GenericOpenAPIError struct definition

Source: https://github.com/stackitcloud/stackit-sdk-go/blob/main/_autodocs/api-reference/oapierror.md

The structure of the error type returned by service Execute methods.

```go
type GenericOpenAPIError struct {
	StatusCode   int
	Body         []byte
	ErrorMessage string
	Model        interface{}
}
```
Tokens:
Raw