fix: add involves edge from task to agent:nomos at creation

Plus sync vendor directory for Docker build compatibility.

vendor/github.com/infisical/go-sdk/packages/api/auth/aws_iam_auth_login.go

@@ -0,0 +1,31 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callAWSIamAuthLoginOperation = "CallAWSIamAuthLogin"
+
+func CallAWSIamAuthLogin(httpClient *resty.Client, request AwsIamAuthLoginRequest) (credential MachineIdentityAuthLoginResponse, e error) {
+	var responseData MachineIdentityAuthLoginResponse
+
+	clonedClient := httpClient.Clone()
+	clonedClient.SetAuthToken("")
+	clonedClient.SetAuthScheme("")
+
+	response, err := clonedClient.R().
+		SetResult(&responseData).
+		SetBody(request).
+		Post("/v1/auth/aws-auth/login")
+
+	if err != nil {
+		return MachineIdentityAuthLoginResponse{}, errors.NewRequestError(callAWSIamAuthLoginOperation, err)
+	}
+
+	if response.IsError() {
+		return MachineIdentityAuthLoginResponse{}, errors.NewAPIErrorWithResponse(callAWSIamAuthLoginOperation, response)
+	}
+
+	return responseData, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/auth/azure_auth_login.go

@@ -0,0 +1,31 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const azureAuthLoginOperation = "CallAzureAuthLogin"
+
+func CallAzureAuthLogin(httpClient *resty.Client, request AzureAuthLoginRequest) (credential MachineIdentityAuthLoginResponse, e error) {
+	var responseData MachineIdentityAuthLoginResponse
+
+	clonedClient := httpClient.Clone()
+	clonedClient.SetAuthToken("")
+	clonedClient.SetAuthScheme("")
+
+	response, err := clonedClient.R().
+		SetResult(&responseData).
+		SetBody(request).
+		Post("/v1/auth/azure-auth/login")
+
+	if err != nil {
+		return MachineIdentityAuthLoginResponse{}, errors.NewRequestError(azureAuthLoginOperation, err)
+	}
+
+	if response.IsError() {
+		return MachineIdentityAuthLoginResponse{}, errors.NewAPIErrorWithResponse(azureAuthLoginOperation, response)
+	}
+
+	return responseData, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/auth/gcp_id_token_auth_login.go

@@ -0,0 +1,31 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callGCPAuthLoginOperation = "CallGCPAuthLogin"
+
+func CallGCPAuthLogin(httpClient *resty.Client, request GCPAuthLoginRequest) (credential MachineIdentityAuthLoginResponse, e error) {
+	var responseData MachineIdentityAuthLoginResponse
+
+	clonedClient := httpClient.Clone()
+	clonedClient.SetAuthToken("")
+	clonedClient.SetAuthScheme("")
+
+	response, err := clonedClient.R().
+		SetResult(&responseData).
+		SetBody(request).
+		Post("/v1/auth/gcp-auth/login")
+
+	if err != nil {
+		return MachineIdentityAuthLoginResponse{}, errors.NewRequestError(callGCPAuthLoginOperation, err)
+	}
+
+	if response.IsError() {
+		return MachineIdentityAuthLoginResponse{}, errors.NewAPIErrorWithResponse(callGCPAuthLoginOperation, response)
+	}
+
+	return responseData, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/auth/jwt_auth_login.go

@@ -0,0 +1,31 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callJwtAuthLoginOperation = "CallJwtAuthLogin"
+
+func CallJwtAuthLogin(httpClient *resty.Client, request JwtAuthLoginRequest) (credential MachineIdentityAuthLoginResponse, e error) {
+	var responseData MachineIdentityAuthLoginResponse
+
+	clonedClient := httpClient.Clone()
+	clonedClient.SetAuthToken("")
+	clonedClient.SetAuthScheme("")
+
+	response, err := clonedClient.R().
+		SetResult(&responseData).
+		SetBody(request).
+		Post("/v1/auth/jwt-auth/login")
+
+	if err != nil {
+		return responseData, errors.NewRequestError(callJwtAuthLoginOperation, err)
+	}
+
+	if response.IsError() {
+		return responseData, errors.NewAPIErrorWithResponse(callJwtAuthLoginOperation, response)
+	}
+
+	return responseData, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/auth/kubernetes_auth_login.go

@@ -0,0 +1,31 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callKubernetesAuthLoginOperation = "CallKubernetesAuthLogin"
+
+func CallKubernetesAuthLogin(httpClient *resty.Client, request KubernetesAuthLoginRequest) (credential MachineIdentityAuthLoginResponse, e error) {
+	var responseData MachineIdentityAuthLoginResponse
+
+	clonedClient := httpClient.Clone()
+	clonedClient.SetAuthToken("")
+	clonedClient.SetAuthScheme("")
+
+	response, err := clonedClient.R().
+		SetResult(&responseData).
+		SetBody(request).
+		Post("/v1/auth/kubernetes-auth/login")
+
+	if err != nil {
+		return MachineIdentityAuthLoginResponse{}, errors.NewRequestError(callKubernetesAuthLoginOperation, err)
+	}
+
+	if response.IsError() {
+		return MachineIdentityAuthLoginResponse{}, errors.NewAPIErrorWithResponse(callKubernetesAuthLoginOperation, response)
+	}
+
+	return responseData, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/auth/ldap_auth_login.go

@@ -0,0 +1,31 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callLdapAuthLoginOperation = "CallLdapAuthLogin"
+
+func CallLdapAuthLogin(httpClient *resty.Client, request LdapAuthLoginRequest) (credential MachineIdentityAuthLoginResponse, e error) {
+	var responseData MachineIdentityAuthLoginResponse
+
+	clonedClient := httpClient.Clone()
+	clonedClient.SetAuthToken("")
+	clonedClient.SetAuthScheme("")
+
+	response, err := clonedClient.R().
+		SetResult(&responseData).
+		SetBody(request).
+		Post("/v1/auth/ldap-auth/login")
+
+	if err != nil {
+		return MachineIdentityAuthLoginResponse{}, errors.NewRequestError(callLdapAuthLoginOperation, err)
+	}
+
+	if response.IsError() {
+		return MachineIdentityAuthLoginResponse{}, errors.NewAPIErrorWithResponse(callLdapAuthLoginOperation, response)
+	}
+
+	return responseData, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/auth/models.go

@@ -0,0 +1,82 @@
+package api
+
+// JWT auth:
+type JwtAuthLoginRequest struct {
+	IdentityID       string `json:"identityId"`
+	JWT              string `json:"jwt"`
+	OrganizationSlug string `json:"organizationSlug,omitempty"`
+}
+
+// Revoke access token:
+type RevokeAccessTokenRequest struct {
+	AccessToken string `json:"accessToken"`
+}
+
+type RevokeAccessTokenResponse struct {
+	Message string `json:"message"`
+}
+
+// Universal auth:
+type UniversalAuthLoginRequest struct {
+	ClientID         string `json:"clientId"`
+	ClientSecret     string `json:"clientSecret"`
+	OrganizationSlug string `json:"organizationSlug,omitempty"`
+}
+
+// Kubernetes auth:
+type KubernetesAuthLoginRequest struct {
+	IdentityID       string `json:"identityId"`
+	JWT              string `json:"jwt"`
+	OrganizationSlug string `json:"organizationSlug,omitempty"`
+}
+
+type AzureAuthLoginRequest struct {
+	IdentityID       string `json:"identityId"`
+	JWT              string `json:"jwt"`
+	OrganizationSlug string `json:"organizationSlug,omitempty"`
+}
+
+type AwsIamAuthLoginRequest struct {
+	HTTPRequestMethod string `json:"iamHttpRequestMethod"`
+	IamRequestBody    string `json:"iamRequestBody"`
+	IamRequestHeaders string `json:"iamRequestHeaders"`
+	IdentityId        string `json:"identityId"`
+	OrganizationSlug  string `json:"organizationSlug,omitempty"`
+}
+
+type GCPAuthLoginRequest struct {
+	IdentityID       string `json:"identityId"`
+	JWT              string `json:"jwt"`
+	OrganizationSlug string `json:"organizationSlug,omitempty"`
+}
+
+type OidcAuthLoginRequest struct {
+	IdentityID       string `json:"identityId"`
+	JWT              string `json:"jwt"`
+	OrganizationSlug string `json:"organizationSlug,omitempty"`
+}
+
+type MachineIdentityAuthLoginResponse struct {
+	AccessToken       string `json:"accessToken"`
+	ExpiresIn         int64  `json:"expiresIn"`
+	AccessTokenMaxTTL int64  `json:"accessTokenMaxTTL"`
+	TokenType         string `json:"tokenType"`
+}
+
+type RenewAccessTokenRequest struct {
+	AccessToken string `json:"accessToken"`
+}
+
+type OciAuthLoginRequest struct {
+	IdentityID       string            `json:"identityId"`
+	UserOcid         string            `json:"userOcid"`
+	Headers          map[string]string `json:"headers"`
+	OrganizationSlug string            `json:"organizationSlug,omitempty"`
+}
+
+type LdapAuthLoginRequest struct {
+	IdentityID       string `json:"identityId"`
+	Username         string `json:"username"`
+	Password         string `json:"password"`
+	OrganizationSlug string `json:"organizationSlug,omitempty"`
+}

vendor/github.com/infisical/go-sdk/packages/api/auth/oci_auth_login.go

@@ -0,0 +1,31 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callOciAuthLoginOperation = "CallOciAuthLogin"
+
+func CallOciAuthLogin(httpClient *resty.Client, request OciAuthLoginRequest) (credential MachineIdentityAuthLoginResponse, e error) {
+	var responseData MachineIdentityAuthLoginResponse
+
+	clonedClient := httpClient.Clone()
+	clonedClient.SetAuthToken("")
+	clonedClient.SetAuthScheme("")
+
+	response, err := clonedClient.R().
+		SetResult(&responseData).
+		SetBody(request).
+		Post("/v1/auth/oci-auth/login")
+
+	if err != nil {
+		return MachineIdentityAuthLoginResponse{}, errors.NewRequestError(callOciAuthLoginOperation, err)
+	}
+
+	if response.IsError() {
+		return MachineIdentityAuthLoginResponse{}, errors.NewAPIErrorWithResponse(callOciAuthLoginOperation, response)
+	}
+
+	return responseData, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/auth/oidc_auth_login.go

@@ -0,0 +1,31 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callOidcAuthLoginOperation = "CallOidcAuthLogin"
+
+func CallOidcAuthLogin(httpClient *resty.Client, request OidcAuthLoginRequest) (credential MachineIdentityAuthLoginResponse, e error) {
+	var responseData MachineIdentityAuthLoginResponse
+
+	clonedClient := httpClient.Clone()
+	clonedClient.SetAuthToken("")
+	clonedClient.SetAuthScheme("")
+
+	response, err := clonedClient.R().
+		SetResult(&responseData).
+		SetBody(request).
+		Post("/v1/auth/oidc-auth/login")
+
+	if err != nil {
+		return MachineIdentityAuthLoginResponse{}, errors.NewRequestError(callOidcAuthLoginOperation, err)
+	}
+
+	if response.IsError() {
+		return MachineIdentityAuthLoginResponse{}, errors.NewAPIErrorWithResponse(callOidcAuthLoginOperation, response)
+	}
+
+	return responseData, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/auth/renew_access_token.go

@@ -0,0 +1,31 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callRenewAccessToken = "CallRenewAccessToken"
+
+func CallRenewAccessToken(httpClient *resty.Client, request RenewAccessTokenRequest) (credential MachineIdentityAuthLoginResponse, e error) {
+	var responseData MachineIdentityAuthLoginResponse
+
+	clonedClient := httpClient.Clone()
+	clonedClient.SetAuthToken("")
+	clonedClient.SetAuthScheme("")
+
+	response, err := clonedClient.R().
+		SetResult(&responseData).
+		SetBody(request).
+		Post("/v1/auth/token/renew")
+
+	if err != nil {
+		return responseData, errors.NewRequestError(callRenewAccessToken, err)
+	}
+
+	if response.IsError() {
+		return responseData, errors.NewAPIErrorWithResponse(callRenewAccessToken, response)
+	}
+
+	return responseData, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/auth/revoke_access_token.go

@@ -0,0 +1,27 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callRevokeAccessTokenOperation = "CallRevokeAccessToken"
+
+func CallRevokeAccessToken(httpClient *resty.Client, request RevokeAccessTokenRequest) (RevokeAccessTokenResponse, error) {
+	var responseData RevokeAccessTokenResponse
+
+	response, err := httpClient.R().
+		SetResult(&responseData).
+		SetBody(request).
+		Post("/v1/auth/token/revoke")
+
+	if err != nil {
+		return responseData, errors.NewRequestError(callRevokeAccessTokenOperation, err)
+	}
+
+	if response.IsError() {
+		return responseData, errors.NewAPIErrorWithResponse(callRevokeAccessTokenOperation, response)
+	}
+
+	return responseData, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/auth/universal_auth_login.go

@@ -0,0 +1,31 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callUniversalAuthLoginOperation = "CallUniversalAuthLogin"
+
+func CallUniversalAuthLogin(httpClient *resty.Client, request UniversalAuthLoginRequest) (credential MachineIdentityAuthLoginResponse, e error) {
+	var responseData MachineIdentityAuthLoginResponse
+
+	clonedClient := httpClient.Clone()
+	clonedClient.SetAuthToken("")
+	clonedClient.SetAuthScheme("")
+
+	response, err := clonedClient.R().
+		SetResult(&responseData).
+		SetBody(request).
+		Post("/v1/auth/universal-auth/login")
+
+	if err != nil {
+		return responseData, errors.NewRequestError(callUniversalAuthLoginOperation, err)
+	}
+
+	if response.IsError() {
+		return responseData, errors.NewAPIErrorWithResponse(callUniversalAuthLoginOperation, response)
+	}
+
+	return responseData, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/dynamic_secrets/create_lease.go

@@ -0,0 +1,29 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callCreateDynamicSecretLeaseV1Operation = "CallCreateDynamicSecretLeaseV1"
+
+func CallCreateDynamicSecretLeaseV1(httpClient *resty.Client, request CreateDynamicSecretLeaseV1Request) (CreateDynamicSecretLeaseV1Response, error) {
+
+	createResponse := CreateDynamicSecretLeaseV1Response{}
+
+	req := httpClient.R().
+		SetResult(&createResponse).
+		SetBody(request)
+
+	res, err := req.Post("/v1/dynamic-secrets/leases")
+
+	if err != nil {
+		return CreateDynamicSecretLeaseV1Response{}, errors.NewRequestError(callCreateDynamicSecretLeaseV1Operation, err)
+	}
+
+	if res.IsError() {
+		return CreateDynamicSecretLeaseV1Response{}, errors.NewAPIErrorWithResponse(callCreateDynamicSecretLeaseV1Operation, res)
+	}
+
+	return createResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/dynamic_secrets/delete_lease.go

@@ -0,0 +1,29 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callDeleteDynamicSecretLeaseV1Operation = "CallDeleteDynamicSecretLeaseV1"
+
+func CallDeleteDynamicSecretLeaseV1(httpClient *resty.Client, request DeleteDynamicSecretLeaseV1Request) (DeleteDynamicSecretLeaseV1Response, error) {
+
+	deleteResponse := DeleteDynamicSecretLeaseV1Response{}
+
+	req := httpClient.R().
+		SetResult(&deleteResponse).
+		SetBody(request)
+
+	res, err := req.Delete("/v1/dynamic-secrets/leases/" + request.LeaseId)
+
+	if err != nil {
+		return DeleteDynamicSecretLeaseV1Response{}, errors.NewRequestError(callDeleteDynamicSecretLeaseV1Operation, err)
+	}
+
+	if res.IsError() {
+		return DeleteDynamicSecretLeaseV1Response{}, errors.NewAPIErrorWithResponse(callDeleteDynamicSecretLeaseV1Operation, res)
+	}
+
+	return deleteResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/dynamic_secrets/get_lease_by_id.go

@@ -0,0 +1,33 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callGetDynamicSecretLeaseByIdV1Operation = "CallGetDynamicSecretLeaseByIdV1"
+
+func CallGetByDynamicSecretByIdLeaseV1(httpClient *resty.Client, request GetDynamicSecretLeaseByIdV1Request) (GetDynamicSecretLeaseByIdV1Response, error) {
+
+	getByIdResponse := GetDynamicSecretLeaseByIdV1Response{}
+
+	req := httpClient.R().
+		SetResult(&getByIdResponse).
+		SetQueryParams(map[string]string{
+			"projectSlug":     request.ProjectSlug,
+			"environmentSlug": request.EnvironmentSlug,
+			"path":            request.SecretPath,
+		})
+
+	res, err := req.Get("/v1/dynamic-secrets/leases/" + request.LeaseId)
+
+	if err != nil {
+		return GetDynamicSecretLeaseByIdV1Response{}, errors.NewRequestError(callGetDynamicSecretLeaseByIdV1Operation, err)
+	}
+
+	if res.IsError() {
+		return GetDynamicSecretLeaseByIdV1Response{}, errors.NewAPIErrorWithResponse(callGetDynamicSecretLeaseByIdV1Operation, res)
+	}
+
+	return getByIdResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/dynamic_secrets/get_secret_by_name.go

@@ -0,0 +1,32 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callGetDynamicSecretByNameV1Operation = "CallGetDynamicSecretSecretByNameV1"
+
+func CallGetDynamicSecretByNameV1(httpClient *resty.Client, request GetDynamicSecretByNameV1Request) (GetDynamicSecretByNameV1Response, error) {
+
+	getByNameResponse := GetDynamicSecretByNameV1Response{}
+
+	req := httpClient.R().
+		SetResult(&getByNameResponse).SetQueryParams(map[string]string{
+		"projectSlug":     request.ProjectSlug,
+		"environmentSlug": request.EnvironmentSlug,
+		"path":            request.SecretPath,
+	})
+
+	res, err := req.Get("/v1/dynamic-secrets/" + request.DynamicSecretName)
+
+	if err != nil {
+		return GetDynamicSecretByNameV1Response{}, errors.NewRequestError(callGetDynamicSecretByNameV1Operation, err)
+	}
+
+	if res.IsError() {
+		return GetDynamicSecretByNameV1Response{}, errors.NewAPIErrorWithResponse(callGetDynamicSecretByNameV1Operation, res)
+	}
+
+	return getByNameResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/dynamic_secrets/list_lease.go

@@ -0,0 +1,33 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callListDynamicSecretLeaseV1Operation = "CallListDynamicSecretLeaseV1"
+
+func CallListDynamicSecretLeaseV1(httpClient *resty.Client, request ListDynamicSecretLeaseV1Request) (ListDynamicSecretLeaseV1Response, error) {
+
+	listResponse := ListDynamicSecretLeaseV1Response{}
+
+	req := httpClient.R().
+		SetResult(&listResponse).
+		SetQueryParams(map[string]string{
+			"projectSlug":     request.ProjectSlug,
+			"environmentSlug": request.EnvironmentSlug,
+			"path":            request.SecretPath,
+		})
+
+	res, err := req.Get("/v1/dynamic-secrets/" + request.DynamicSecretName + "/leases")
+
+	if err != nil {
+		return ListDynamicSecretLeaseV1Response{}, errors.NewRequestError(callListDynamicSecretLeaseV1Operation, err)
+	}
+
+	if res.IsError() {
+		return ListDynamicSecretLeaseV1Response{}, errors.NewAPIErrorWithResponse(callListDynamicSecretLeaseV1Operation, res)
+	}
+
+	return listResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/dynamic_secrets/list_secrets.go

@@ -0,0 +1,33 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callListDynamicSecretsV1Operation = "CallListDynamicSecretSecretsV1"
+
+func CallListDynamicSecretsV1(httpClient *resty.Client, request ListDynamicSecretsV1Request) (ListDynamicSecretsV1Response, error) {
+
+	listDynamicSecretResponse := ListDynamicSecretsV1Response{}
+
+	req := httpClient.R().
+		SetResult(&listDynamicSecretResponse).
+		SetQueryParams(map[string]string{
+			"projectSlug":     request.ProjectSlug,
+			"environmentSlug": request.EnvironmentSlug,
+			"path":            request.SecretPath,
+		})
+
+	res, err := req.Get("/v1/dynamic-secrets")
+
+	if err != nil {
+		return ListDynamicSecretsV1Response{}, errors.NewRequestError(callListDynamicSecretsV1Operation, err)
+	}
+
+	if res.IsError() {
+		return ListDynamicSecretsV1Response{}, errors.NewAPIErrorWithResponse(callListDynamicSecretsV1Operation, res)
+	}
+
+	return listDynamicSecretResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/dynamic_secrets/models.go

@@ -0,0 +1,88 @@
+package api
+
+import (
+	"github.com/infisical/go-sdk/packages/models"
+)
+
+type CreateDynamicSecretLeaseV1Request struct {
+	DynamicSecretName string         `json:"dynamicSecretName"`
+	ProjectSlug       string         `json:"projectSlug"`
+	TTL               string         `json:"ttl"`
+	SecretPath        string         `json:"path"`
+	EnvironmentSlug   string         `json:"environmentSlug"`
+	Config            map[string]any `json:"config"`
+}
+
+type CreateDynamicSecretLeaseV1Response struct {
+	Lease         models.DynamicSecretLease `json:"lease"`
+	DynamicSecret models.DynamicSecret      `json:"dynamicSecret"`
+	Data          map[string]any            `json:"data"`
+}
+
+type DeleteDynamicSecretLeaseV1Request struct {
+	LeaseId         string `json:"leaseId"`
+	ProjectSlug     string `json:"projectSlug"`
+	SecretPath      string `json:"path"`
+	EnvironmentSlug string `json:"environmentSlug"`
+	IsForced        bool   `json:"isForced"`
+}
+
+type DeleteDynamicSecretLeaseV1Response struct {
+	Lease models.DynamicSecretLease `json:"lease"`
+}
+
+type RenewDynamicSecretLeaseV1Request struct {
+	LeaseId         string `json:"leaseId"`
+	TTL             string `json:"ttl"`
+	ProjectSlug     string `json:"projectSlug"`
+	SecretPath      string `json:"path"`
+	EnvironmentSlug string `json:"environmentSlug"`
+	IsForced        bool   `json:"isForced"`
+}
+
+type RenewDynamicSecretLeaseV1Response struct {
+	Lease models.DynamicSecretLease `json:"lease"`
+}
+
+type GetDynamicSecretLeaseByIdV1Request struct {
+	LeaseId         string `json:"leaseId"`
+	ProjectSlug     string `json:"projectSlug"`
+	SecretPath      string `json:"path"`
+	EnvironmentSlug string `json:"environmentSlug"`
+}
+
+type GetDynamicSecretLeaseByIdV1Response struct {
+	Lease models.DynamicSecretLeaseWithDynamicSecret `json:"lease"`
+}
+
+type ListDynamicSecretLeaseV1Request struct {
+	DynamicSecretName string `json:"secretName"`
+	ProjectSlug       string `json:"projectSlug"`
+	SecretPath        string `json:"path"`
+	EnvironmentSlug   string `json:"environmentSlug"`
+}
+
+type ListDynamicSecretLeaseV1Response struct {
+	Leases []models.DynamicSecretLease `json:"leases"`
+}
+
+type GetDynamicSecretByNameV1Request struct {
+	DynamicSecretName string `json:"secretName"`
+	ProjectSlug       string `json:"projectSlug"`
+	SecretPath        string `json:"path"`
+	EnvironmentSlug   string `json:"environmentSlug"`
+}
+
+type GetDynamicSecretByNameV1Response struct {
+	DynamicSecret models.DynamicSecret `json:"dynamicSecret"`
+}
+
+type ListDynamicSecretsV1Request struct {
+	ProjectSlug     string `json:"projectSlug"`
+	SecretPath      string `json:"path"`
+	EnvironmentSlug string `json:"environmentSlug"`
+}
+
+type ListDynamicSecretsV1Response struct {
+	DynamicSecrets []models.DynamicSecret `json:"dynamicSecrets"`
+}

vendor/github.com/infisical/go-sdk/packages/api/dynamic_secrets/renew_lease.go

@@ -0,0 +1,29 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callRenewDynamicSecretLeaseV1Operation = "CallRenewDynamicSecretLeaseV1"
+
+func CallRenewDynamicSecretLeaseV1(httpClient *resty.Client, request RenewDynamicSecretLeaseV1Request) (RenewDynamicSecretLeaseV1Response, error) {
+
+	renewResponse := RenewDynamicSecretLeaseV1Response{}
+
+	req := httpClient.R().
+		SetResult(&renewResponse).
+		SetBody(request)
+
+	res, err := req.Post("/v1/dynamic-secrets/leases/" + request.LeaseId + "/renew")
+
+	if err != nil {
+		return RenewDynamicSecretLeaseV1Response{}, errors.NewRequestError(callRenewDynamicSecretLeaseV1Operation, err)
+	}
+
+	if res.IsError() {
+		return RenewDynamicSecretLeaseV1Response{}, errors.NewAPIErrorWithResponse(callRenewDynamicSecretLeaseV1Operation, res)
+	}
+
+	return renewResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/folders/create_folder.go

@@ -0,0 +1,29 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callCreateFolderV1Operation = "CallCreateFolderV1"
+
+func CallCreateFolderV1(httpClient *resty.Client, request CreateFolderV1Request) (CreateFolderV1Response, error) {
+
+	createResponse := CreateFolderV1Response{}
+
+	req := httpClient.R().
+		SetResult(&createResponse).
+		SetBody(request)
+
+	res, err := req.Post("/v1/folders")
+
+	if err != nil {
+		return CreateFolderV1Response{}, errors.NewRequestError(callCreateFolderV1Operation, err)
+	}
+
+	if res.IsError() {
+		return CreateFolderV1Response{}, errors.NewAPIErrorWithResponse(callCreateFolderV1Operation, res)
+	}
+
+	return createResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/folders/delete_folder.go

@@ -0,0 +1,41 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callDeleteFolderV1Operation = "CallDeleteFolderV1"
+
+func CallDeleteFolderV1(httpClient *resty.Client, request DeleteFolderV1Request) (DeleteFolderV1Response, error) {
+
+	deleteResponse := DeleteFolderV1Response{}
+
+	// Either folderID or folderName must be provided
+	var folderIdOrName string
+	if request.FolderID != "" {
+		folderIdOrName = request.FolderID
+	} else if request.FolderName != "" {
+		folderIdOrName = request.FolderName
+	} else {
+		return DeleteFolderV1Response{}, fmt.Errorf("CallDeleteFolderV1: Either folderID or folderName must be provided")
+	}
+
+	req := httpClient.R().
+		SetResult(&deleteResponse).
+		SetBody(request)
+
+	res, err := req.Delete(fmt.Sprintf("/v1/folders/%s", folderIdOrName))
+
+	if err != nil {
+		return DeleteFolderV1Response{}, errors.NewRequestError(callDeleteFolderV1Operation, err)
+	}
+
+	if res.IsError() {
+		return DeleteFolderV1Response{}, errors.NewAPIErrorWithResponse(callDeleteFolderV1Operation, res)
+	}
+
+	return deleteResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/folders/list_folders.go

@@ -0,0 +1,36 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callListFoldersV1Operation = "CallListFoldersV1"
+
+func CallListFoldersV1(httpClient *resty.Client, request ListFoldersV1Request) (ListFoldersV1Response, error) {
+
+	secretsResponse := ListFoldersV1Response{}
+
+	queryParams := map[string]string{
+		"workspaceId": request.ProjectID,
+		"environment": request.Environment,
+	}
+
+	if request.Path != "" {
+		queryParams["path"] = request.Path
+	}
+
+	res, err := httpClient.R().
+		SetResult(&secretsResponse).
+		SetQueryParams(queryParams).Get("/v1/folders")
+
+	if err != nil {
+		return ListFoldersV1Response{}, errors.NewRequestError(callListFoldersV1Operation, err)
+	}
+
+	if res.IsError() {
+		return ListFoldersV1Response{}, errors.NewAPIErrorWithResponse(callListFoldersV1Operation, res)
+	}
+
+	return secretsResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/folders/models.go

@@ -0,0 +1,57 @@
+package api
+
+import (
+	"github.com/infisical/go-sdk/packages/models"
+)
+
+// List folders
+type ListFoldersV1Request struct {
+	ProjectID   string `json:"workspaceId"`
+	Environment string `json:"environment"`
+	Path        string `json:"path,omitempty"`
+}
+
+type ListFoldersV1Response struct {
+	Folders []models.Folder `json:"folders"`
+}
+
+// Update folder
+type UpdateFolderV1Request struct {
+	FolderID string `json:"-"`
+
+	ProjectID   string `json:"workspaceId"`
+	Environment string `json:"environment"`
+	NewName     string `json:"name"`
+	Path        string `json:"path,omitempty"`
+}
+
+type UpdateFolderV1Response struct {
+	Folder models.Folder `json:"folder"`
+}
+
+// Create folder
+type CreateFolderV1Request struct {
+	ProjectID   string `json:"workspaceId"`
+	Environment string `json:"environment"`
+	Name        string `json:"name"`
+	Path        string `json:"path,omitempty"`
+}
+
+type CreateFolderV1Response struct {
+	Folder models.Folder `json:"folder"`
+}
+
+// Delete folder
+type DeleteFolderV1Request struct {
+	// Either FolderID or folderName must be provided
+	FolderID   string `json:"-"`
+	FolderName string `json:"-"`
+
+	ProjectID   string `json:"workspaceId"`
+	Environment string `json:"environment"`
+	Path        string `json:"path,omitempty"`
+}
+
+type DeleteFolderV1Response struct {
+	Folder models.Folder `json:"folder"`
+}

vendor/github.com/infisical/go-sdk/packages/api/folders/update_folder.go

@@ -0,0 +1,31 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callUpdateFolderV1Operation = "CallUpdateFolderV1"
+
+func CallUpdateFolderV1(httpClient *resty.Client, request UpdateFolderV1Request) (UpdateFolderV1Response, error) {
+
+	updateResponse := UpdateFolderV1Response{}
+
+	req := httpClient.R().
+		SetResult(&updateResponse).
+		SetBody(request)
+
+	res, err := req.Patch(fmt.Sprintf("/v1/folders/%s", request.FolderID))
+
+	if err != nil {
+		return UpdateFolderV1Response{}, errors.NewRequestError(callUpdateFolderV1Operation, err)
+	}
+
+	if res.IsError() {
+		return UpdateFolderV1Response{}, errors.NewAPIErrorWithResponse(callUpdateFolderV1Operation, res)
+	}
+
+	return updateResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/kms/create_key.go

@@ -0,0 +1,27 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callKmsCreateKeyOperationV1 = "CallKmsCreateKeyV1"
+
+func CallKmsCreateKeyV1(httpClient *resty.Client, request KmsCreateKeyV1Request) (KmsCreateKeyV1Response, error) {
+	kmsCreateKeyResponse := KmsCreateKeyV1Response{}
+
+	res, err := httpClient.R().
+		SetResult(&kmsCreateKeyResponse).
+		SetBody(request).
+		Post("/v1/kms/keys")
+
+	if err != nil {
+		return KmsCreateKeyV1Response{}, errors.NewRequestError(callKmsCreateKeyOperationV1, err)
+	}
+
+	if res.IsError() {
+		return KmsCreateKeyV1Response{}, errors.NewAPIErrorWithResponse(callKmsCreateKeyOperationV1, res)
+	}
+
+	return kmsCreateKeyResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/kms/decrypt_data.go

@@ -0,0 +1,29 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callKmsDecryptDataOperationV1 = "CallKmsDecryptDataV1"
+
+func CallKmsDecryptDataV1(httpClient *resty.Client, request KmsDecryptDataV1Request) (KmsDecryptDataV1Response, error) {
+	kmsDecryptDataResponse := KmsDecryptDataV1Response{}
+
+	res, err := httpClient.R().
+		SetResult(&kmsDecryptDataResponse).
+		SetBody(request).
+		Post(fmt.Sprintf("/v1/kms/keys/%s/decrypt", request.KeyId))
+
+	if err != nil {
+		return KmsDecryptDataV1Response{}, errors.NewRequestError(callKmsDecryptDataOperationV1, err)
+	}
+
+	if res.IsError() {
+		return KmsDecryptDataV1Response{}, errors.NewAPIErrorWithResponse(callKmsDecryptDataOperationV1, res)
+	}
+
+	return kmsDecryptDataResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/kms/delete_key.go

@@ -0,0 +1,29 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callKmsDeleteKeyOperationV1 = "CallKmsDeleteKeyV1"
+
+func CallKmsDeleteKeyV1(httpClient *resty.Client, request KmsDeleteKeyV1Request) (KmsDeleteKeyV1Response, error) {
+	kmsDeleteKeyResponse := KmsDeleteKeyV1Response{}
+
+	res, err := httpClient.R().
+		SetResult(&kmsDeleteKeyResponse).
+		SetBody(request).
+		Delete(fmt.Sprintf("/v1/kms/keys/%s", request.KeyId))
+
+	if err != nil {
+		return KmsDeleteKeyV1Response{}, errors.NewRequestError(callKmsDeleteKeyOperationV1, err)
+	}
+
+	if res.IsError() {
+		return KmsDeleteKeyV1Response{}, errors.NewAPIErrorWithResponse(callKmsDeleteKeyOperationV1, res)
+	}
+
+	return kmsDeleteKeyResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/kms/encrypt_data.go

@@ -0,0 +1,29 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callKmsEncryptDataOperationV1 = "CallKmsEncryptDataV1"
+
+func CallKmsEncryptDataV1(httpClient *resty.Client, request KmsEncryptDataV1Request) (KmsEncryptDataV1Response, error) {
+	kmsEncryptDataResponse := KmsEncryptDataV1Response{}
+
+	res, err := httpClient.R().
+		SetResult(&kmsEncryptDataResponse).
+		SetBody(request).
+		Post(fmt.Sprintf("/v1/kms/keys/%s/encrypt", request.KeyId))
+
+	if err != nil {
+		return KmsEncryptDataV1Response{}, errors.NewRequestError(callKmsEncryptDataOperationV1, err)
+	}
+
+	if res.IsError() {
+		return KmsEncryptDataV1Response{}, errors.NewAPIErrorWithResponse(callKmsEncryptDataOperationV1, res)
+	}
+
+	return kmsEncryptDataResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/kms/get_key_by_name.go

@@ -0,0 +1,28 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callKmsGetKeyByNameOperationV1 = "CallKmsGetKeyByNameV1"
+
+func CallKmsGetKeyByNameV1(httpClient *resty.Client, request KmsGetKeyByNameV1Request) (KmsGetKeyV1Response, error) {
+	kmsGetKeyByNameResponse := KmsGetKeyV1Response{}
+
+	res, err := httpClient.R().
+		SetResult(&kmsGetKeyByNameResponse).
+		Get(fmt.Sprintf("/v1/kms/keys/key-name/%s?projectId=%s", request.KeyName, request.ProjectId))
+
+	if err != nil {
+		return KmsGetKeyV1Response{}, errors.NewRequestError(callKmsGetKeyByNameOperationV1, err)
+	}
+
+	if res.IsError() {
+		return KmsGetKeyV1Response{}, errors.NewAPIErrorWithResponse(callKmsGetKeyByNameOperationV1, res)
+	}
+
+	return kmsGetKeyByNameResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/kms/get_public_key.go

@@ -0,0 +1,28 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callKmsGetPublicKeyOperationV1 = "CallKmsGetPublicKeyV1"
+
+func CallKmsGetPublicKeyV1(httpClient *resty.Client, request KmsGetPublicKeyV1Request) (KmsGetPublicKeyV1Response, error) {
+	kmsGetPublicKeyResponse := KmsGetPublicKeyV1Response{}
+
+	res, err := httpClient.R().
+		SetResult(&kmsGetPublicKeyResponse).
+		Get(fmt.Sprintf("/v1/kms/keys/%s/public-key", request.KeyId))
+
+	if err != nil {
+		return KmsGetPublicKeyV1Response{}, errors.NewRequestError(callKmsGetPublicKeyOperationV1, err)
+	}
+
+	if res.IsError() {
+		return KmsGetPublicKeyV1Response{}, errors.NewAPIErrorWithResponse(callKmsGetPublicKeyOperationV1, res)
+	}
+
+	return kmsGetPublicKeyResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/kms/get_signing_algorithms.go

@@ -0,0 +1,29 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callKmsGetSigningAlgorithmsOperationV1 = "CallKmsGetSigningAlgorithmsV1"
+
+func CallKmsGetSigningAlgorithmsV1(httpClient *resty.Client, request KmsListSigningAlgorithmsV1Request) (KmsListSigningAlgorithmsV1Response, error) {
+	kmsListSigningAlgorithmsResponse := KmsListSigningAlgorithmsV1Response{}
+
+	res, err := httpClient.R().
+		SetResult(&kmsListSigningAlgorithmsResponse).
+		Get(fmt.Sprintf("/v1/kms/keys/%s/signing-algorithms", request.KeyId))
+
+	if err != nil {
+		return KmsListSigningAlgorithmsV1Response{}, errors.NewRequestError(callKmsGetSigningAlgorithmsOperationV1, err)
+	}
+
+	if res.IsError() {
+		return KmsListSigningAlgorithmsV1Response{}, errors.NewAPIErrorWithResponse(callKmsGetSigningAlgorithmsOperationV1, res)
+	}
+
+	return kmsListSigningAlgorithmsResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/kms/models.go

@@ -0,0 +1,114 @@
+package api
+
+type KmsEncryptDataV1Request struct {
+	KeyId     string
+	Plaintext string `json:"plaintext"`
+}
+
+type KmsEncryptDataV1Response struct {
+	Ciphertext string `json:"ciphertext"`
+}
+
+type KmsDecryptDataV1Request struct {
+	KeyId      string
+	Ciphertext string `json:"ciphertext"`
+}
+
+type KmsDecryptDataV1Response struct {
+	Plaintext string `json:"plaintext"`
+}
+
+type KmsSignDataV1Request struct {
+	KeyId            string
+	Data             string `json:"data"`
+	SigningAlgorithm string `json:"signingAlgorithm"`
+	IsDigest         bool   `json:"isDigest"`
+}
+
+type KmsSignDataV1Response struct {
+	Signature        string `json:"signature"`
+	KeyId            string `json:"keyId"`
+	SigningAlgorithm string `json:"signingAlgorithm"`
+}
+
+type KmsVerifyDataV1Request struct {
+	KeyId            string
+	Data             string `json:"data"` // Data must be base64 encoded
+	Signature        string `json:"signature"`
+	SigningAlgorithm string `json:"signingAlgorithm"`
+	IsDigest         bool   `json:"isDigest"`
+}
+
+type KmsVerifyDataV1Response struct {
+	SignatureValid   bool   `json:"signatureValid"`
+	KeyId            string `json:"keyId"`
+	SigningAlgorithm string `json:"signingAlgorithm"`
+}
+
+type KmsListSigningAlgorithmsV1Request struct {
+	KeyId string
+}
+
+type KmsListSigningAlgorithmsV1Response struct {
+	SigningAlgorithms []string `json:"signingAlgorithms"`
+}
+
+type KmsGetPublicKeyV1Request struct {
+	KeyId string
+}
+
+type KmsGetPublicKeyV1Response struct {
+	PublicKey string `json:"publicKey"`
+}
+
+type KmsCreateKeyV1Request struct {
+	// KeyUsage is the usage of the key. Can be either sign-verify or encrypt-decrypt
+	KeyUsage string `json:"keyUsage"`
+
+	// Description is the description of the key.
+	Description string `json:"description"`
+
+	// Name is the name of the key.
+	Name string `json:"name"`
+
+	// EncryptionAlgorithm is the algorithm that will be used for the key itself.
+	// `sign-verify algorithms`: `rsa-4096`, `ecc-nist-p256`
+	// `encrypt-decrypt algorithms`: `aes-256-gcm`, `aes-128-gcm`
+	EncryptionAlgorithm string `json:"encryptionAlgorithm"`
+
+	// ProjectId is the project ID that the key will be created in.
+	ProjectId string `json:"projectId"`
+}
+
+type KmsCreateKeyV1Response struct {
+	Key KmsKey `json:"key"`
+}
+
+type KmsDeleteKeyV1Request struct {
+	KeyId string
+}
+
+type KmsDeleteKeyV1Response struct {
+	Key KmsKey `json:"key"`
+}
+
+type KmsGetKeyByNameV1Request struct {
+	KeyName   string
+	ProjectId string
+}
+
+type KmsGetKeyV1Response struct {
+	Key KmsKey `json:"key"`
+}
+
+type KmsKey struct {
+	KeyId               string `json:"id"`
+	Description         string `json:"description"`
+	IsDisabled          bool   `json:"isDisabled"`
+	OrgId               string `json:"orgId"`
+	Name                string `json:"name"`
+	ProjectId           string `json:"projectId"`
+	KeyUsage            string `json:"keyUsage"`
+	Version             int    `json:"version"`
+	EncryptionAlgorithm string `json:"encryptionAlgorithm"`
+}

vendor/github.com/infisical/go-sdk/packages/api/kms/sign_data.go

@@ -0,0 +1,29 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callKmsSignDataOperationV1 = "CallKmsSignDataV1"
+
+func CallKmsSignDataV1(httpClient *resty.Client, request KmsSignDataV1Request) (KmsSignDataV1Response, error) {
+	kmsSignDataResponse := KmsSignDataV1Response{}
+
+	res, err := httpClient.R().
+		SetResult(&kmsSignDataResponse).
+		SetBody(request).
+		Post(fmt.Sprintf("/v1/kms/keys/%s/sign", request.KeyId))
+
+	if err != nil {
+		return KmsSignDataV1Response{}, errors.NewRequestError(callKmsSignDataOperationV1, err)
+	}
+
+	if res.IsError() {
+		return KmsSignDataV1Response{}, errors.NewAPIErrorWithResponse(callKmsSignDataOperationV1, res)
+	}
+
+	return kmsSignDataResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/kms/verify_data.go

@@ -0,0 +1,29 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callKmsVerifyDataOperationV1 = "CallKmsVerifyDataV1"
+
+func CallKmsVerifyDataV1(httpClient *resty.Client, request KmsVerifyDataV1Request) (KmsVerifyDataV1Response, error) {
+	kmsVerifyDataResponse := KmsVerifyDataV1Response{}
+
+	res, err := httpClient.R().
+		SetResult(&kmsVerifyDataResponse).
+		SetBody(request).
+		Post(fmt.Sprintf("/v1/kms/keys/%s/verify", request.KeyId))
+
+	if err != nil {
+		return KmsVerifyDataV1Response{}, errors.NewRequestError(callKmsVerifyDataOperationV1, err)
+	}
+
+	if res.IsError() {
+		return KmsVerifyDataV1Response{}, errors.NewAPIErrorWithResponse(callKmsVerifyDataOperationV1, res)
+	}
+
+	return kmsVerifyDataResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/secrets/bulk_create_secrets.go

@@ -0,0 +1,40 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callBatchCreateSecretV3RawOperation = "CallBatchCreateSecretV3Raw"
+
+func CallBatchCreateSecretV3(httpClient *resty.Client, request BatchCreateSecretsV3RawRequest) (BatchCreateSecretsV3RawResponse, error) {
+
+	createBatchResponse := BatchCreateSecretsV3RawResponse{}
+
+	req := httpClient.R().
+		SetResult(&createBatchResponse).
+		SetBody(request)
+
+	res, err := req.Post("/v3/secrets/batch/raw")
+
+	if err != nil {
+		return BatchCreateSecretsV3RawResponse{}, errors.NewRequestError(callBatchCreateSecretV3RawOperation, err)
+	}
+
+	if res.IsError() {
+		return BatchCreateSecretsV3RawResponse{}, errors.NewAPIErrorWithResponse(callBatchCreateSecretV3RawOperation, res)
+	}
+
+	for idx := range createBatchResponse.Secrets {
+
+		secretPath := request.SecretPath
+
+		if secretPath == "" {
+			secretPath = "/"
+		}
+
+		createBatchResponse.Secrets[idx].SecretPath = secretPath
+	}
+
+	return createBatchResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/secrets/create_secret.go

@@ -0,0 +1,31 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callCreateSecretV3RawOperation = "CallCreateSecretV3Raw"
+
+func CallCreateSecretV3(httpClient *resty.Client, request CreateSecretV3RawRequest) (CreateSecretV3RawResponse, error) {
+
+	createResponse := CreateSecretV3RawResponse{}
+
+	req := httpClient.R().
+		SetResult(&createResponse).
+		SetBody(request)
+
+	res, err := req.Post(fmt.Sprintf("/v3/secrets/raw/%s", request.SecretKey))
+
+	if err != nil {
+		return CreateSecretV3RawResponse{}, errors.NewRequestError(callCreateSecretV3RawOperation, err)
+	}
+
+	if res.IsError() {
+		return CreateSecretV3RawResponse{}, errors.NewAPIErrorWithResponse(callCreateSecretV3RawOperation, res)
+	}
+
+	return createResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/secrets/delete_secret.go

@@ -0,0 +1,31 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callDeleteSecretV3RawOperation = "CallDeleteSecretV3Raw"
+
+func CallDeleteSecretV3(httpClient *resty.Client, request DeleteSecretV3RawRequest) (DeleteSecretV3RawResponse, error) {
+
+	deleteResponse := DeleteSecretV3RawResponse{}
+
+	req := httpClient.R().
+		SetResult(&deleteResponse).
+		SetBody(request)
+
+	res, err := req.Delete(fmt.Sprintf("/v3/secrets/raw/%s", request.SecretKey))
+
+	if err != nil {
+		return DeleteSecretV3RawResponse{}, errors.NewRequestError(callDeleteSecretV3RawOperation, err)
+	}
+
+	if res.IsError() {
+		return DeleteSecretV3RawResponse{}, errors.NewAPIErrorWithResponse(callDeleteSecretV3RawOperation, res)
+	}
+
+	return deleteResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/secrets/list_secrets.go

@@ -0,0 +1,75 @@
+package api
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+	"github.com/hashicorp/golang-lru/v2/expirable"
+	"github.com/infisical/go-sdk/packages/errors"
+	"github.com/infisical/go-sdk/packages/util"
+)
+
+const callListSecretsV3RawOperation = "CallListSecretsV3Raw"
+
+func CallListSecretsV3(cache *expirable.LRU[string, interface{}], httpClient *resty.Client, request ListSecretsV3RawRequest) (ListSecretsV3RawResponse, error) {
+	var cacheKey string
+
+	if cache != nil {
+		reqBytes, err := json.Marshal(request)
+		if err != nil {
+			return ListSecretsV3RawResponse{}, err
+		}
+		cacheKey = util.ComputeCacheKeyFromBytes(reqBytes, callListSecretsV3RawOperation)
+		if cached, found := cache.Get(cacheKey); found {
+			if response, ok := cached.(ListSecretsV3RawResponse); ok {
+				return response, nil
+			}
+			cache.Remove(cacheKey)
+		}
+	}
+
+	secretsResponse := ListSecretsV3RawResponse{}
+
+	if request.SecretPath == "" {
+		request.SecretPath = "/"
+	}
+
+	req := httpClient.R().
+		SetResult(&secretsResponse).
+		SetQueryParams(map[string]string{
+			"workspaceId":            request.ProjectID,
+			"workspaceSlug":          request.ProjectSlug,
+			"environment":            request.Environment,
+			"secretPath":             request.SecretPath,
+			"expandSecretReferences": fmt.Sprintf("%t", request.ExpandSecretReferences),
+			"include_imports":        fmt.Sprintf("%t", request.IncludeImports),
+			"recursive":              fmt.Sprintf("%t", request.Recursive),
+		})
+
+	if request.IfNoneMatch != "" {
+		req.SetHeader("If-None-Match", request.IfNoneMatch)
+	}
+
+	res, err := req.Get("/v3/secrets/raw")
+
+	if err != nil {
+		return ListSecretsV3RawResponse{}, errors.NewRequestError(callListSecretsV3RawOperation, err)
+	}
+
+	if res.StatusCode() == 304 {
+		return ListSecretsV3RawResponse{}, errors.NewNotModifiedError(callListSecretsV3RawOperation)
+	}
+
+	if res.IsError() {
+		return ListSecretsV3RawResponse{}, errors.NewAPIErrorWithResponse(callListSecretsV3RawOperation, res)
+	}
+
+	secretsResponse.ETag = res.Header().Get("ETag")
+
+	if cache != nil {
+		cache.Add(cacheKey, secretsResponse)
+	}
+
+	return secretsResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/secrets/models.go

@@ -0,0 +1,113 @@
+package api
+
+import "github.com/infisical/go-sdk/packages/models"
+
+// List secrets
+type ListSecretsV3RawRequest struct {
+	AttachToProcessEnv bool `json:"-"`
+
+	// ProjectId and ProjectSlug are used to fetch secrets from the project. Only one of them is required.
+	ProjectID              string `json:"workspaceId,omitempty"`
+	ProjectSlug            string `json:"workspaceSlug,omitempty"`
+	Environment            string `json:"environment"`
+	ExpandSecretReferences bool   `json:"expandSecretReferences"`
+	IncludeImports         bool   `json:"include_imports"`
+	Recursive              bool   `json:"recursive"`
+	SecretPath             string `json:"secretPath,omitempty"`
+	SkipUniqueValidation   bool   `json:"skip_unique_validation,omitempty"`
+	IfNoneMatch            string `json:"-"`
+}
+
+type ListSecretsV3RawResponse struct {
+	Secrets []models.Secret       `json:"secrets"`
+	Imports []models.SecretImport `json:"imports"`
+	ETag    string                `json:"etag"`
+}
+
+// Retrieve secret
+
+type RetrieveSecretV3RawRequest struct {
+	SecretKey string `json:"secretKey"`
+
+	ProjectSlug            string `json:"workspaceSlug,omitempty"`
+	ProjectID              string `json:"workspaceId,omitempty"`
+	Environment            string `json:"environment"`
+	SecretPath             string `json:"secretPath,omitempty"`
+	Type                   string `json:"type,omitempty"`
+	IncludeImports         bool   `json:"include_imports"`
+	ExpandSecretReferences bool   `json:"expandSecretReferences"`
+
+	Version int `json:"version,omitempty"`
+}
+
+type RetrieveSecretV3RawResponse struct {
+	Secret models.Secret `json:"secret"`
+}
+
+// Update secret
+type UpdateSecretV3RawRequest struct {
+	SecretKey string `json:"-"`
+
+	ProjectID   string `json:"workspaceId"`
+	Environment string `json:"environment"`
+	SecretPath  string `json:"secretPath,omitempty"`
+	Type        string `json:"type,omitempty"`
+
+	NewSecretValue           string `json:"secretValue,omitempty"`
+	NewSkipMultilineEncoding bool   `json:"skipMultilineEncoding,omitempty"`
+}
+
+type UpdateSecretV3RawResponse struct {
+	Secret models.Secret `json:"secret"`
+}
+
+// Create secret
+type CreateSecretV3RawRequest struct {
+	SecretKey string `json:"-"`
+
+	ProjectID             string `json:"workspaceId"`
+	Environment           string `json:"environment"`
+	SecretPath            string `json:"secretPath,omitempty"`
+	Type                  string `json:"type,omitempty"`
+	SecretComment         string `json:"secretComment,omitempty"`
+	SkipMultiLineEncoding bool   `json:"skipMultilineEncoding"`
+	SecretValue           string `json:"secretValue"`
+}
+
+type CreateSecretV3RawResponse struct {
+	Secret models.Secret `json:"secret"`
+}
+
+// Delete secret
+type DeleteSecretV3RawRequest struct {
+	SecretKey string `json:"-"`
+
+	ProjectID   string `json:"workspaceId"`
+	Environment string `json:"environment"`
+	SecretPath  string `json:"secretPath,omitempty"`
+	Type        string `json:"type,omitempty"`
+}
+
+type DeleteSecretV3RawResponse struct {
+	Secret models.Secret `json:"secret"`
+}
+
+type BatchCreateSecret struct {
+	SecretKey             string                  `json:"secretKey"`
+	SecretValue           string                  `json:"secretValue"`
+	SecretComment         string                  `json:"secretComment,omitempty"`
+	SkipMultiLineEncoding bool                    `json:"skipMultilineEncoding,omitempty"`
+	SecretMetadata        []models.SecretMetadata `json:"secretMetadata,omitempty"`
+	TagIDs                []string                `json:"tagIds,omitempty"`
+}
+
+type BatchCreateSecretsV3RawRequest struct {
+	Environment string              `json:"environment"`
+	ProjectID   string              `json:"workspaceId"`
+	SecretPath  string              `json:"secretPath,omitempty"`
+	Secrets     []BatchCreateSecret `json:"secrets"`
+}
+
+type BatchCreateSecretsV3RawResponse struct {
+	Secrets []models.Secret `json:"secrets"`
+}

vendor/github.com/infisical/go-sdk/packages/api/secrets/retrieve_secret.go

@@ -0,0 +1,81 @@
+package api
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+	"github.com/hashicorp/golang-lru/v2/expirable"
+	sdkErrors "github.com/infisical/go-sdk/packages/errors"
+	"github.com/infisical/go-sdk/packages/util"
+)
+
+const callRetrieveSecretV3RawOperation = "CallRetrieveSecretV3Raw"
+
+func CallRetrieveSecretV3(cache *expirable.LRU[string, interface{}], httpClient *resty.Client, request RetrieveSecretV3RawRequest) (RetrieveSecretV3RawResponse, error) {
+	var cacheKey string
+
+	if cache != nil {
+		reqBytes, err := json.Marshal(request)
+		if err != nil {
+			return RetrieveSecretV3RawResponse{}, err
+		}
+		cacheKey = util.ComputeCacheKeyFromBytes(reqBytes, callRetrieveSecretV3RawOperation)
+		if cached, found := cache.Get(cacheKey); found {
+			if response, ok := cached.(RetrieveSecretV3RawResponse); ok {
+				return response, nil
+			}
+			cache.Remove(cacheKey)
+		}
+	}
+
+	retrieveResponse := RetrieveSecretV3RawResponse{}
+
+	if request.Type == "" {
+		request.Type = "shared"
+	}
+
+	if request.SecretPath == "" {
+		request.SecretPath = "/"
+	}
+
+	queryParams := map[string]string{
+		"environment":            request.Environment,
+		"secretPath":             request.SecretPath,
+		"expandSecretReferences": fmt.Sprintf("%t", request.ExpandSecretReferences),
+		"include_imports":        fmt.Sprintf("%t", request.IncludeImports),
+		"type":                   request.Type,
+	}
+	if request.ProjectID != "" {
+		queryParams["workspaceId"] = request.ProjectID
+	} else if request.ProjectSlug != "" {
+		queryParams["workspaceSlug"] = request.ProjectSlug
+	} else {
+		return RetrieveSecretV3RawResponse{}, errors.New("projectId or projectSlug is required")
+	}
+
+	if request.Version != 0 {
+		queryParams["version"] = fmt.Sprintf("%d", request.Version)
+	}
+
+	req := httpClient.R().
+		SetResult(&retrieveResponse).
+		SetQueryParams(queryParams)
+
+	res, err := req.Get(fmt.Sprintf("/v3/secrets/raw/%s", request.SecretKey))
+
+	if err != nil {
+		return RetrieveSecretV3RawResponse{}, sdkErrors.NewRequestError(callRetrieveSecretV3RawOperation, err)
+	}
+
+	if res.IsError() {
+		return RetrieveSecretV3RawResponse{}, sdkErrors.NewAPIErrorWithResponse(callRetrieveSecretV3RawOperation, res)
+	}
+
+	if cache != nil {
+		cache.Add(cacheKey, retrieveResponse)
+	}
+
+	return retrieveResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/secrets/update_secret.go

@@ -0,0 +1,31 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callUpdateSecretV3RawOperation = "CallUpdateSecretV3Raw"
+
+func CallUpdateSecretV3(httpClient *resty.Client, request UpdateSecretV3RawRequest) (UpdateSecretV3RawResponse, error) {
+
+	updateResponse := UpdateSecretV3RawResponse{}
+
+	req := httpClient.R().
+		SetResult(&updateResponse).
+		SetBody(request)
+
+	res, err := req.Patch(fmt.Sprintf("/v3/secrets/raw/%s", request.SecretKey))
+
+	if err != nil {
+		return UpdateSecretV3RawResponse{}, errors.NewRequestError(callUpdateSecretV3RawOperation, err)
+	}
+
+	if res.IsError() {
+		return UpdateSecretV3RawResponse{}, errors.NewAPIErrorWithResponse(callUpdateSecretV3RawOperation, res)
+	}
+
+	return updateResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/ssh/add_ssh_host.go

@@ -0,0 +1,27 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callAddSshHostOperation = "CallAddSshHostV1"
+
+func CallAddSshHostV1(httpClient *resty.Client, body AddSshHostV1Request) (AddSshHostV1Response, error) {
+	resp := AddSshHostV1Response{}
+
+	res, err := httpClient.R().
+		SetBody(body).
+		SetResult(&resp).
+		Post("/v1/ssh/hosts")
+
+	if err != nil {
+		return AddSshHostV1Response{}, errors.NewRequestError(callAddSshHostOperation, err)
+	}
+
+	if res.IsError() {
+		return AddSshHostV1Response{}, errors.NewAPIErrorWithResponse(callAddSshHostOperation, res)
+	}
+
+	return resp, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/ssh/get_ssh_host_host_ca_pk.go

@@ -0,0 +1,21 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+func GetSshHostHostCaPublicKeyV1(httpClient *resty.Client, sshHostId string) (string, error) {
+	res, err := httpClient.R().
+		Get("/v1/ssh/hosts/" + sshHostId + "/host-ca-public-key")
+
+	if err != nil {
+		return "", errors.NewRequestError("GetSshHostHostCaPublicKeyV1", err)
+	}
+
+	if res.IsError() {
+		return "", errors.NewAPIErrorWithResponse("GetSshHostHostCaPublicKeyV1", res)
+	}
+
+	return res.String(), nil
+}

vendor/github.com/infisical/go-sdk/packages/api/ssh/get_ssh_host_user_ca_pk.go

@@ -0,0 +1,21 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+func GetSshHostUserCaPublicKeyV1(httpClient *resty.Client, sshHostId string) (string, error) {
+	res, err := httpClient.R().
+		Get("/v1/ssh/hosts/" + sshHostId + "/user-ca-public-key")
+
+	if err != nil {
+		return "", errors.NewRequestError("GetSshHostUserCaPublicKeyV1", err)
+	}
+
+	if res.IsError() {
+		return "", errors.NewAPIErrorWithResponse("GetSshHostUserCaPublicKeyV1", res)
+	}
+
+	return res.String(), nil
+}

vendor/github.com/infisical/go-sdk/packages/api/ssh/get_ssh_hosts.go

@@ -0,0 +1,26 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callGetSshHostsOperation = "CallGetSshHostsV1"
+
+func GetSshHostsV1(httpClient *resty.Client, _ GetSshHostsV1Request) (GetSshHostsV1Response, error) {
+	var getSshHostsResponse GetSshHostsV1Response
+
+	res, err := httpClient.R().
+		SetResult(&getSshHostsResponse).
+		Get("/v1/ssh/hosts")
+
+	if err != nil {
+		return nil, errors.NewRequestError(callGetSshHostsOperation, err)
+	}
+
+	if res.IsError() {
+		return nil, errors.NewAPIErrorWithResponse(callGetSshHostsOperation, res)
+	}
+
+	return getSshHostsResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/ssh/issue_ssh_creds.go

@@ -0,0 +1,27 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callIssueSshCredsOperation = "CallIssueSshCredsV1"
+
+func CallIssueSshCredsV1(httpClient *resty.Client, request IssueSshCredsV1Request) (IssueSshCredsV1Response, error) {
+	issueSshCredsResponse := IssueSshCredsV1Response{}
+
+	res, err := httpClient.R().
+		SetResult(&issueSshCredsResponse).
+		SetBody(request).
+		Post("/v1/ssh/certificates/issue")
+
+	if err != nil {
+		return IssueSshCredsV1Response{}, errors.NewRequestError(callIssueSshCredsOperation, err)
+	}
+
+	if res.IsError() {
+		return IssueSshCredsV1Response{}, errors.NewAPIErrorWithResponse(callIssueSshCredsOperation, res)
+	}
+
+	return issueSshCredsResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/ssh/issue_ssh_host_host_cert.go

@@ -0,0 +1,29 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callIssueSshHostHostCertOperation = "CallIssueSshHostHostCertV1"
+
+func CallIssueSshHostHostCertV1(httpClient *resty.Client, sshHostId string, body IssueSshHostHostCertV1Request) (IssueSshHostHostCertV1Response, error) {
+	resp := IssueSshHostHostCertV1Response{}
+
+	res, err := httpClient.R().
+		SetBody(body).
+		SetResult(&resp).
+		Post(fmt.Sprintf("/v1/ssh/hosts/%s/issue-host-cert", sshHostId))
+
+	if err != nil {
+		return IssueSshHostHostCertV1Response{}, errors.NewRequestError(callIssueSshHostHostCertOperation, err)
+	}
+
+	if res.IsError() {
+		return IssueSshHostHostCertV1Response{}, errors.NewAPIErrorWithResponse(callIssueSshHostHostCertOperation, res)
+	}
+
+	return resp, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/ssh/issue_ssh_host_user_cert.go

@@ -0,0 +1,29 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callIssueSshHostUserCertOperation = "CallIssueSshHostUserCertV1"
+
+func CallIssueSshHostUserCertV1(httpClient *resty.Client, sshHostId string, body IssueSshHostUserCertV1Request) (IssueSshHostUserCertV1Response, error) {
+	resp := IssueSshHostUserCertV1Response{}
+
+	res, err := httpClient.R().
+		SetBody(body).
+		SetResult(&resp).
+		Post(fmt.Sprintf("/v1/ssh/hosts/%s/issue-user-cert", sshHostId))
+
+	if err != nil {
+		return IssueSshHostUserCertV1Response{}, errors.NewRequestError(callIssueSshHostUserCertOperation, err)
+	}
+
+	if res.IsError() {
+		return IssueSshHostUserCertV1Response{}, errors.NewAPIErrorWithResponse(callIssueSshHostUserCertOperation, res)
+	}
+
+	return resp, nil
+}

vendor/github.com/infisical/go-sdk/packages/api/ssh/models.go

@@ -0,0 +1,95 @@
+package api
+
+import (
+	"github.com/infisical/go-sdk/packages/util"
+)
+
+type SignSshPublicKeyV1Request struct {
+	CertificateTemplateID string           `json:"certificateTemplateId"`
+	PublicKey             string           `json:"publicKey"`
+	CertType              util.SshCertType `json:"certType,omitempty"`
+	Principals            []string         `json:"principals"`
+	TTL                   string           `json:"ttl,omitempty"`
+	KeyID                 string           `json:"keyId,omitempty"`
+}
+
+type SignSshPublicKeyV1Response struct {
+	SerialNumber string `json:"serialNumber"`
+	SignedKey    string `json:"signedKey"`
+}
+
+type IssueSshCredsV1Request struct {
+	CertificateTemplateID string                `json:"certificateTemplateId"`
+	KeyAlgorithm          util.CertKeyAlgorithm `json:"keyAlgorithm,omitempty"`
+	CertType              util.SshCertType      `json:"certType,omitempty"`
+	Principals            []string              `json:"principals"`
+	TTL                   string                `json:"ttl,omitempty"`
+	KeyID                 string                `json:"keyId,omitempty"`
+}
+
+type IssueSshCredsV1Response struct {
+	SerialNumber string                `json:"serialNumber"`
+	SignedKey    string                `json:"signedKey"`
+	PrivateKey   string                `json:"privateKey"`
+	PublicKey    string                `json:"publicKey"`
+	KeyAlgorithm util.CertKeyAlgorithm `json:"keyAlgorithm"`
+}
+
+type GetSshHostsV1Request struct{}
+
+type AllowedPrincipals struct {
+	Usernames []string `json:"usernames"`
+}
+
+type SshHostLoginMapping struct {
+	LoginUser         string            `json:"loginUser"`
+	AllowedPrincipals AllowedPrincipals `json:"allowedPrincipals"`
+}
+
+type SshHost struct {
+	ID            string                `json:"id"`
+	ProjectID     string                `json:"projectId"`
+	Hostname      string                `json:"hostname"`
+	Alias         string                `json:"alias,omitempty"`
+	UserCertTtl   string                `json:"userCertTtl"`
+	HostCertTtl   string                `json:"hostCertTtl"`
+	UserSshCaId   string                `json:"userSshCaId"`
+	HostSshCaId   string                `json:"hostSshCaId"`
+	LoginMappings []SshHostLoginMapping `json:"loginMappings"`
+}
+
+type GetSshHostsV1Response []SshHost
+
+type IssueSshHostUserCertV1Request struct {
+	LoginUser string `json:"loginUser"`
+}
+
+type IssueSshHostUserCertV1Response struct {
+	SerialNumber string                `json:"serialNumber"`
+	SignedKey    string                `json:"signedKey"`
+	PrivateKey   string                `json:"privateKey"`
+	PublicKey    string                `json:"publicKey"`
+	KeyAlgorithm util.CertKeyAlgorithm `json:"keyAlgorithm"`
+}
+
+type IssueSshHostHostCertV1Request struct {
+	PublicKey string `json:"publicKey"`
+}
+
+type IssueSshHostHostCertV1Response struct {
+	SerialNumber string `json:"serialNumber"`
+	SignedKey    string `json:"signedKey"`
+}
+
+type AddSshHostV1Request struct {
+	ProjectID     string                `json:"projectId"`
+	Hostname      string                `json:"hostname"`
+	Alias         string                `json:"alias,omitempty"`
+	UserCertTtl   string                `json:"userCertTtl,omitempty"`
+	HostCertTtl   string                `json:"hostCertTtl,omitempty"`
+	UserSshCaId   string                `json:"userSshCaId,omitempty"`
+	HostSshCaId   string                `json:"hostSshCaId,omitempty"`
+	LoginMappings []SshHostLoginMapping `json:"loginMappings,omitempty"`
+}
+
+type AddSshHostV1Response SshHost

vendor/github.com/infisical/go-sdk/packages/api/ssh/sign_ssh_public_key.go

@@ -0,0 +1,27 @@
+package api
+
+import (
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/errors"
+)
+
+const callSignSshPublicKeyOperation = "CallSignSshPublicKeyV1"
+
+func CallSignSshPublicKeyV1(httpClient *resty.Client, request SignSshPublicKeyV1Request) (SignSshPublicKeyV1Response, error) {
+	signSshPublicKeyResponse := SignSshPublicKeyV1Response{}
+
+	res, err := httpClient.R().
+		SetResult(&signSshPublicKeyResponse).
+		SetBody(request).
+		Post("/v1/ssh/certificates/sign")
+
+	if err != nil {
+		return SignSshPublicKeyV1Response{}, errors.NewRequestError(callSignSshPublicKeyOperation, err)
+	}
+
+	if res.IsError() {
+		return SignSshPublicKeyV1Response{}, errors.NewAPIErrorWithResponse(callSignSshPublicKeyOperation, res)
+	}
+
+	return signSshPublicKeyResponse, nil
+}

vendor/github.com/infisical/go-sdk/packages/errors/api.go

@@ -0,0 +1,75 @@
+package errors
+
+import (
+	"fmt"
+
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/util"
+)
+
+// APIError represents an error response from the API
+type APIError struct {
+	Operation    string `json:"operation"`
+	Method       string `json:"method"`
+	URL          string `json:"url"`
+	StatusCode   int    `json:"statusCode"`
+	ErrorMessage string `json:"message,omitempty"`
+	ReqId        string `json:"reqId,omitempty"`
+}
+
+func (e *APIError) Error() string {
+	msg := fmt.Sprintf(
+		"APIError: %s unsuccessful response [%v %v] [status-code=%v] [reqId=%v]",
+		e.Operation,
+		e.Method,
+		e.URL,
+		e.StatusCode,
+		e.ReqId,
+	)
+
+	if e.ErrorMessage != "" {
+		return fmt.Sprintf("%s [message=\"%s\"]", msg, e.ErrorMessage)
+
+	}
+
+	return msg
+}
+
+func NewAPIError(operation string, res *resty.Response) error {
+	return &APIError{
+		Operation:  operation,
+		Method:     res.Request.Method,
+		URL:        res.Request.URL,
+		StatusCode: res.StatusCode(),
+	}
+}
+
+func NewAPIErrorWithResponse(operation string, res *resty.Response) error {
+	errorMessage := util.TryParseErrorBody(res)
+	reqId := util.TryExtractReqId(res)
+
+	return &APIError{
+		Operation:    operation,
+		Method:       res.Request.Method,
+		URL:          res.Request.URL,
+		StatusCode:   res.StatusCode(),
+		ErrorMessage: errorMessage,
+		ReqId:        reqId,
+	}
+}
+
+// NotModifiedError is returned when the server responds with 304 Not Modified,
+// indicating the resource has not changed since the last request (based on ETag).
+type NotModifiedError struct {
+	Operation string
+}
+
+func (e *NotModifiedError) Error() string {
+	return fmt.Sprintf("%s: secrets not modified (HTTP 304)", e.Operation)
+}
+
+func NewNotModifiedError(operation string) error {
+	return &NotModifiedError{
+		Operation: operation,
+	}
+}

vendor/github.com/infisical/go-sdk/packages/errors/request.go

@@ -0,0 +1,22 @@
+package errors
+
+import (
+	"fmt"
+)
+
+// RequestError represents an error that occurred during an API request
+type RequestError struct {
+	Operation string `json:"operation"`
+	error     error  `json:"-"`
+}
+
+func (e *RequestError) Error() string {
+	return fmt.Sprintf("%s: unable to complete api request [err=%s]", e.Operation, e.error)
+}
+
+func NewRequestError(operation string, err error) error {
+	return &RequestError{
+		Operation: operation,
+		error:     err,
+	}
+}

vendor/github.com/infisical/go-sdk/packages/models/auth.go

@@ -0,0 +1,66 @@
+package models
+
+type TokenType string
+
+const (
+	BEARER_TOKEN_TYPE TokenType = "Bearer"
+)
+
+type UniversalAuthCredential struct {
+	ClientID     string
+	ClientSecret string
+}
+
+type AccessTokenCredential struct {
+	AccessToken string
+}
+
+type GCPIDTokenCredential struct {
+	IdentityID string
+}
+
+type GCPIAMCredential struct {
+	IdentityID                string
+	ServiceAccountKeyFilePath string
+}
+
+type AWSIAMCredential struct {
+	IdentityID string
+}
+
+type KubernetesCredential struct {
+	IdentityID          string
+	ServiceAccountToken string
+}
+
+type AzureCredential struct {
+	IdentityID string
+	Resource   string
+	ClientID   string
+}
+
+type OIDCCredential struct {
+	IdentityID string
+	JWT        string
+}
+
+type JWTCredential struct {
+	IdentityID string
+	JWT        string
+}
+
+type LDAPCredential struct {
+	IdentityID string
+	Username   string
+	Password   string
+}
+
+type OCICredential struct {
+	IdentityID  string
+	PrivateKey  string
+	Fingerprint string
+	UserID      string
+	TenancyID   string
+	Region      string
+	Passphrase  *string
+}

vendor/github.com/infisical/go-sdk/packages/models/dynamic_secrets.go

@@ -0,0 +1,44 @@
+package models
+
+import "time"
+
+type DynamicSecret struct {
+	Id            string    `json:"id"`
+	Name          string    `json:"name"`
+	Type          string    `json:"type"`
+	Version       int       `json:"number"`
+	DefaultTTL    string    `json:"defaultTTL"`
+	MaxTTL        string    `json:"maxTTL"`
+	FolderID      string    `json:"folderId"`
+	Status        string    `json:"status"`
+	StatusDetails string    `json:"statusDetails"`
+	CreatedAt     time.Time `json:"createdAt"`
+	UpdatedAt     time.Time `json:"updatedAt"`
+}
+
+type DynamicSecretLease struct {
+	Id               string    `json:"id"`
+	Type             string    `json:"type"`
+	Version          int       `json:"number"`
+	ExternalEntityId string    `json:"externalEntityId"`
+	ExpireAt         time.Time `json:"expireAt"`
+	Status           string    `json:"status"`
+	DynamicSecretId  string    `json:"dynamicSecretId"`
+	StatusDetails    string    `json:"statusDetails"`
+	CreatedAt        time.Time `json:"createdAt"`
+	UpdatedAt        time.Time `json:"updatedAt"`
+}
+
+type DynamicSecretLeaseWithDynamicSecret struct {
+	Id               string        `json:"id"`
+	Type             string        `json:"type"`
+	Version          int           `json:"number"`
+	ExternalEntityId string        `json:"externalEntityId"`
+	ExpireAt         time.Time     `json:"expireAt"`
+	Status           string        `json:"status"`
+	DynamicSecretId  string        `json:"dynamicSecretId"`
+	StatusDetails    string        `json:"statusDetails"`
+	CreatedAt        time.Time     `json:"createdAt"`
+	UpdatedAt        time.Time     `json:"updatedAt"`
+	DynamicSecret    DynamicSecret `json:"dynamicSecret"`
+}

vendor/github.com/infisical/go-sdk/packages/models/folders.go

@@ -0,0 +1,14 @@
+package models
+
+import "time"
+
+type Folder struct {
+	ID            string    `json:"id"`
+	Name          string    `json:"name"`
+	Version       int       `json:"version"`
+	CreatedAt     time.Time `json:"createdAt"`
+	UpdatedAt     time.Time `json:"updatedAt"`
+	EnvironmentID string    `json:"envId"`
+	ParentID      string    `json:"parentId"`
+	IsReserved    bool      `json:"isReserved"`
+}

vendor/github.com/infisical/go-sdk/packages/models/secrets.go

@@ -0,0 +1,34 @@
+package models
+
+type SecretMetadata struct {
+	Key   string `json:"key"`
+	Value string `json:"value"`
+}
+
+type SecretTag struct {
+	ID    string `json:"id"`
+	Slug  string `json:"slug"`
+	Name  string `json:"name"`
+	Color string `json:"color"`
+}
+
+type Secret struct {
+	ID             string           `json:"id"`
+	Workspace      string           `json:"workspace"`
+	Environment    string           `json:"environment"`
+	Version        int              `json:"version"`
+	Type           string           `json:"type"`
+	SecretKey      string           `json:"secretKey"`
+	SecretValue    string           `json:"secretValue"`
+	SecretComment  string           `json:"secretComment"`
+	SecretPath     string           `json:"secretPath,omitempty"`
+	SecretMetadata []SecretMetadata `json:"secretMetadata"`
+	Tags           []SecretTag      `json:"tags"`
+}
+
+type SecretImport struct {
+	SecretPath  string   `json:"secretPath"`
+	Environment string   `json:"environment"`
+	FolderID    string   `json:"folderId"`
+	Secrets     []Secret `json:"secrets"`
+}

vendor/github.com/infisical/go-sdk/packages/util/auth.go

@@ -0,0 +1,244 @@
+package util
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"os"
+	"time"
+
+	credentials "cloud.google.com/go/iam/credentials/apiv1"
+	"cloud.google.com/go/iam/credentials/apiv1/credentialspb"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/config"
+	"github.com/go-resty/resty/v2"
+	"google.golang.org/api/option"
+)
+
+func GetKubernetesServiceAccountToken(serviceAccountTokenPath string) (string, error) {
+
+	if serviceAccountTokenPath == "" {
+		serviceAccountTokenPath = DEFAULT_KUBERNETES_SERVICE_ACCOUNT_TOKEN_PATH
+	}
+
+	token, err := os.ReadFile(serviceAccountTokenPath)
+
+	if err != nil {
+		return "", err
+	}
+
+	return string(token), nil
+
+}
+
+func buildAzureMetadataServiceURL(resource string, clientID string) string {
+	azureURL := AZURE_METADATA_SERVICE_URL + AZURE_DEFAULT_RESOURCE
+	if resource != "" {
+		azureURL = AZURE_METADATA_SERVICE_URL + url.QueryEscape(resource)
+	}
+	if clientID != "" {
+		azureURL += "&client_id=" + url.QueryEscape(clientID)
+	}
+	return azureURL
+}
+
+// GetAzureMetadataToken fetches a JWT from the Azure IMDS endpoint.
+// The optional clientID parameter targets a specific User-Assigned Managed Identity;
+// pass "" for System-Assigned Managed Identity.
+func GetAzureMetadataToken(httpClient *resty.Client, customResource string, clientID string) (string, error) {
+
+	type AzureMetadataResponse struct {
+		AccessToken string `json:"access_token"`
+	}
+
+	metadataResponse := AzureMetadataResponse{}
+
+	response, err := httpClient.R().
+		SetResult(&metadataResponse).
+		SetHeader("Metadata", "true").
+		SetHeader("Accept", "application/json").
+		Get(buildAzureMetadataServiceURL(customResource, clientID))
+
+	if err != nil {
+		return "", err
+	}
+
+	if response.IsError() {
+		return "", fmt.Errorf("GetAzureMetadataToken: Unsuccessful response [%v %v] [status-code=%v] [Error: %s]", response.Request.Method, response.Request.URL, response.StatusCode(), TryParseErrorBody(response))
+	}
+
+	return metadataResponse.AccessToken, nil
+}
+
+func GetGCPMetadataToken(httpClient *resty.Client, identityID string) (string, error) {
+
+	res, err := httpClient.R().
+		SetHeader("Metadata-Flavor", "Google").
+		Get(fmt.Sprintf("http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/identity?audience=%s&format=full", identityID))
+
+	if err != nil {
+		return "", err
+	}
+
+	if res.IsError() {
+		return "", fmt.Errorf("GetGCPMetadataToken: Unsuccessful response [%v %v] [status-code=%v] [Error: %s]", res.Request.Method, res.Request.URL, res.StatusCode(), TryParseErrorBody(res))
+	}
+
+	return res.String(), nil
+
+}
+
+func GetAwsEC2IdentityDocumentRegion(timeout int) (string, error) {
+
+	type AwsIdentityDocument struct {
+		Region string `json:"region"`
+	}
+
+	httpClient := resty.New().SetTimeout(time.Duration(timeout) * time.Millisecond)
+
+	res, err := httpClient.R().
+		SetHeader("X-aws-ec2-metadata-token-ttl-seconds", "21600").
+		Put(AWS_EC2_METADATA_TOKEN_URL)
+
+	if err != nil {
+		return "", err
+	}
+
+	if res.IsError() {
+		return "", fmt.Errorf("GetAwsEC2IdentityDocumentRegion: Unsuccessful response [%v %v] [status-code=%v] [Error: %s]", res.Request.Method, res.Request.URL, res.StatusCode(), TryParseErrorBody(res))
+	}
+
+	metadataToken := res.String()
+
+	res, err = httpClient.R().
+		SetHeader("X-aws-ec2-metadata-token", metadataToken).
+		SetHeader("Accept", "application/json").
+		Get(AWS_EC2_INSTANCE_IDENTITY_DOCUMENT_URL)
+
+	if err != nil {
+		return "", err
+	}
+
+	if res.IsError() {
+		return "", fmt.Errorf("GetAwsEC2IdentityDocumentRegion: Unsuccessful response [%v %v] [status-code=%v] [Error: %s]", res.Request.Method, res.Request.URL, res.StatusCode(), TryParseErrorBody(res))
+	}
+
+	// For some reason using .SetResult(&AwsIdentityDocument{}) doesn't work and just results in an empty object. This works though..
+	var identityDocument AwsIdentityDocument
+	err = json.Unmarshal(res.Body(), &identityDocument)
+	if err != nil {
+		return "", err
+	}
+
+	return identityDocument.Region, nil
+
+}
+
+func GetGCPIamServiceAccountToken(identityID string, serviceAccountKeyPath string) (string, error) {
+
+	type JwtPayload struct {
+		Sub string `json:"sub"`
+		Aud string `json:"aud"`
+	}
+
+	ctx := context.Background()
+
+	serviceAccountKey, err := os.ReadFile(serviceAccountKeyPath)
+	if err != nil {
+		return "", err
+	}
+
+	var creds map[string]string
+	if err := json.Unmarshal(serviceAccountKey, &creds); err != nil {
+		return "", fmt.Errorf("failed to unmarshal service account key: %v", err)
+	}
+
+	clientEmail := creds["client_email"]
+	if clientEmail == "" {
+		return "", fmt.Errorf("client email not found in service account key")
+	}
+
+	payload := JwtPayload{
+		Sub: clientEmail,
+		Aud: identityID,
+	}
+
+	payloadJSON, err := json.Marshal(payload)
+	if err != nil {
+		return "", fmt.Errorf("failed to marshal JWT payload: %v", err)
+	}
+
+	iamCredentialsClient, err := credentials.NewIamCredentialsClient(ctx, option.WithCredentialsFile(serviceAccountKeyPath)) //nolint:staticcheck // deprecated but no drop-in replacement available yet
+	if err != nil {
+		return "", fmt.Errorf("failed to create IAM credentials client: %v", err)
+	}
+
+	defer iamCredentialsClient.Close() //nolint:errcheck
+
+	signJwtRequest := &credentialspb.SignJwtRequest{
+		Name:    fmt.Sprintf("projects/-/serviceAccounts/%s", clientEmail),
+		Payload: string(payloadJSON),
+	}
+
+	resp, err := iamCredentialsClient.SignJwt(ctx, signJwtRequest)
+	if err != nil {
+		return "", fmt.Errorf("failed to sign JWT: %v. Ensure the IAM Service Account Credentials API is enabled", err)
+	}
+
+	signedJwt := resp.SignedJwt
+	if signedJwt == "" {
+		return "", fmt.Errorf("failed to sign JWT: signedJwt is empty")
+	}
+
+	return signedJwt, nil
+
+}
+
+func GetAwsRegion() (string, error) {
+	// in Lambda environments, the region is available in the AWS_REGION environment variable
+	region := os.Getenv("AWS_REGION")
+
+	if region != "" {
+		return region, nil
+	}
+
+	// in EC2 environments, the region is available in the identity doc
+
+	region, err := GetAwsEC2IdentityDocumentRegion(5000)
+
+	if err != nil {
+		return "", err
+	}
+
+	return region, nil
+
+}
+
+func RetrieveAwsCredentials() (credentials aws.Credentials, region string, err error) {
+	presetAwsCfg, err := config.LoadDefaultConfig(context.TODO())
+
+	if err == nil && presetAwsCfg.Region != "" {
+		creds, err := presetAwsCfg.Credentials.Retrieve(context.TODO())
+		if err == nil {
+			return creds, presetAwsCfg.Region, nil
+		}
+	}
+
+	awsRegion, err := GetAwsRegion()
+	if err != nil {
+		return aws.Credentials{}, "", err
+	}
+
+	awsCfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion(awsRegion))
+	if err != nil {
+		return aws.Credentials{}, "", fmt.Errorf("unable to load SDK config, %v", err)
+	}
+
+	creds, err := awsCfg.Credentials.Retrieve(context.TODO())
+	if err != nil {
+		return aws.Credentials{}, "", fmt.Errorf("error retrieving credentials: %v", err)
+	}
+
+	return creds, awsRegion, nil
+}

vendor/github.com/infisical/go-sdk/packages/util/constants.go

@@ -0,0 +1,92 @@
+package util
+
+import (
+	"context"
+	"errors"
+)
+
+// Auth related:
+const (
+	INFISICAL_AUTH_ORGANIZATION_SLUG_ENV_NAME = "INFISICAL_AUTH_ORGANIZATION_SLUG"
+
+	// Universal auth:
+	INFISICAL_UNIVERSAL_AUTH_CLIENT_ID_ENV_NAME     = "INFISICAL_UNIVERSAL_AUTH_CLIENT_ID"
+	INFISICAL_UNIVERSAL_AUTH_CLIENT_SECRET_ENV_NAME = "INFISICAL_UNIVERSAL_AUTH_CLIENT_SECRET"
+
+	// GCP auth:
+	INFISICAL_GCP_AUTH_IDENTITY_ID_ENV_NAME                  = "INFISICAL_GCP_AUTH_IDENTITY_ID"
+	INFISICAL_GCP_IAM_SERVICE_ACCOUNT_KEY_FILE_PATH_ENV_NAME = "INFISICAL_GCP_IAM_SERVICE_ACCOUNT_KEY_FILE_PATH"
+
+	// AWS auth:
+	INFISICAL_AWS_IAM_AUTH_IDENTITY_ID_ENV_NAME = "INFISICAL_AWS_IAM_AUTH_IDENTITY_ID"
+
+	// Azure auth:
+	INFISICAL_AZURE_AUTH_IDENTITY_ID_ENV_NAME = "INFISICAL_AZURE_AUTH_IDENTITY_ID"
+	INFISICAL_AZURE_AUTH_CLIENT_ID_ENV_NAME   = "INFISICAL_AZURE_AUTH_CLIENT_ID"
+
+	// OCI auth:
+	INFISICAL_OCI_AUTH_IDENTITY_ID_ENV_NAME = "INFISICAL_OCI_AUTH_IDENTITY_ID"
+
+	// LDAP auth:
+	INFISICAL_LDAP_AUTH_IDENTITY_ID_ENV_NAME = "INFISICAL_LDAP_AUTH_IDENTITY_ID"
+
+	// Kubernetes auth:
+	INFISICAL_KUBERNETES_IDENTITY_ID_ENV_NAME                = "INFISICAL_KUBERNETES_IDENTITY_ID"
+	INFISICAL_KUBERNETES_SERVICE_ACCOUNT_TOKEN_PATH_ENV_NAME = "INFISICAL_KUBERNETES_SERVICE_ACCOUNT_TOKEN_PATH"
+
+	// OIDC auth:
+	INFISICAL_OIDC_AUTH_IDENTITY_ID_ENV_NAME = "INFISICAL_OIDC_AUTH_IDENTITY_ID"
+
+	// Access token:
+	INFISICAL_ACCESS_TOKEN_ENV_NAME = "INFISICAL_ACCESS_TOKEN"
+
+	// AWS metadata service:
+	AWS_EC2_METADATA_TOKEN_URL             = "http://169.254.169.254/latest/api/token"
+	AWS_EC2_INSTANCE_IDENTITY_DOCUMENT_URL = "http://169.254.169.254/latest/dynamic/instance-identity/document"
+
+	// Azure metadata service:
+	AZURE_METADATA_SERVICE_URL = "http://169.254.169.254/metadata/identity/oauth2/token?api-version=2018-02-01&resource=" // End of the URL needs to be appended with the resource
+	AZURE_DEFAULT_RESOURCE     = "https%3A%2F%2Fmanagement.azure.com/"
+)
+
+type AuthMethod string
+
+const (
+	ACCESS_TOKEN   AuthMethod = "ACCESS_TOKEN"
+	UNIVERSAL_AUTH AuthMethod = "UNIVERSAL_AUTH"
+	GCP_ID_TOKEN   AuthMethod = "GCP_ID_TOKEN"
+	GCP_IAM        AuthMethod = "GCP_IAM"
+	AWS_IAM        AuthMethod = "AWS_IAM"
+	KUBERNETES     AuthMethod = "KUBERNETES"
+	AZURE          AuthMethod = "AZURE"
+	OIDC_AUTH      AuthMethod = "OIDC_AUTH"
+	JWT_AUTH       AuthMethod = "JWT_AUTH"
+	LDAP_AUTH      AuthMethod = "LDAP_AUTH"
+	OCI_AUTH       AuthMethod = "OCI_AUTH"
+)
+
+// SSH related:
+type CertKeyAlgorithm string
+
+const (
+	RSA2048   CertKeyAlgorithm = "RSA_2048"
+	RSA4096   CertKeyAlgorithm = "RSA_4096"
+	ECDSAP256 CertKeyAlgorithm = "EC_prime256v1"
+	ECDSAP384 CertKeyAlgorithm = "EC_secp384r1"
+)
+
+type SshCertType string
+
+const (
+	UserCert SshCertType = "user"
+	HostCert SshCertType = "host"
+)
+
+// General:
+const (
+	DEFAULT_INFISICAL_API_URL                     = "https://app.infisical.com/api"
+	DEFAULT_KUBERNETES_SERVICE_ACCOUNT_TOKEN_PATH = "/var/run/secrets/kubernetes.io/serviceaccount/token"
+)
+
+var ErrContextCanceled = errors.New("context canceled")
+var ErrContextDeadlineExceeded error = context.DeadlineExceeded

vendor/github.com/infisical/go-sdk/packages/util/helper.go

@@ -0,0 +1,146 @@
+package util
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/go-resty/resty/v2"
+	"github.com/infisical/go-sdk/packages/models"
+	"github.com/rs/zerolog"
+)
+
+func AppendAPIEndpoint(siteUrl string) string {
+	// Ensure the address does not already end with "/api"
+	if strings.HasSuffix(siteUrl, "/api") {
+		return siteUrl
+	}
+
+	// Check if the address ends with a slash and append accordingly
+	if siteUrl[len(siteUrl)-1] == '/' {
+		return siteUrl + "api"
+	}
+	return siteUrl + "/api"
+}
+
+func PrintWarning(logger zerolog.Logger, message string) {
+	logger.Warn().Msgf("[Infisical] Warning: %v", message)
+}
+
+func EnsureUniqueSecretsByKey(secrets *[]models.Secret, skipUniqueKey bool) {
+	secretMap := make(map[string]models.Secret)
+
+	// Move secrets to a map to ensure uniqueness
+	for _, secret := range *secrets {
+		var key string
+		if skipUniqueKey {
+			// Create a composite key using both SecretPath and SecretKey
+			key = secret.SecretPath + ":" + secret.SecretKey
+		} else {
+			// Use only SecretKey for global uniqueness
+			key = secret.SecretKey
+		}
+		secretMap[key] = secret
+	}
+
+	// Clear the slice
+	*secrets = (*secrets)[:0]
+
+	// Refill the slice from the map
+	for _, secret := range secretMap {
+		*secrets = append(*secrets, secret)
+	}
+}
+
+// containsSecret checks if the given key exists in the slice of secrets
+func ContainsSecret(secrets []models.Secret, key string) bool {
+	for _, secret := range secrets {
+		if secret.SecretKey == key {
+			return true
+		}
+	}
+	return false
+}
+
+// Helper function to sort the secrets by key so we can create a consistent output
+func SortSecretsByKeys(secrets []models.Secret) []models.Secret {
+	sort.Slice(secrets, func(i, j int) bool {
+		return secrets[i].SecretKey < secrets[j].SecretKey
+	})
+	return secrets
+}
+
+/*
+If the status code is 400, there will most likely always be a body.
+The body is a json object with a message key. we need to try to parse it, but if it fails, we can just return an empty string.
+But if the status code is 500, there may not be a body. if there is, it will be a json object with a message key. we need to try to parse it, but if it fails, we can just return an empty string
+*/
+func TryParseErrorBody(res *resty.Response) string {
+	if res == nil || !res.IsError() {
+		return ""
+	}
+
+	body := res.String()
+	if body == "" {
+		return ""
+	}
+
+	type ErrorResponse struct {
+		Message string `json:"message"`
+		ReqId   string `json:"reqId"`
+	}
+
+	// stringify zod body entirely
+	if res.StatusCode() == 422 {
+		return body
+	}
+
+	// now we have a string, we need to try to parse it as json
+	var errorResponse ErrorResponse
+	err := json.Unmarshal([]byte(body), &errorResponse)
+
+	if err != nil {
+		return ""
+	}
+
+	return errorResponse.Message
+}
+
+func TryExtractReqId(res *resty.Response) string {
+	if res == nil || !res.IsError() {
+		return ""
+	}
+
+	type ErrorResponse struct {
+		ReqId string `json:"reqId"`
+	}
+
+	var errorResponse ErrorResponse
+
+	err := json.Unmarshal([]byte(res.String()), &errorResponse)
+
+	if err != nil {
+		return ""
+	}
+
+	return errorResponse.ReqId
+}
+
+func SleepWithContext(ctx context.Context, duration time.Duration) error {
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	case <-time.After(duration):
+		return nil
+	}
+}
+
+func ComputeCacheKeyFromBytes(bytes []byte, feature string) string {
+	key := sha256.Sum256(bytes)
+	return fmt.Sprintf("%s-%s", feature, hex.EncodeToString(key[:]))
+}