@versori/run 0.2.29 → 0.3.0-beta.2

package/esm/src/services/platform/generated/types.gen.d.ts

@@ -0,0 +1,3798 @@
+export type Activation = {
+    id: string;
+    user: EndUser;
+    environment?: ProjectEnvironment;
+    connections?: Array<Connection>;
+    dynamicVariables?: DynamicVariables;
+};
+export type ActivationsList = Array<Activation>;
+/**
+ * ActivationCreate is the request payload to activate an environment for End User
+ *
+ */
+export type ActivationCreate = {
+    /**
+     * This userID could be the id or the external_id of the user that is being activated.
+     */
+    userId: string;
+    environmentId: string;
+    connections: Array<{
+        connectionTemplateId: TemplateId;
+        connection?: ConnectionCreate;
+        /**
+         * The id of an existing connection to be linked to the environment. If 'connection' is provided, this field is ignored.
+         */
+        existingConnectionId?: string;
+    }>;
+    dynamicVariables?: DynamicVariables;
+};
+/**
+ * ConnectionCreate defines the connection to create.
+ */
+export type ConnectionCreate = {
+    /**
+     * Name is the name of the Connection.
+     */
+    name: string;
+    credentials: ConnectionCredentialsCreate;
+    /**
+     * BaseURL is the base URL for the connection. This allows you to override the baseURL for the system being connected to.
+     * An example is where the system's baseURL is https://shopifyplaceholder.com and you want to connect to your own shopify
+     * which is at https://myshopify.com. Everything after the top-level domain will be ignored. If the scheme is missing, then
+     * https:// will be used.
+     *
+     */
+    baseUrl?: string;
+};
+export type EnvSystemConnectionCreate = {
+    connectionTemplateId: TemplateId;
+    connection: ConnectionCreate;
+};
+/**
+ * LinkConnectionEnvironment is the request payload to link an existing connection to an environment.
+ *
+ */
+export type LinkConnectionEnvironment = {
+    connectionTemplateId: TemplateId;
+};
+/**
+ * ProjectCreate is the request body for creating a new Project.
+ */
+export type ProjectCreate = {
+    /**
+     * Name is the name of the project.
+     */
+    name: string;
+    /**
+     * The unique identifier for the project.
+     */
+    id?: string;
+};
+/**
+ * ProjectUpdate is the request body for updating a Project.
+ */
+export type ProjectUpdate = {
+    /**
+     * Name is the name of the project.
+     */
+    name?: string;
+    settings?: ProjectSettings;
+    metadata?: ProjectMetadata;
+};
+/**
+ * ProjectSettings hold configuration for the project
+ */
+export type ProjectSettings = {
+    acceptCodeChangesAutomatically?: boolean;
+};
+/**
+ * ProjectMetadata hold metadata for the project
+ */
+export type ProjectMetadata = {
+    sentimentHistory?: Array<Sentiment>;
+};
+/**
+ * Sentiment is the sentiment of a project
+ */
+export type Sentiment = {
+    timestamp: string;
+    sentimentScore: number;
+    messageId: string;
+};
+/**
+ * SentimentRequest is the request body for adding a sentiment entry to a project
+ */
+export type SentimentRequest = {
+    /**
+     * The sentiment score for this entry
+     */
+    sentimentScore: number;
+    /**
+     * The message ID associated with this sentiment
+     */
+    messageId: string;
+};
+/**
+ * ProjectsList is the response body for listing all projects.
+ */
+export type ProjectsList = {
+    projects: Array<ProjectSummary>;
+};
+/**
+ * The Project represents a deployable unit within our platform that includes both the functional components (files) and configuration. It serves as the backbone of custom or predefined functionalities, allowing organizations to create, update, and manage APIs and projects.
+ *
+ */
+export type ProjectSummary = {
+    /**
+     * The unique identifier for the project.
+     */
+    id: string;
+    name: string;
+    createdAt: string;
+    /**
+     * List of environments for the project.
+     *
+     */
+    environments: Array<ProjectEnvironment>;
+};
+/**
+ * DynamicVariablesSchema is the JSON schema for the project's dynamic variables.
+ *
+ */
+export type DynamicVariablesSchema = {
+    [key: string]: unknown;
+};
+/**
+ * DynamicVariablesSchemaPatch is the request body for updating the project's dynamic variables.
+ *
+ */
+export type DynamicVariablesSchemaPatch = {
+    op: 'add' | 'remove' | 'replace';
+    /**
+     * The path to the field to update. This should be a JSON path to the field to update. For example, if you want
+     * to update/remove the dynamic variables `newVar` in the following schema:
+     *
+     * ```
+     * {
+     * "type": "object",
+     * "properties": {
+     * "newVar": {
+     * "type": "string"
+     * }
+     * }
+     * }
+     * ```
+     *
+     * The path would be `/properties/newVar`.
+     *
+     */
+    path: string;
+    /**
+     * The value to set the field to. This should be valid JSON schema containing the name of the variable, its type
+     * and any other properties. An example would be `{"newVar": {"type": "string"}}`.
+     *
+     */
+    value?: {
+        [key: string]: unknown;
+    };
+};
+/**
+ * The Project represents a deployable unit within our platform that includes both the functional components (files) and configuration. It serves as the backbone of custom or predefined functionalities, allowing organizations to create, update, and manage APIs and projects.
+ *
+ */
+export type Project = {
+    /**
+     * The unique identifier for the project.
+     */
+    id: string;
+    /**
+     * List of environments for the project.
+     *
+     */
+    environments: Array<ProjectEnvironment>;
+    name: string;
+    currentFiles: Files;
+    createdAt: string;
+    dynamicVariablesSchema?: DynamicVariablesSchema;
+    settings: ProjectSettings;
+    metadata: ProjectMetadata;
+};
+export type ProjectEnvironment = {
+    /**
+     * The unique identifier for the environment.
+     */
+    id: string;
+    name: string;
+    /**
+     * One of running|suspended|error|draft.
+     */
+    status: string;
+    createdAt: string;
+    updatedAt: string;
+    publicUrl: string;
+    /**
+     * The files associated with the project.
+     */
+    files?: Array<File>;
+    labels?: Labels;
+    config: EnvironmentConfig;
+};
+export type File = {
+    /**
+     * The name of the file.
+     */
+    filename: string;
+    /**
+     * The content of the file.
+     */
+    content: string;
+};
+export type Files = {
+    /**
+     * The files associated with the project.
+     */
+    files: Array<File>;
+    /**
+     * The labels associated with the project. Labels are stored as key-value pairs.
+     * Only string-string values are allowed
+     *
+     */
+    labels: {
+        [key: string]: unknown;
+    };
+};
+/**
+ * ErrorField denotes a field which has an error.
+ */
+export type ErrorField = {
+    /**
+     * Field is the name of the field which has an error, this may be a path to a nested field, including array
+     * elements. The format of this field is of the form: "field1.field2[0].field3"
+     *
+     */
+    field: string;
+    /**
+     * Message is the error message for this specific field.
+     */
+    message: string;
+};
+export type _Error = {
+    /**
+     * Code is a machine-readable error code.
+     */
+    code: string;
+    /**
+     * Message is a human-readable error message.
+     */
+    message: string;
+    fields?: Array<ErrorField>;
+    details?: string;
+};
+export type Log = {
+    timestamp: string;
+    severity: string;
+    message: string;
+    error?: string;
+    httpRequest?: {
+        [key: string]: unknown;
+    };
+    fields?: {
+        [key: string]: unknown;
+    };
+};
+export type Logs = {
+    logs: Array<Log>;
+    nextToken?: string;
+};
+export type PageInfo = {
+    totalCount: number;
+    next?: string;
+    prev?: string;
+};
+/**
+ * This is the ID of the template that the connection is created against.
+ *
+ */
+export type TemplateId = string;
+/**
+ * ConnectionUpdate is the request payload to update an existing connection.
+ *
+ */
+export type ConnectionUpdate = {
+    /**
+     * Name is the name of the Connection. This must be unique within the owning Connector.
+     */
+    name: string;
+    credentials: ConnectionCredentials;
+    /**
+     * The baseUrl on the connection allows a dynamic user to override the base URL of the connection. This is useful
+     * when users have their own instance of a service and want to connect to it.
+     *
+     * For example, a user may have their own instance of shopify and their url is `https://myshopify.com`. They can
+     * override the base url of the connection to `https://myshopify.com` and all requests will be made to this url.
+     * If it is left as an empty string, it will be ignored.
+     *
+     */
+    baseUrl: string;
+};
+/**
+ * Connection defines the credentials for the owning Connector, and additional variables
+ * which can be used to customize the Connector in a particular connection.
+ *
+ */
+export type Connection = {
+    /**
+     * ID is the unique identifier of the Connection. Typically this is only used internally and most (if not all)
+     * public-facing APIs will use the `name` in combination with the Connector's `id` instead.
+     *
+     */
+    id: string;
+    /**
+     * Name is the name of the Connection. This must be unique within the owning Connector.
+     */
+    name: string;
+    credentials: ConnectionCredentials;
+    /**
+     * The baseUrl on the connection allows a dynamic user to override the base URL of the connection. This is useful
+     * when users have their own instance of a service and want to connect to it.
+     *
+     * For example, a user may have their own instance of shopify and their url is `https://myshopify.com`. They can
+     * override the base url of the connection to `https://myshopify.com` and all requests will be made to this url.
+     * If it is left as an empty string, it will be ignored.
+     *
+     */
+    baseUrl?: string;
+    /**
+     * CreatedAt is the time the Connection was created.
+     */
+    createdAt: string;
+    /**
+     * UpdatedAt is the time the Connection was last updated.
+     */
+    updatedAt: string;
+    /**
+     * ID of the system to add the project environment.
+     */
+    systemId?: string;
+    connectionTemplateId?: TemplateId;
+};
+/**
+ * ConnectionCredentials defines the credentials for the owning Connector. If multiple
+ * credentials are defined for each type, they are applied to the request in the order they are defined. This is to
+ * enable Connectors which require both a user session token and an API key to be provided in the request.
+ *
+ */
+export type ConnectionCredentials = Array<ConnectionCredential>;
+/**
+ * ConnectionPage defines a page of Connection summaries.
+ */
+export type ConnectionPage = PageInfo & {
+    items: Array<Connection>;
+};
+/**
+ * ConnectionCredential contains the a Credential and the AuthSchemeConfig to define how the Credential should be used against the Connection's Connector.
+ */
+export type ConnectionCredential = {
+    id: string;
+    authSchemeConfig?: AuthSchemeConfig;
+    credential?: Credential;
+};
+/**
+ * CredentialBase is the base type for all credentials. It contains the common properties which are shared across
+ * all credential types.
+ *
+ */
+export type Credential = {
+    /**
+     * ID is the unique identifier of the Credential.
+     */
+    id: string;
+    /**
+     * OrganisationID is the unique identifier of the Organisation which owns the Credential.
+     */
+    organisationId: string;
+    type?: CredentialType;
+    /**
+     * Name is the name of the Credential.
+     */
+    name?: string;
+    /**
+     * Errors is a list of errors which occurred when attempting to validate the credential. This field may be
+     * undefined, which implies that validation has not occurred and the consumer cannot assume whether this
+     * Credential is valid or not. An empty array indicates that the Credential is valid.
+     *
+     */
+    errors?: Array<string>;
+    data?: CredentialData;
+    /**
+     * ExpiresAt denotes the time this credential should be automatically deleted. External systems can subscribe
+     * to deletion events and if the reason is "expired", can trigger the correct notifications to interested
+     * parties (such as un-publishing jobs which rely on the credential and emailing the owner to rectify it).
+     *
+     */
+    expiresAt?: string;
+};
+export type CredentialData = {
+    binary?: CredentialDataBinary;
+    none?: CredentialDataNone;
+    string?: CredentialDataString;
+    basicAuth?: CredentialDataBasicAuth;
+    oauth2Client?: CredentialDataOAuth2Client;
+    oauth2Token?: CredentialDataOAuth2Token;
+    oauth2Code?: CredentialDataOAuth2Code;
+    oauth2Password?: CredentialDataOAuth2Password;
+    certificate?: CredentialDataCertificate;
+    oauth1?: CredentialDataOAuth1;
+    oauth1Token?: CredentialDataOAuth1Token;
+};
+/**
+ * CredentialType denotes the type of the credential which determines what the Credential's `data` property will
+ * contain.
+ *
+ * - none: No credential is required to authenticate with the Connector.
+ * - string: The credential is a string value, such as an API key or password.
+ * - binary: The credential is a binary value, such as a private key, certificate or other file.
+ * - basic-auth: The credential is a username and password to be used for basic authentication.
+ * - oauth2-client: The credential is an OAuth2 client ID and secret to be used for OAuth2 authentication.
+ * - oauth2-code: The credential is a temporary authorization code which will be exchanged for an oauth2-token.
+ * - oauth2-password: The credential is an OAuth2 username and password with an optional client ID and secret to be used for OAuth2 authentication.
+ * - oauth2-token: The credential is an OAuth2 access_token to be used for OAuth2 authentication.
+ * - oauth1: The credential is an OAuth1 access_token to be used for OAuth1 authentication.
+ * - oauth1-token: The credential is the oatuh1 token allowing bypassing the user authorization step.
+ * - certificate: The credential is a PEM encoded certificate, key and CA to be used for TLS client authentication.
+ *
+ */
+export type CredentialType = 'none' | 'string' | 'binary' | 'basic-auth' | 'oauth2-client' | 'oauth1' | 'oauth1-token' | 'oauth2-code' | 'oauth2-password' | 'oauth2-token' | 'certificate';
+/**
+ * None
+ * CredentialDataNone contains no data as no credential is required to authenticate with the Connector. It is used
+ * purely as a placeholder to implement a consistent interface across all CredentialType/AuthSchemeTypes.
+ *
+ */
+export type CredentialDataNone = {
+    [key: string]: never;
+};
+/**
+ * String
+ * CredentialDataString contains a string value and nothing else and is commonly used for API keys. This value
+ * will be redacted when returned in a response.
+ *
+ */
+export type CredentialDataString = {
+    /**
+     * Value is a UTF-8 string containing the credential data. When read from the API this field will be redacted.
+     *
+     */
+    value: string;
+};
+/**
+ * JWT
+ * CredentialJWTBearer contains the username and password required to authenticate with the Connector. The
+ * `secret` property will be redacted when returned in a response.
+ *
+ */
+export type CredentialJwtBearer = {
+    algorithm: 'HS256' | 'HS384' | 'HS512' | 'RS256' | 'RS384' | 'RS512';
+    /**
+     * Secret is the base64 encoded secret used to sign new JWTs.
+     *
+     */
+    secret: string;
+    /**
+     * Payload is stringified JSON object containing the default set of claims to include in the JWT payload.
+     * Issued JWTs may contain additional claims and may overwrite ones defined here, such as `exp` and `iat`.
+     *
+     */
+    payload: string;
+    /**
+     * Expires in is a duration in the form `1h2m3s` (see Go's `time.Duration` documentation) which defined
+     * how long a newly issued JWT should be valid for.
+     *
+     */
+    expiresIn: string;
+    /**
+     * AuthorizationHeaderPrefix is the prefix to use when setting the Authorization header, for example,
+     * "Bearer" or "JWT".
+     *
+     */
+    authorizationHeaderPrefix: string;
+};
+/**
+ * Username/Password
+ * CredentialDataBasicAuth contains the username and password required to authenticate with the Connector. The
+ * `password` property will be redacted when returned in a response.
+ *
+ */
+export type CredentialDataBasicAuth = {
+    /**
+     * Username is the username used to authenticate with the Connector.
+     */
+    username: string;
+    /**
+     * Password is the password used to authenticate with the Connector. Will be redacted when returned in a
+     * response.
+     *
+     */
+    password: string;
+};
+/**
+ * Certificate
+ * CredentialDataCertificate contains the Certificate, Certificate key and CA(Certificate authority).
+ *
+ */
+export type CredentialDataCertificate = {
+    /**
+     * Certificate is the certificate that will be send to the connection.
+     */
+    certificate: string;
+    /**
+     * Key is the accompanying key for the certificate.
+     */
+    key: string;
+    /**
+     * CA is the Certificate Authority to verify the server certificates against.
+     */
+    ca: string;
+};
+/**
+ * OAuth 2.0 Password
+ * CredentialDataOAuth2Password contains the username and password of a Resource Owner within an OAuth 2.0
+ * application. The `password` property will be redacted when returned in a response.
+ *
+ */
+export type CredentialDataOAuth2Password = {
+    /**
+     * Username is the username used to authenticate with the Connector.
+     */
+    username: string;
+    /**
+     * Password is the password used to authenticate with the Connector. Will be redacted when returned in a
+     * response.
+     *
+     */
+    password: string;
+};
+/**
+ * OAuth 2.0 Client
+ * CredentialDataOAuth2Client contains the OAuth2 client credentials required to either issue an access token from
+ * a refresh_token, or via the `client_credentials` and `authorization_code` grant types. The `clientSecret` property will be redacted when
+ * returned in a response.
+ *
+ */
+export type CredentialDataOAuth2Client = {
+    /**
+     * ClientID is the OAuth2 client ID used to authenticate with the Connector.
+     *
+     */
+    clientId: string;
+    /**
+     * ClientSecret is the OAuth2 client secret used to authenticate with the Connector. Will be redacted when
+     * returned in a response.
+     *
+     */
+    clientSecret: string;
+    /**
+     * TokenURL is the URL which the application will use to issue an access token.
+     */
+    tokenUrl: string;
+    /**
+     * Scopes is a list of scopes which should be requested when issuing an access token. This is only required if
+     * this credential is being used on a `client_credentials` grant type, for `authorization_code` grant types the
+     * requested scopes come from the `CredentialDataOAuth2Token` credential.
+     *
+     */
+    scopes?: Array<string>;
+    /**
+     * AdditionalParams is a URL-encoded query string which can be used to pass additional
+     * parameters to the OAuth 2.0 token endpoint. These parameters are attached to the body
+     * in the formatted as the `application/x-www-form-urlencoded` content-type.
+     *
+     */
+    additionalParams?: string;
+    /**
+     * MTLSEnabled is a boolean flag which determines whether the client should use mutual TLS authentication when
+     * communicating with the OAuth2 provider. If enabled, the `mTLSCredentialId` field must be set, or it must be
+     * created via the `CreateConnection` endpoint with an associated mTLS credential defined beforehand, in which
+     * case the mTLSCredentialID field will be populated upon saving by the API.
+     *
+     */
+    mTLSEnabled?: boolean;
+    /**
+     * MTLSCredentialID is an optional reference to another credential being created.
+     * If set the certificate credential will be used when making a request to the tokenUrl.
+     *
+     */
+    mTLSCredentialId?: string;
+};
+/**
+ * OAuth 2.0 Token
+ * CredentialDataOAuth2Token is primarily used to store the refresh_token for an user who has authorized an OAuth2
+ * Application to access their data. However, this information is not exposed publicly and the only data visible
+ * via the API are the `scopes` which the user has granted consent for. This can be used to determine whether
+ * the user should be prompted to re-authorize the application with additional scopes in the event they choose to
+ * use a new endpoint which requires additional scopes to what they've already consented to.
+ *
+ */
+export type CredentialDataOAuth2Token = {
+    /**
+     * Scopes is a list of scopes which the user has granted consent for.
+     */
+    scopes: Array<string>;
+    /**
+     * AccessToken is the OAuth2 access token which can be used to authenticate with the Connector. This
+     * information is redacted when read from the API.
+     *
+     */
+    accessToken?: string;
+    /**
+     * TokenType is the type of token which is being issued. Defaults to "Bearer" if not set.
+     *
+     */
+    tokenType?: string;
+    /**
+     * ExpiresAt is the time at which the access token will expire. If not defined, the accessToken will be
+     * reused until a 401 response is received from the Connector, at which point the token should be refreshed
+     * with the provided `refreshToken`. Ideally this should be provided so that erroneous failures can be
+     * avoided.
+     *
+     */
+    expiresAt?: string;
+    /**
+     * RefreshToken is the OAuth2 refresh token which can be used to issue new access tokens. This information is
+     * redacted when read from the API.
+     *
+     * This is a required field as it is used to refresh the access token when it expires. If users are providing
+     * an access token which does not expire using this credential type, then the same functionality may be
+     * achieved by using a simple API key and OAuth 2.0 need not be used.
+     *
+     */
+    refreshToken: string;
+};
+/**
+ * OAuth 2.0 Code
+ * CredentialDataOAuth2Code is used to exchange an authorization code for an access token and
+ * is denoted by the `oauth2-code` type.
+ * This is only used when creating or updating an OAuth 2.0 connection using the
+ * `authorization_code` grant type. Retrieving this credential will return a payload of
+ * type `oauth2-token` in the shape of a `CredentialDataOAuth2Token` object.
+ *
+ */
+export type CredentialDataOAuth2Code = {
+    /**
+     * Code is the authorization code which will be exchanged for an access token.
+     *
+     */
+    code: string;
+    /**
+     * State is the state value which is propagated through the OAuth2 flow.
+     *
+     */
+    state: string;
+};
+/**
+ * OAuth1
+ */
+export type CredentialDataOAuth1 = {
+    state: string;
+    oauthToken: string;
+    oauthVerifier: string;
+};
+/**
+ * OAuth1Token
+ */
+export type CredentialDataOAuth1Token = {
+    token: string;
+    tokenSecret: string;
+    additionalParams?: Array<AdditionalParam>;
+};
+export type AdditionalParam = {
+    name: string;
+    value?: string;
+};
+/**
+ * Binary
+ * CredentialDataBinary is commonly used to store non-string data such as binary files or encryption keys. This
+ * value will be redacted when returned in a response.
+ *
+ */
+export type CredentialDataBinary = {
+    /**
+     * Value is a base64 encoded string containing the credential data. This could decode to a valid utf-8 string,
+     * or it could decode to a binary file such as a private key etc. When read from the API this field will be
+     * redacted.
+     *
+     */
+    valueBase64: string;
+};
+/**
+ * An AuthSchemeConfig describes how credentials should be used to authenticate with a System, an example being where
+ * an API key should be sent and what the header/query parameter/cookie name is. For OAuth2, this config object also
+ * contains data such as the token URL, client ID and secret, and scopes to request.
+ * This type contains a string called `type` which denotes which field in this object should be populated.
+ * For example if the `type` is `api-key`, then the `apiKey` field will be populated with an
+ * `AuthSchemeConfigAPIKey` object.
+ *
+ */
+export type AuthSchemeConfig = {
+    type: AuthSchemeType;
+    none?: AuthSchemeConfigNone;
+    apiKey?: AuthSchemeConfigApiKey;
+    basicAuth?: AuthSchemeConfigBasicAuth;
+    oauth2?: AuthSchemeConfigOAuth2;
+    oauth1?: AuthSchemeConfigOAuth1;
+    hmac?: AuthSchemeConfigHmac;
+    certificate?: AuthSchemeConfigCertificate;
+};
+/**
+ * API Key
+ * AuthSchemeConfigAPIKey defines how a Connector uses an API key credential to authenticate with the system.
+ *
+ */
+export type AuthSchemeConfigApiKey = AuthSchemeConfigBase & {
+    /**
+     * Name is the query parameter/header/cookie name which will be used to send the API key.
+     */
+    name: string;
+    in: AuthSchemeConfigApiKeyIn;
+};
+/**
+ * AuthSchemeConfigAPIKeyIn defines the location of the API key in the request.
+ *
+ */
+export type AuthSchemeConfigApiKeyIn = 'query' | 'header' | 'cookie';
+/**
+ * Type is a unique identifier of the AuthScheme, this is a kebab-case formatted string, see
+ * enum values for possible options.
+ *
+ */
+export type AuthSchemeType = 'none' | 'api-key' | 'basic-auth' | 'oauth2' | 'hmac' | 'jwt-bearer' | 'certificate' | 'oauth1' | 'secret';
+/**
+ * OAuth2Scope represents a single scope which can be requested by an OAuth2 application.
+ *
+ */
+export type OAuth2Scope = {
+    /**
+     * Name is the name of the scope as determined by the application to which this Connector
+     * is connecting to.
+     *
+     */
+    name: string;
+    /**
+     * Description describes the scope in human-friendly terminology. This text may be
+     * displayed to users via a help tooltip or similar.
+     *
+     */
+    description?: string;
+};
+export type AuthSchemeConfigBase = {
+    /**
+     * ID is the unique identifier of the AuthSchemeConfig, this is generated by the client and
+     * only requires to be unique amongst the elements of the array in which is it contained.
+     *
+     */
+    id: string;
+    /**
+     * Description enables users to distinguish multiple configurations which use the same
+     * schemeType.
+     *
+     */
+    description: string;
+    /**
+     * ValidationMessages is a list of messages which are generated when the AuthSchemeConfig
+     * is validated. This is typically used to provide feedback to the user when they are
+     * creating or updating the AuthSchemeConfig.
+     *
+     * This field will be ignored if sent to the API.
+     *
+     */
+    validationMessages?: Array<Message>;
+};
+export type AuthSchemeConfigOAuth2GrantType = 'authorizationCode' | 'clientCredentials' | 'password';
+/**
+ * authorization_code
+ * AuthSchemeConfigOAuth2GrantAuthorizationCode contains grant-specific configuration for the
+ * `authorization_code` grant type.
+ *
+ * How the API manages changes to this configuration is as follows:
+ *
+ * - CredentialID and OrganisationID are not set, a new credential is created containing the
+ * sensitive information and the non-sensitive information is updated in the database.
+ * - Otherwise, both the credential and the database are updated using JSON Merge Patch, with
+ * undefined properties not being updated.
+ * - Any other permutation will result in a 400 Bad Request.
+ *
+ */
+export type AuthSchemeConfigOAuth2GrantAuthorizationCode = {
+    /**
+     * CredentialID is the unique identifier of the Credential which contains the client ID and
+     * client secret to be used as part of the `password` flow.
+     *
+     */
+    credentialId?: string;
+    /**
+     * OrganisationID is the unique identifier of the Organisation that owns the Credential.
+     * This can be different to the Connector's OrganisationID since some may be imported from
+     * Versori's public library.
+     *
+     */
+    organisationId?: string;
+    /**
+     * ClientID is the OAuth 2.0 client's identifier. This is not a sensitive value and may be
+     * presented to the user in plaintext.
+     *
+     */
+    clientId?: string;
+    /**
+     * ClientSecret is the OAuth 2.0 client's secret. This is a sensitive value and will not be
+     * displayed to the user.
+     *
+     */
+    clientSecret?: string;
+};
+/**
+ * client_credentials
+ */
+export type AuthSchemeConfigOAuth2GrantClientCredentials = {
+    [key: string]: unknown;
+};
+/**
+ * password
+ * AuthSchemeConfigOAuth2GrantPassword contains grant-specific configuration for the `password`
+ * grant type.
+ *
+ * How the API manages changes to this configuration is as follows:
+ *
+ * - CredentialID and OrganisationID are not set, a new credential is created containing the
+ * sensitive information and the non-sensitive information is created/updated in the
+ * database.
+ * - Otherwise, both the credential and the database are updated using JSON Merge Patch.
+ * - Any other permutation will result in a 400 Bad Request.
+ *
+ */
+export type AuthSchemeConfigOAuth2GrantPassword = {
+    /**
+     * CredentialID is the unique identifier of the Credential which contains the client ID and
+     * client secret to be used as part of the `password` flow.
+     *
+     */
+    credentialId?: string;
+    /**
+     * OrganisationID is the unique identifier of the Organisation that owns the Credential. This can be different
+     * to the Connector's OrganisationID since some may be imported from Versori's public library.
+     *
+     */
+    organisationId?: string;
+    /**
+     * ClientID is the OAuth 2.0 client's identifier. This is not a sensitive value and may be presented to the
+     * user in plaintext.
+     *
+     */
+    clientId?: string;
+    /**
+     * ClientSecret is the OAuth 2.0 client's secret. This is a sensitive value and will not be displayed to the
+     * user. It may be populated when updating the Credential.
+     *
+     */
+    clientSecret?: string;
+};
+export type AuthSchemeConfigOAuth2Grant = {
+    authorizationCode?: AuthSchemeConfigOAuth2GrantAuthorizationCode;
+    clientCredentials?: AuthSchemeConfigOAuth2GrantClientCredentials;
+    password?: AuthSchemeConfigOAuth2GrantPassword;
+    type: AuthSchemeConfigOAuth2GrantType;
+};
+/**
+ * None
+ * AuthSchemeConfigNone is a placeholder object with the schemeType set to `none`. There is no other configuration
+ * required.
+ *
+ */
+export type AuthSchemeConfigNone = AuthSchemeConfigBase;
+/**
+ * Basic Auth
+ * AuthSchemeConfigBasicAuth is a placeholder object with the schemeType set to `basic-auth`. There is no other
+ * configuration required.
+ *
+ */
+export type AuthSchemeConfigBasicAuth = AuthSchemeConfigBase;
+/**
+ * TLS Certificate
+ * AuthSchemeConfigCertificate is a placeholder object with the schemeType set to `certificate`.
+ * There is no other config required
+ *
+ */
+export type AuthSchemeConfigCertificate = AuthSchemeConfigBase;
+/**
+ * OAuth 2.0
+ * AuthSchemeConfigOAuth2 defines how a Connector uses an OAuth2 credential to authenticate
+ * with the system. This is to be used for all OAuth 2.0 flows which require a client ID and
+ * client secret as part of the Connector's configuration. Connectors which use the
+ * `client_credentials` grant type, where the user provides the Client ID  and Client Secret at
+ * the point where they connect, should use the `AuthSchemeConfigOAuth2ClientCredentials` type
+ * instead.
+ *
+ */
+export type AuthSchemeConfigOAuth2 = AuthSchemeConfigBase & {
+    /**
+     * AuthorizeURL is the URL which the user will be redirected to in order to authorize
+     * the application.
+     *
+     */
+    authorizeUrl?: string;
+    /**
+     * TokenURL is the URL which the application will use to issue an access token.
+     *
+     */
+    tokenUrl: string;
+    /**
+     * Scopes is the list of all OAuth2 scopes which the application supports. The user
+     * will be allowed to choose which scopes to request when configuring the Connection.
+     *
+     */
+    scopes: Array<OAuth2Scope>;
+    /**
+     * DefaultScopes is the list of scopes which will be requested by default when the user
+     * connects the Connector. This is useful for Connectors which require a specific set
+     * of scopes to function correctly.
+     *
+     */
+    defaultScopes: Array<string>;
+    /**
+     * AdditionalAuthorizeParams is a URL-encoded query string which should be attached to
+     * the AuthorizeURL when the user is redirected to the OAuth 2.0 authorization
+     * endpoint.
+     *
+     * This value is only used by the UI to drive the default values when connecting, the
+     * API to `InitialiseOAuth2Connection` can be provided a different value if required.
+     *
+     */
+    additionalAuthorizeParams?: string;
+    /**
+     * AdditionalTokenParams is a URL-encoded string following the
+     * `application/x-www-form-urlencoded` mime-type, which can be used to pass additional
+     * parameters to the OAuth 2.0 token endpoint within the request body.
+     *
+     */
+    additionalTokenParams?: string;
+    /**
+     * MTLSEnabled is a flag which determines whether the Connector should use Mutual TLS
+     * (mTLS) to authenticate with the OAuth 2.0 token endpoint. This is useful for
+     * Connectors which require a higher level of security.
+     *
+     */
+    mtlsEnabled?: boolean;
+    /**
+     * MTLSCredentialID is the unique identifier of the Credential which contains the
+     * client certificate and private key to be used as part of the mTLS connection.
+     *
+     * This may be unset when creating a connection, in which case if `mtlsEnabled` is
+     * true, then the API will find an associated AuthSchemeConfigCertificate and link
+     * them automatically.
+     *
+     */
+    mtlsCredentialId?: string;
+    pkce?: boolean;
+    grant: AuthSchemeConfigOAuth2Grant;
+};
+/**
+ * OAuth 2.0
+ */
+export type AuthSchemeConfigOAuth1 = AuthSchemeConfigBase & {
+    /**
+     * If set to 'true' the endpoints are optional but when connecting you need to use oauth1-token credentials and provide the token and token secret.
+     * If left empty or set to 'false' you need to provide all the endpoint and connect using the oauth1 credentials which uses the browser authorize flow.
+     *
+     */
+    tokenAuth?: boolean;
+    consumerKey: string;
+    consumerSecret: string;
+    tempCredentialEndpoint?: Endpoint;
+    resourceOwnerAuthorizationEndpoint?: Endpoint;
+    tokenEndpoint?: Endpoint;
+    /**
+     * One of 'sha256', 'sha1'
+     */
+    signatureMethod: string;
+    credentialId?: string;
+};
+export type Endpoint = {
+    /**
+     * URL of the endpoint, may contain templated values in curly braces
+     */
+    url: string;
+    additionalParamConfigs?: Array<ParameterConfig>;
+    parameterTransmission?: 'AUTH_STYLE_AUTHORIZATION_HEADER' | 'AUTH_STYLE_FORM' | 'AUTH_STYLE_QUERY';
+};
+export type ParameterConfig = {
+    /**
+     * Key of the additional parameter to insert
+     */
+    parameterName: string;
+    /**
+     * Override name for the parameter in endpoint requests
+     */
+    targetName?: string;
+    location: 'LOCATION_IGNORE' | 'LOCATION_BODY' | 'LOCATION_HEADER' | 'LOCATION_QUERY' | 'LOCATION_ENDPOINT' | 'LOCATION_HEADER_PARAMETER';
+    usages?: 'USAGE_UNKNOWN' | 'USAGE_TEMP_CREDENTIAL_ENDPOINT' | 'USAGE_TOKEN_REQUEST_ENDPOINT';
+    /**
+     * Whether parameter is required in requests
+     */
+    required: boolean;
+    /**
+     * Whether parameter can be modified by user
+     */
+    modifiable: boolean;
+};
+/**
+ * AuthSchemeConfigHMACIn defines where the signature should be set on requests.
+ */
+export type AuthSchemeConfigHmacIn = 'query' | 'header' | 'cookie';
+/**
+ * HMAC
+ * AuthSchemeConfigHMAC defines how a Connector uses an HMAC credential to authenticate with the system.
+ *
+ * This may be used on outbound requests to sign the request body, however it is more commonly used on inbound
+ * requests (i.e. from Webhook Triggers) to verify the sender of the request is allowed to invoke the Trigger.
+ *
+ */
+export type AuthSchemeConfigHmac = AuthSchemeConfigBase & {
+    /**
+     * Name is the query parameter/header/cookie name which will be used to send the signature.
+     */
+    name: string;
+    in: AuthSchemeConfigHmacIn;
+    /**
+     * AuthSchemeConfigHMACAlgorithm defines the hashing algorithm to use when generating the HMAC signature.
+     */
+    algorithm: 'sha1' | 'sha256' | 'sha512';
+    /**
+     * AuthSchemeConfigHMACInputs defines what parts of a HTTP request are consumed to generate the HMAC signature. Some systems
+     * only generate the signature from the request body, others may include the URL. The order of this array
+     * defines the order in which the input is fed into the hashing function.
+     *
+     */
+    digestInputs: Array<'body' | 'url'>;
+    /**
+     * Encoding defines how the HMAC signature was encoded. This can be one of `hex`, `base64` or `base64url`.
+     *
+     */
+    encoding: 'hex' | 'base64' | 'base64url';
+};
+/**
+ * Message is a message to be displayed to the user to indicate some information about the
+ * preceding request.
+ *
+ */
+export type Message = {
+    /**
+     * Text contains the text of the message.
+     */
+    text: string;
+    severity: MessageSeverity;
+    /**
+     * Details contains additional information about the message. This is intended to be used
+     * to provide more information about the message, such as a list of validation errors.
+     *
+     */
+    detail?: Array<string>;
+};
+export type MessageSeverity = 'info' | 'warning' | 'error';
+/**
+ * InitialiseOAuth2ConnectionRequest is the payload to initialise an OAuth 2.0 connection.
+ *
+ */
+export type InitialiseOAuth2ConnectionRequest = {
+    credential: {
+        /**
+         * ID is the unique identifier of the credential which is being used to
+         * initialise the connection. This is used to load the client_secret when the authorisation
+         * code is exchanged for an access token.
+         *
+         */
+        id: string;
+        /**
+         * OrganisationID is the unique identifier of the organisation which the credential is
+         * associated with. This is used to ensure that the credential is only used to initialise
+         * connections for the organisation which owns the credential.
+         *
+         */
+        organisationId: string;
+    };
+    /**
+     * AuthorizeURL is the URL which the user will be redirected to in order to authorize
+     * the application.
+     *
+     */
+    authorizeUrl: string;
+    /**
+     * ClientID is the OAuth 2.0 client ID which is used to identify the application to the
+     * OAuth 2.0 provider.
+     *
+     */
+    clientId: string;
+    /**
+     * Scopes is a list of OAuth 2.0 scopes which the application is requesting access to.
+     *
+     * Unless `disableOfflineAccess` is set to true, the API will also include the standard
+     * `offline_access` scope in addition to the ones provided here.
+     *
+     */
+    scopes?: Array<string>;
+    /**
+     * DisableOfflineAccess is a flag which can be set to true to disable the inclusion of the
+     * standard `offline_access` scope in the list of scopes. This is defined separately to
+     * `scopes` to make it clear that the API will always include the `offline_access` scope
+     * by default, but can be disabled if the system does not implement the standards so that
+     * the user can define their own custom scope as part of `scopes`.
+     *
+     */
+    disableOfflineAccess?: boolean;
+    /**
+     * Prompt controls the behaviour of the OAuth 2.0 provider when the user is redirected to
+     * the authorize URL. This is typically used to force the user to re-authenticate or to
+     * select a user account.
+     *
+     * If set, should be one of "none", "login", "consent", "select_account". However the
+     * specification dictates that arbitrary prompts may be provided in case of new values
+     * added in the future. Some providers also allow multiple values to be provided, separated
+     * by the '+' symbol, i.e. `consent+select_account`.
+     *
+     * If not provided, this API defaults to "login", unless `additionalParams` contains the
+     * `approval_prompt` parameter (thanks, Google refresh tokens), in which case this value
+     * does not default to anything.
+     *
+     */
+    prompt?: string;
+    /**
+     * AdditionalParams is a URL-encoded query string which can be used to pass additional
+     * parameters to the OAuth 2.0 authorize endpoint. These cannot conflict with any of the
+     * other parameters defined by the request, an attempt to do so will result in an error.
+     *
+     * These parameters are attached to returned URL as query parameters.
+     *
+     */
+    additionalParams?: string;
+};
+/**
+ * InitialiseOAuth2ConnectionResponse contains the URL to redirect the user to in order to
+ * initiate an OAuth 2.0 `authorization_code` grant flow.
+ *
+ */
+export type InitialiseOAuth2ConnectionResponse = {
+    /**
+     * The URL to redirect the user to.
+     */
+    url: string;
+};
+/**
+ * InitialiseOAuth1ConnectionRequest is the payload to initialise an OAuth 1.0 connection.
+ *
+ */
+export type InitialiseOAuth1ConnectionRequest = {
+    credential: {
+        id: string;
+        organisationId: string;
+    };
+};
+export type InitialiseOAuth1ConnectionResponse = {
+    /**
+     * The URL to redirect the user to.
+     */
+    url: string;
+};
+export type ConnectionCredentialsCreate = Array<ConnectionCredential>;
+export type EndUser = {
+    /**
+     * ID is the Versori identifier for the user. Most APIs will not use this field but instead reference
+     * users by their externalId.
+     *
+     */
+    id: string;
+    /**
+     * ExternalID is the identifier for the user as determined by the organisation. This typically should
+     * be the same as the user's ID on the organisations system. Regardless of the value, it must
+     * be unique within the Organisation.
+     *
+     */
+    externalId: string;
+    /**
+     * DisplayName is an optional human-readable name for the user. If not set, the default is an empty string.
+     *
+     */
+    displayName: string;
+    /**
+     * The organisation ID to which the user belongs to.
+     */
+    organisationId: string;
+    /**
+     * CreatedAt is the time the user was created.
+     */
+    createdAt: string;
+    /**
+     * UpdatedAt is the time the user was last updated.
+     */
+    updatedAt: string;
+};
+/**
+ * Request to create a new End User
+ */
+export type EndUserCreate = {
+    /**
+     * ExternalID is the identifier of the user
+     */
+    externalId: string;
+    /**
+     * DisplayName is a human-readable name for the user
+     */
+    displayName?: string;
+};
+export type EndUserPage = PageInfo & {
+    users: Array<EndUser>;
+};
+export type Automation = {
+    id: string;
+    name: string;
+    createdAt?: string;
+    promptTemplate: string;
+    secretNames?: Array<string>;
+};
+export type AutomationRunCreate = {
+    prompt: string;
+    /**
+     * The maximum number of steps the agent can take.
+     */
+    maxSteps?: number;
+    /**
+     * The webhook URL to send the run results to.
+     */
+    webhookUrl?: string;
+};
+export type AutomationRun = {
+    id: string;
+    status: AutomationJobStatus;
+    prompt: string;
+    executionId: string;
+    artifacts?: Array<AutomationRunArtifact>;
+};
+export type TranscriptionCreate = {
+    recording_id: string;
+};
+export type AutomationRecording = {
+    id: string;
+    transcription: string;
+    status: AutomationJobStatus;
+};
+export type AutomationJobStatus = 'pending' | 'running' | 'completed' | 'failed';
+export type AutomationRunArtifact = {
+    name?: string;
+    url?: string;
+};
+export type AutomationRunResponse = {
+    runId: string;
+};
+export type AutomationCreate = {
+    name: string;
+    promptTemplate?: string;
+};
+export type AutomationUpdate = {
+    /**
+     * The updated name for the automation
+     */
+    name?: string;
+    /**
+     * The updated prompt template for the automation
+     */
+    promptTemplate?: string;
+    secrets?: Array<AutomationSecret>;
+};
+export type AutomationSecret = {
+    name?: string;
+    value?: string;
+};
+export type UpdateSystem = {
+    name?: string;
+    domain?: string;
+    templateBaseUrl?: string;
+};
+export type SystemCreate = {
+    name: string;
+    domain: string;
+    templateBaseUrl: string;
+    authSchemeConfigs: Array<AuthSchemeConfig>;
+    labels?: Labels;
+};
+export type LinkSystem = {
+    /**
+     * ID of the system to add the project environment.
+     */
+    systemId: string;
+    /**
+     * How you will reference your system from the SDK.
+     */
+    name: string;
+    /**
+     * The environment to link the system to.
+     */
+    environmentId?: string;
+    /**
+     * If the connections to the system need to be dynamic or static.
+     * Dynamic connections are used when the integration runs for multiple end users.
+     * Defaults to false if not set.
+     *
+     */
+    dynamic?: boolean;
+};
+export type System = {
+    id: string;
+    name: string;
+    domain: string;
+    authSchemeConfigs: Array<AuthSchemeConfig>;
+    templateBaseUrl: string;
+};
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+export type ActionType = 'http' | 'graphql';
+export type ActionParameter = {
+    name: string;
+    in: 'path' | 'query' | 'header';
+    required: boolean;
+    type: 'string' | 'integer' | 'boolean';
+    default?: string;
+};
+export type ActionPage = PageInfo & {
+    actions: Array<Action>;
+};
+export type TriggerPage = PageInfo & {
+    triggers: Array<Trigger>;
+};
+export type Action = {
+    id: string;
+    systemId: string;
+    type: ActionType;
+    name: string;
+    /**
+     * ContentType is the content type that this action expects to receive in the request body if any, and the
+     * content type of the response body if any. If this field is left blank, then "application/json" is assumed.
+     *
+     */
+    contentType?: string;
+    summary?: string;
+    description?: string;
+    method: HttpMethod;
+    /**
+     * Path is the path of the action, which may contain templated values in curly braces.
+     * For example, `/users/{userId}`. The path should be the full path relative to the base URL of the system,
+     * the base URL containing everything before (and including) the top-level domain (.com, .gov, .org etc).
+     *
+     */
+    path: string;
+    /**
+     * Parameters is a list of parameters which are used to configure the action. These may be
+     * used to set values in the path, query string or headers of the request. Note that when creating an action,
+     * if the path contains templated values in curly braces, these will automatically be converted into
+     * parameters of type `path` with the name of the parameter being the name of the templated value.
+     *
+     */
+    parameters: Array<ActionParameter>;
+    /**
+     * GraphQLQuery is the GraphQL query to execute for the action. This is only used if the action type is `graphql`.
+     *
+     */
+    graphqlQuery?: string;
+    /**
+     * Request is the request body of the action. This is only used if the action type is `http`.
+     *
+     */
+    request?: string;
+    /**
+     * Response is the response body of the action. This is only used if the action type is `http`.
+     *
+     */
+    response?: string;
+};
+export type Trigger = {
+    id: string;
+    systemId: string;
+    name: string;
+    description: string;
+    summary: string;
+    type: 'http';
+    method: HttpMethod;
+    parameters: Array<ActionParameter>;
+};
+export type CreateActions = {
+    projectId?: string;
+    actions: Array<{
+        name: string;
+        description?: string;
+        summary?: string;
+        type: ActionType;
+        method: HttpMethod;
+        path: string;
+        /**
+         * ContentType is the content type that this action expects to receive in the request body if any, and the
+         * content type of the response body if any. If this field is left blank, then "application/json" is assumed.
+         *
+         */
+        contentType?: string;
+        parameters?: Array<ActionParameter>;
+        graphqlQuery?: string;
+        request?: string;
+        response?: string;
+    }>;
+};
+export type CreateTriggers = {
+    projectId?: string;
+    triggers: Array<{
+        name: string;
+        description?: string;
+        summary?: string;
+        method: HttpMethod;
+        parameters?: Array<ActionParameter>;
+    }>;
+};
+export type UpdateConnectionTemplate = {
+    /**
+     * The name of the template. This is how the connections should be referenced in code.
+     */
+    name?: string;
+    dynamic?: boolean;
+    /**
+     * The IDs of the auth scheme config to use for this connection template. The overwhelming majority of the time,
+     * this will only be a single ID. To see about multiple auth scheme configs, see ConnectionTemplate for details.
+     *
+     */
+    authSchemeConfigIds?: Array<string>;
+};
+export type ConnectionTemplate = {
+    /**
+     * The system ID.
+     */
+    id: string;
+    connectionTemplateId?: string;
+    /**
+     * The name of the template. This is how the connections should be referenced in code.
+     */
+    name: string;
+    domain: string;
+    dynamic: boolean;
+    /**
+     * AuthSchemeConfigs is a list of auth scheme configs which are used to authenticate with the system.
+     * This is used to determine how the connection should be authenticated, and may contain multiple
+     * configs for different authentication methods. The overwhelming majority of the time, this will be a single config.
+     * There does exist cases where credentials may need to be applied in sequence, such as mTLS. If there are multiple
+     * auth scheme configs here, it acts like a queue and they are applied in order.
+     *
+     */
+    authSchemeConfigs: Array<AuthSchemeConfig>;
+    templateBaseUrl: string;
+};
+/**
+ * TriggerPage defines a paginated list of Triggers.
+ */
+export type EnvironmentSystemPage = PageInfo & {
+    items: Array<ConnectionTemplate>;
+    next?: string;
+    prev?: string;
+};
+/**
+ * TriggerPage defines a paginated list of Triggers.
+ */
+export type SystemPage = PageInfo & {
+    items: Array<System>;
+};
+/**
+ * Labels is a map of key-value pairs that can be used to store arbitrary metadata about a resource.
+ * Keys must start with a letter and can only contain letters, numbers, and underscores.
+ * Values can be any string.
+ *
+ */
+export type Labels = {
+    [key: string]: unknown;
+};
+export type TraceSearch = {
+    items: Array<SpanSummary>;
+    nextToken?: string;
+};
+export type Scheduler = {
+    id: string;
+    /**
+     * The name of the scheduler.
+     */
+    name: string;
+    /**
+     * The cron schedule for the scheduler.
+     */
+    schedule: string;
+    /**
+     * The URL to which the scheduler will send requests.
+     */
+    url: string;
+    environment_id: string;
+};
+export type SpanSummary = {
+    /**
+     * The unique identifier for the trace
+     */
+    traceId: string;
+    /**
+     * The unique identifier for the span within the trace
+     */
+    spanId: string;
+    /**
+     * The name of the span
+     */
+    name: string;
+    /**
+     * The name of the service that generated the span
+     */
+    serviceName: string;
+    /**
+     * The time when the span started
+     */
+    startTime: string;
+    /**
+     * The duration of the span
+     */
+    duration: string;
+    executionId: string;
+};
+export type Trace = {
+    /**
+     * Unique identifier for the trace
+     */
+    traceId: string;
+    spans: Array<Span>;
+};
+export type Span = {
+    /**
+     * Unique identifier for the span
+     */
+    spanId: string;
+    /**
+     * ID of the parent span
+     */
+    parentSpanId: string;
+    /**
+     * Name of the span
+     */
+    name: string;
+    /**
+     * Start time of the span
+     */
+    startTime: string;
+    /**
+     * End time of the span
+     */
+    endTime: string;
+    attributes: Array<Attribute>;
+    status: TraceStatus;
+};
+export type Attribute = {
+    /**
+     * Attribute key
+     */
+    key: string;
+    /**
+     * Attribute value
+     */
+    value: string;
+};
+export type TraceStatus = {
+    /**
+     * Status code of the span
+     */
+    code: 'OK' | 'ERROR';
+};
+export type DynamicVariables = {
+    [key: string]: unknown;
+};
+export type EnvironmentConfig = {
+    deploymentSpec?: DeploymentSpec;
+};
+export type DeploymentSpec = {
+    replicas?: number;
+    affinity?: Affinity;
+    tolerations?: Array<Toleration>;
+    resources?: Resources;
+};
+export type Affinity = {
+    nodeAffinity?: NodeAffinity;
+};
+export type NodeAffinity = {
+    requiredDuringSchedulingIgnoredDuringExecution?: Array<NodeSelectorTerm>;
+};
+export type PreferredSchedulingTerm = {
+    weight?: number;
+    preference?: NodeSelectorTerm;
+};
+export type NodeSelectorTerm = {
+    matchExpressions?: Array<NodeSelectorRequirement>;
+    matchFields?: Array<NodeSelectorRequirement>;
+};
+export type NodeSelectorRequirement = {
+    key: string;
+    operator: string;
+    values: Array<string>;
+};
+export type Toleration = {
+    effect: string;
+    key: string;
+    operator: string;
+    value: string;
+};
+export type Resources = {
+    limits?: ResourceRequirements;
+    requests?: ResourceRequirements;
+};
+export type ResourceRequirements = {
+    cpu?: string;
+    memory?: string;
+};
+export type CreateRecordingResponse = {
+    id: string;
+    /**
+     * The pre-signed URL that can be used to upload the file
+     */
+    url: string;
+};
+export type CreateRecordingRequest = {
+    /**
+     * The name of the file to be uploaded
+     */
+    fileName: string;
+    /**
+     * The content type of the file to be uploaded
+     */
+    contentType: string;
+    /**
+     * The number of seconds the signed URL will be valid for
+     */
+    expirySeconds?: number;
+    /**
+     * Whether the recording has voiceover content
+     */
+    hasVoiceover?: boolean;
+};
+export type SignedUrlResponse = {
+    /**
+     * The pre-signed URL that can be used to upload the file
+     */
+    url: string;
+    /**
+     * The time when the URL will expire
+     */
+    expiresAt: string;
+};
+/**
+ * Reason for the issue creation
+ */
+export type IssueReasonEnum = 'error' | 'manual';
+/**
+ * Severity level of the issue
+ */
+export type IssueSeverityEnum = 'high' | 'low' | 'medium';
+/**
+ * Current status of the issue
+ */
+export type IssueStatusEnum = 'open' | 'closed' | 'acked' | 'resolved';
+/**
+ * Status of the issue resolution
+ */
+export type IssueResolutionStatusEnum = 'resolved' | 'negated' | 'ignored';
+export type Issue = {
+    /**
+     * Unique identifier for the issue (ULID)
+     */
+    id: string;
+    /**
+     * ID of the organization the isszue belongs to
+     */
+    organisationId: string;
+    /**
+     * ID of the project the issue belongs to
+     */
+    projectId: string;
+    /**
+     * ID of the environment the issue occurred in
+     */
+    environmentId: string;
+    status: IssueStatusEnum;
+    reason: IssueReasonEnum;
+    /**
+     * Detailed message of the issue
+     */
+    message: string;
+    /**
+     * Title of the issue
+     */
+    title: string;
+    /**
+     * Key-value pairs for searchable labels
+     */
+    labels: {
+        [key: string]: string;
+    };
+    /**
+     * Key-value pairs for additional non-searchable information
+     */
+    annotations: {
+        [key: string]: string;
+    };
+    resolutionStatus?: IssueResolutionStatusEnum;
+    /**
+     * Timestamp when the issue was created
+     */
+    createdAt: string;
+    /**
+     * Timestamp when the issue was resolved
+     */
+    resolvedAt?: string | null;
+    /**
+     * Timestamp when the issue was last seen
+     */
+    lastSeenAt: string;
+    /**
+     * Number of times the issue has been seen
+     */
+    seenCount: number;
+    severity?: IssueSeverityEnum;
+};
+export type UpdateIssue = {
+    reason?: IssueReasonEnum;
+    /**
+     * Detailed message of the issue
+     */
+    message?: string;
+    /**
+     * Title of the issue
+     */
+    title?: string;
+    /**
+     * Key-value pairs for searchable labels
+     */
+    labels?: {
+        [key: string]: string;
+    };
+    /**
+     * Key-value pairs for additional non-searchable information
+     */
+    annotations?: {
+        [key: string]: string;
+    };
+    severity?: IssueSeverityEnum;
+    /**
+     * Timestamp when the issue was resolved
+     */
+    resolvedAt?: string | null;
+    resolutionStatus?: IssueResolutionStatusEnum;
+    status?: IssueStatusEnum;
+};
+export type CreateIssue = {
+    /**
+     * ID of the organization the issue belongs to
+     */
+    organisationId: string;
+    /**
+     * ID of the project the issue belongs to
+     */
+    projectId?: string;
+    /**
+     * ID of the environment the issue occurred in
+     */
+    environmentId: string;
+    reason: IssueReasonEnum;
+    /**
+     * Detailed message of the issue
+     */
+    message?: string;
+    /**
+     * Title of the issue
+     */
+    title: string;
+    /**
+     * Key-value pairs for searchable labels
+     */
+    labels?: {
+        [key: string]: string;
+    };
+    /**
+     * Key-value pairs for additional non-searchable information
+     */
+    annotations?: {
+        [key: string]: string;
+    };
+    severity: IssueSeverityEnum;
+};
+export type NotificationChannelList = {
+    items: Array<NotificationChannel>;
+};
+export type NotificationChannel = {
+    id: string;
+    organisation_id: string;
+    name: string;
+    type: string;
+    config: NotificationConfig;
+    created_at: string;
+    updated_at: string;
+};
+export type CreateNotificationChannel = {
+    name: string;
+    type: string;
+    config: NotificationConfig;
+};
+export type NotificationConfig = {
+    email?: EmailNotificationConfig;
+};
+export type EmailNotificationConfig = {
+    to: string;
+    cc?: Array<string>;
+};
+export type ProjectNotificationList = {
+    items: Array<ProjectNotification>;
+};
+export type ProjectNotification = {
+    id: string;
+    project_id: string;
+    environment_id: string;
+    channel_id: string;
+    created_at: string;
+    name: string;
+    channelName: string;
+    type?: string;
+    config: NotificationConfig;
+};
+export type CreateProjectNotification = {
+    channel_id: string;
+    environment_id: string;
+    name: string;
+};
+export type OrganisationId = string;
+export type ConnectionId = string;
+export type AutomationId = string;
+export type RecordingId = string;
+export type RunId = string;
+export type EnvironmentId = string;
+export type SchedulerId = string;
+export type ActivationId = string;
+/**
+ * The static query parameter is used to list the static activation/user on endpoints.
+ * This query parameter is really only intended for internal use or by the UI.
+ *
+ */
+export type Static = boolean;
+export type EnvSystemId = string;
+export type ProjectId = string;
+export type SystemId = string;
+export type ActionId = string;
+export type EnvId = string;
+export type ProjectEnv = string;
+export type ProjectIdQuery = string;
+export type First = number;
+export type Before = string;
+export type After = string;
+export type Search = string;
+export type ActivateUserData = {
+    body?: ActivationCreate;
+    path: {
+        organisation_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/activations';
+};
+export type ActivateUserResponses = {
+    /**
+     * OK
+     */
+    200: Activation;
+};
+export type ActivateUserResponse = ActivateUserResponses[keyof ActivateUserResponses];
+export type ListProjectsData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/projects';
+};
+export type ListProjectsErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type ListProjectsError = ListProjectsErrors[keyof ListProjectsErrors];
+export type ListProjectsResponses = {
+    /**
+     * OK
+     */
+    200: ProjectsList;
+};
+export type ListProjectsResponse = ListProjectsResponses[keyof ListProjectsResponses];
+export type CreateProjectData = {
+    body?: ProjectCreate;
+    path: {
+        organisation_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/projects';
+};
+export type CreateProjectErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type CreateProjectError = CreateProjectErrors[keyof CreateProjectErrors];
+export type CreateProjectResponses = {
+    /**
+     * OK
+     */
+    200: Project;
+};
+export type CreateProjectResponse = CreateProjectResponses[keyof CreateProjectResponses];
+export type DeleteProjectData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        project_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/projects/{project_id}';
+};
+export type DeleteProjectErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type DeleteProjectError = DeleteProjectErrors[keyof DeleteProjectErrors];
+export type DeleteProjectResponses = {
+    /**
+     * OK
+     */
+    204: void;
+};
+export type DeleteProjectResponse = DeleteProjectResponses[keyof DeleteProjectResponses];
+export type GetProjectData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        project_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/projects/{project_id}';
+};
+export type GetProjectErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type GetProjectError = GetProjectErrors[keyof GetProjectErrors];
+export type GetProjectResponses = {
+    /**
+     * OK
+     */
+    200: Project;
+};
+export type GetProjectResponse = GetProjectResponses[keyof GetProjectResponses];
+export type UpdateProjectData = {
+    body: ProjectUpdate;
+    path: {
+        organisation_id: string;
+        project_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/projects/{project_id}';
+};
+export type UpdateProjectErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type UpdateProjectError = UpdateProjectErrors[keyof UpdateProjectErrors];
+export type UpdateProjectResponses = {
+    /**
+     * OK
+     */
+    200: Project;
+};
+export type UpdateProjectResponse = UpdateProjectResponses[keyof UpdateProjectResponses];
+export type CloneProjectData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        project_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/projects/{project_id}/clone';
+};
+export type CloneProjectErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type CloneProjectError = CloneProjectErrors[keyof CloneProjectErrors];
+export type CloneProjectResponses = {
+    /**
+     * OK
+     */
+    200: Project;
+};
+export type CloneProjectResponse = CloneProjectResponses[keyof CloneProjectResponses];
+export type PatchProjectVariablesSchemaData = {
+    body: DynamicVariablesSchemaPatch;
+    path: {
+        organisation_id: string;
+        project_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/projects/{project_id}/variables';
+};
+export type PatchProjectVariablesSchemaErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type PatchProjectVariablesSchemaError = PatchProjectVariablesSchemaErrors[keyof PatchProjectVariablesSchemaErrors];
+export type PatchProjectVariablesSchemaResponses = {
+    /**
+     * OK
+     */
+    200: DynamicVariablesSchema;
+};
+export type PatchProjectVariablesSchemaResponse = PatchProjectVariablesSchemaResponses[keyof PatchProjectVariablesSchemaResponses];
+export type SetProjectVariablesSchemaData = {
+    body: DynamicVariablesSchema;
+    path: {
+        organisation_id: string;
+        project_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/projects/{project_id}/variables';
+};
+export type SetProjectVariablesSchemaErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type SetProjectVariablesSchemaError = SetProjectVariablesSchemaErrors[keyof SetProjectVariablesSchemaErrors];
+export type SetProjectVariablesSchemaResponses = {
+    /**
+     * OK
+     */
+    200: DynamicVariablesSchema;
+};
+export type SetProjectVariablesSchemaResponse = SetProjectVariablesSchemaResponses[keyof SetProjectVariablesSchemaResponses];
+export type AddProjectSentimentData = {
+    body: SentimentRequest;
+    path: {
+        organisation_id: string;
+        project_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/projects/{project_id}/sentiment';
+};
+export type AddProjectSentimentErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type AddProjectSentimentError = AddProjectSentimentErrors[keyof AddProjectSentimentErrors];
+export type AddProjectSentimentResponses = {
+    /**
+     * OK
+     */
+    200: Project;
+};
+export type AddProjectSentimentResponse = AddProjectSentimentResponses[keyof AddProjectSentimentResponses];
+export type GetFilesData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        project_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/projects/{project_id}/files';
+};
+export type GetFilesErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type GetFilesError = GetFilesErrors[keyof GetFilesErrors];
+export type GetFilesResponses = {
+    /**
+     * OK
+     */
+    200: Files;
+};
+export type GetFilesResponse = GetFilesResponses[keyof GetFilesResponses];
+export type UpdateFilesData = {
+    body: Files;
+    path: {
+        organisation_id: string;
+        project_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/projects/{project_id}/files';
+};
+export type UpdateFilesErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type UpdateFilesError = UpdateFilesErrors[keyof UpdateFilesErrors];
+export type UpdateFilesResponses = {
+    /**
+     * OK
+     */
+    200: Files;
+};
+export type UpdateFilesResponse = UpdateFilesResponses[keyof UpdateFilesResponses];
+export type DeployProjectData = {
+    body: Files;
+    path: {
+        organisation_id: string;
+        project_id: string;
+    };
+    query?: {
+        project_env?: string;
+        env_id?: string;
+    };
+    url: '/o/{organisation_id}/projects/{project_id}/deploy';
+};
+export type DeployProjectErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type DeployProjectError = DeployProjectErrors[keyof DeployProjectErrors];
+export type DeployProjectResponses = {
+    /**
+     * OK
+     */
+    200: Project;
+};
+export type DeployProjectResponse = DeployProjectResponses[keyof DeployProjectResponses];
+export type GetProjectLogsData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        project_id: string;
+    };
+    query?: {
+        project_env?: string;
+        first?: number;
+        next_token?: string;
+        start?: string;
+        end?: string;
+        search?: string;
+        build?: boolean;
+        /**
+         * If true, returns only the latest logs
+         */
+        latest?: boolean;
+        /**
+         * One of 'asc' or 'desc'
+         */
+        order?: string;
+    };
+    url: '/o/{organisation_id}/projects/{project_id}/logs';
+};
+export type GetProjectLogsErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type GetProjectLogsError = GetProjectLogsErrors[keyof GetProjectLogsErrors];
+export type GetProjectLogsResponses = {
+    /**
+     * OK
+     */
+    200: Logs;
+};
+export type GetProjectLogsResponse = GetProjectLogsResponses[keyof GetProjectLogsResponses];
+export type ListTracesData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        project_id: string;
+    };
+    query?: {
+        project_env?: string;
+        next_token?: string;
+        start?: string;
+        end?: string;
+        /**
+         * Filter executions by attribute.
+         *
+         * Example query: 'http.request.method:POST executionId:01JSPK1SB6S622T6E1P9BBJTWP'
+         *
+         * Available attributes are:
+         * - "taskId"
+         * - "taskType"
+         * - "executionId"
+         * - "error.message"
+         * - "error.stack"
+         * - "schedule"
+         * - "connection"
+         * - "http.request.method"
+         * - "http.response.status_code"
+         * - "server.address"
+         * - "server.port"
+         * - "url.full"
+         * - "url.path"
+         * - "url.query"
+         * - "url.scheme"
+         *
+         */
+        filter?: string;
+        error?: boolean;
+        task?: string;
+    };
+    url: '/o/{organisation_id}/projects/{project_id}/traces';
+};
+export type ListTracesErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type ListTracesError = ListTracesErrors[keyof ListTracesErrors];
+export type ListTracesResponses = {
+    /**
+     * OK
+     */
+    200: TraceSearch;
+};
+export type ListTracesResponse = ListTracesResponses[keyof ListTracesResponses];
+export type GetTraceData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        project_id: string;
+        trace_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/projects/{project_id}/traces/{trace_id}';
+};
+export type GetTraceErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type GetTraceError = GetTraceErrors[keyof GetTraceErrors];
+export type GetTraceResponses = {
+    /**
+     * OK
+     */
+    200: Trace;
+};
+export type GetTraceResponse = GetTraceResponses[keyof GetTraceResponses];
+export type SuspendProjectData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        project_id: string;
+    };
+    query: {
+        /**
+         * The environment to suspend the project in.
+         */
+        environment: string;
+    };
+    url: '/o/{organisation_id}/projects/{project_id}/suspend';
+};
+export type SuspendProjectErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type SuspendProjectError = SuspendProjectErrors[keyof SuspendProjectErrors];
+export type SuspendProjectResponses = {
+    /**
+     * OK
+     */
+    200: Project;
+};
+export type SuspendProjectResponse = SuspendProjectResponses[keyof SuspendProjectResponses];
+export type ListConnectionsData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+    };
+    query?: {
+        first?: number;
+        after?: string;
+        before?: string;
+        system_id?: string;
+        end_user_id?: string;
+    };
+    url: '/o/{organisation_id}/connections';
+};
+export type ListConnectionsErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type ListConnectionsError = ListConnectionsErrors[keyof ListConnectionsErrors];
+export type ListConnectionsResponses = {
+    /**
+     * OK
+     */
+    200: ConnectionPage;
+};
+export type ListConnectionsResponse = ListConnectionsResponses[keyof ListConnectionsResponses];
+export type CreateConnectionData = {
+    body?: EnvSystemConnectionCreate;
+    path: {
+        organisation_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/connections';
+};
+export type CreateConnectionErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type CreateConnectionError = CreateConnectionErrors[keyof CreateConnectionErrors];
+export type CreateConnectionResponses = {
+    /**
+     * Created
+     */
+    201: Connection;
+};
+export type CreateConnectionResponse = CreateConnectionResponses[keyof CreateConnectionResponses];
+export type GetConnectionData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        connection_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/connections/{connection_id}';
+};
+export type GetConnectionErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type GetConnectionError = GetConnectionErrors[keyof GetConnectionErrors];
+export type GetConnectionResponses = {
+    /**
+     * OK
+     */
+    200: Connection;
+};
+export type GetConnectionResponse = GetConnectionResponses[keyof GetConnectionResponses];
+export type UpdateConnectionData = {
+    body: ConnectionUpdate;
+    path: {
+        organisation_id: string;
+        connection_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/connections/{connection_id}';
+};
+export type UpdateConnectionErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type UpdateConnectionError = UpdateConnectionErrors[keyof UpdateConnectionErrors];
+export type UpdateConnectionResponses = {
+    /**
+     * OK
+     */
+    200: Connection;
+};
+export type UpdateConnectionResponse = UpdateConnectionResponses[keyof UpdateConnectionResponses];
+export type LinkConnectionToEnvironmentData = {
+    body?: LinkConnectionEnvironment;
+    path: {
+        organisation_id: string;
+        connection_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/connections/{connection_id}/link';
+};
+export type LinkConnectionToEnvironmentErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type LinkConnectionToEnvironmentError = LinkConnectionToEnvironmentErrors[keyof LinkConnectionToEnvironmentErrors];
+export type LinkConnectionToEnvironmentResponses = {
+    /**
+     * Created
+     */
+    201: unknown;
+};
+export type ListEndUsersData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+    };
+    query?: {
+        /**
+         * Search is a string that is used to filter the list of End Users. The search string is matched against the
+         * id, externalId and displayName fields.
+         *
+         */
+        search?: string;
+        /**
+         * Filter users by their activation status. Must be used together with environment_id.
+         * If not provided, returns all users regardless of activation status.
+         *
+         */
+        activated?: boolean;
+        /**
+         * Filter users by activations in a specific environment. Must be used together with the 'activated' parameter.
+         * When combined with 'activated=true', it returns users that are activated in the specified environment.
+         * When combined with 'activated=false', it returns users that are not activated in this specific environment.
+         * If not provided, returns users from all environments.
+         *
+         */
+        environment_id?: string;
+    };
+    url: '/o/{organisation_id}/users';
+};
+export type ListEndUsersErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type ListEndUsersError = ListEndUsersErrors[keyof ListEndUsersErrors];
+export type ListEndUsersResponses = {
+    /**
+     * OK
+     */
+    200: EndUserPage;
+};
+export type ListEndUsersResponse = ListEndUsersResponses[keyof ListEndUsersResponses];
+export type CreateEndUserData = {
+    body?: EndUserCreate;
+    path: {
+        organisation_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/users';
+};
+export type CreateEndUserErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type CreateEndUserError = CreateEndUserErrors[keyof CreateEndUserErrors];
+export type CreateEndUserResponses = {
+    /**
+     * Created
+     */
+    201: EndUser;
+};
+export type CreateEndUserResponse = CreateEndUserResponses[keyof CreateEndUserResponses];
+export type ListAutomationsData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/automations';
+};
+export type ListAutomationsErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type ListAutomationsError = ListAutomationsErrors[keyof ListAutomationsErrors];
+export type ListAutomationsResponses = {
+    /**
+     * OK
+     */
+    200: Array<Automation>;
+};
+export type ListAutomationsResponse = ListAutomationsResponses[keyof ListAutomationsResponses];
+export type CreateAutomationData = {
+    body?: AutomationCreate;
+    path: {
+        organisation_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/automations';
+};
+export type CreateAutomationErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type CreateAutomationError = CreateAutomationErrors[keyof CreateAutomationErrors];
+export type CreateAutomationResponses = {
+    /**
+     * Created
+     */
+    201: Automation;
+};
+export type CreateAutomationResponse = CreateAutomationResponses[keyof CreateAutomationResponses];
+export type ListAutomationRunsData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        automation_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/automations/{automation_id}/run';
+};
+export type ListAutomationRunsErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type ListAutomationRunsError = ListAutomationRunsErrors[keyof ListAutomationRunsErrors];
+export type ListAutomationRunsResponses = {
+    /**
+     * OK
+     */
+    200: Array<AutomationRun>;
+};
+export type ListAutomationRunsResponse = ListAutomationRunsResponses[keyof ListAutomationRunsResponses];
+export type RunAutomationData = {
+    body?: AutomationRunCreate;
+    path: {
+        organisation_id: string;
+        automation_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/automations/{automation_id}/run';
+};
+export type RunAutomationResponses = {
+    /**
+     * Accepted
+     */
+    202: AutomationRunResponse;
+};
+export type RunAutomationResponse = RunAutomationResponses[keyof RunAutomationResponses];
+export type GetAutomationData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        automation_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/automations/{automation_id}';
+};
+export type GetAutomationErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type GetAutomationError = GetAutomationErrors[keyof GetAutomationErrors];
+export type GetAutomationResponses = {
+    /**
+     * OK
+     */
+    200: Automation;
+};
+export type GetAutomationResponse = GetAutomationResponses[keyof GetAutomationResponses];
+export type UpdateAutomationData = {
+    body: AutomationUpdate;
+    path: {
+        organisation_id: string;
+        automation_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/automations/{automation_id}';
+};
+export type UpdateAutomationErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type UpdateAutomationError = UpdateAutomationErrors[keyof UpdateAutomationErrors];
+export type UpdateAutomationResponses = {
+    /**
+     * OK
+     */
+    200: Automation;
+};
+export type UpdateAutomationResponse = UpdateAutomationResponses[keyof UpdateAutomationResponses];
+export type ListRecordingsData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        automation_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/automations/{automation_id}/recordings';
+};
+export type ListRecordingsErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type ListRecordingsError = ListRecordingsErrors[keyof ListRecordingsErrors];
+export type ListRecordingsResponses = {
+    /**
+     * OK
+     */
+    200: Array<AutomationRecording>;
+};
+export type ListRecordingsResponse = ListRecordingsResponses[keyof ListRecordingsResponses];
+export type CreateRecordingData = {
+    body?: CreateRecordingRequest;
+    path: {
+        organisation_id: string;
+        automation_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/automations/{automation_id}/recordings';
+};
+export type CreateRecordingErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type CreateRecordingError = CreateRecordingErrors[keyof CreateRecordingErrors];
+export type CreateRecordingResponses = {
+    /**
+     * OK
+     */
+    200: CreateRecordingResponse;
+};
+export type CreateRecordingResponse2 = CreateRecordingResponses[keyof CreateRecordingResponses];
+export type GetAutomationRunData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        automation_id: string;
+        run_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/automations/{automation_id}/runs/{run_id}';
+};
+export type GetAutomationRunErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type GetAutomationRunError = GetAutomationRunErrors[keyof GetAutomationRunErrors];
+export type GetAutomationRunResponses = {
+    /**
+     * OK
+     */
+    200: AutomationRun;
+};
+export type GetAutomationRunResponse = GetAutomationRunResponses[keyof GetAutomationRunResponses];
+export type GetRecordingData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        automation_id: string;
+        recording_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/automations/{automation_id}/recordings/{recording_id}';
+};
+export type GetRecordingErrors = {
+    /**
+     * Error
+     */
+    default: unknown;
+};
+export type GetRecordingResponses = {
+    /**
+     * OK
+     */
+    200: AutomationRecording;
+};
+export type GetRecordingResponse = GetRecordingResponses[keyof GetRecordingResponses];
+export type CreateTranscriptionData = {
+    body?: TranscriptionCreate;
+    path: {
+        organisation_id: string;
+        automation_id: string;
+        recording_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/automations/{automation_id}/recordings/{recording_id}';
+};
+export type CreateTranscriptionErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type CreateTranscriptionError = CreateTranscriptionErrors[keyof CreateTranscriptionErrors];
+export type CreateTranscriptionResponses = {
+    /**
+     * Accepted
+     */
+    202: AutomationRecording;
+};
+export type CreateTranscriptionResponse = CreateTranscriptionResponses[keyof CreateTranscriptionResponses];
+export type ListSchedulersData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        environment_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/environments/{environment_id}/schedulers';
+};
+export type ListSchedulersErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type ListSchedulersError = ListSchedulersErrors[keyof ListSchedulersErrors];
+export type ListSchedulersResponses = {
+    /**
+     * OK
+     */
+    200: Array<Scheduler>;
+};
+export type ListSchedulersResponse = ListSchedulersResponses[keyof ListSchedulersResponses];
+export type GetSchedulerData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        environment_id: string;
+        scheduler_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/environments/{environment_id}/schedulers/{scheduler_id}';
+};
+export type GetSchedulerErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type GetSchedulerError = GetSchedulerErrors[keyof GetSchedulerErrors];
+export type GetSchedulerResponses = {
+    /**
+     * OK
+     */
+    200: Scheduler;
+};
+export type GetSchedulerResponse = GetSchedulerResponses[keyof GetSchedulerResponses];
+export type TriggerSchedulerData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        environment_id: string;
+        scheduler_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/environments/{environment_id}/schedulers/{scheduler_id}';
+};
+export type TriggerSchedulerErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type TriggerSchedulerError = TriggerSchedulerErrors[keyof TriggerSchedulerErrors];
+export type TriggerSchedulerResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type TriggerSchedulerResponse = TriggerSchedulerResponses[keyof TriggerSchedulerResponses];
+export type ListActivationsData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        environment_id: string;
+    };
+    query?: {
+        /**
+         * The static query parameter is used to list the static activation/user on endpoints.
+         * This query parameter is really only intended for internal use or by the UI.
+         *
+         */
+        static?: boolean;
+    };
+    url: '/o/{organisation_id}/environments/{environment_id}/activations';
+};
+export type ListActivationsErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type ListActivationsError = ListActivationsErrors[keyof ListActivationsErrors];
+export type ListActivationsResponses = {
+    /**
+     * OK
+     */
+    200: ActivationsList;
+};
+export type ListActivationsResponse = ListActivationsResponses[keyof ListActivationsResponses];
+export type DeleteActivationData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        environment_id: string;
+        activation_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/environments/{environment_id}/activations/{activation_id}';
+};
+export type DeleteActivationErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type DeleteActivationError = DeleteActivationErrors[keyof DeleteActivationErrors];
+export type DeleteActivationResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type DeleteActivationResponse = DeleteActivationResponses[keyof DeleteActivationResponses];
+export type GetActivationData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        environment_id: string;
+        activation_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/environments/{environment_id}/activations/{activation_id}';
+};
+export type GetActivationErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type GetActivationError = GetActivationErrors[keyof GetActivationErrors];
+export type GetActivationResponses = {
+    /**
+     * OK
+     */
+    200: Activation;
+};
+export type GetActivationResponse = GetActivationResponses[keyof GetActivationResponses];
+export type SetStaticUserVariablesData = {
+    body: DynamicVariables;
+    path: {
+        organisation_id: string;
+        environment_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/environments/{environment_id}/variables';
+};
+export type SetStaticUserVariablesErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type SetStaticUserVariablesError = SetStaticUserVariablesErrors[keyof SetStaticUserVariablesErrors];
+export type SetStaticUserVariablesResponses = {
+    /**
+     * Variables updated successfully
+     */
+    200: DynamicVariables;
+};
+export type SetStaticUserVariablesResponse = SetStaticUserVariablesResponses[keyof SetStaticUserVariablesResponses];
+export type UpdateEnvironmentConfigData = {
+    body: EnvironmentConfig;
+    path: {
+        organisation_id: string;
+        environment_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/environments/{environment_id}/config';
+};
+export type UpdateEnvironmentConfigErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type UpdateEnvironmentConfigError = UpdateEnvironmentConfigErrors[keyof UpdateEnvironmentConfigErrors];
+export type UpdateEnvironmentConfigResponses = {
+    /**
+     * ok
+     */
+    204: void;
+};
+export type UpdateEnvironmentConfigResponse = UpdateEnvironmentConfigResponses[keyof UpdateEnvironmentConfigResponses];
+export type SetDynamicVariablesData = {
+    body: DynamicVariables;
+    path: {
+        organisation_id: string;
+        environment_id: string;
+        activation_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/environments/{environment_id}/activations/{activation_id}/variables';
+};
+export type SetDynamicVariablesErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type SetDynamicVariablesError = SetDynamicVariablesErrors[keyof SetDynamicVariablesErrors];
+export type SetDynamicVariablesResponses = {
+    /**
+     * Variables updated successfully
+     */
+    200: DynamicVariables;
+};
+export type SetDynamicVariablesResponse = SetDynamicVariablesResponses[keyof SetDynamicVariablesResponses];
+export type SetDynamicVariableData = {
+    body: {
+        /**
+         * The new value for the variable (can be any JSON type)
+         */
+        value: unknown;
+    };
+    path: {
+        organisation_id: string;
+        environment_id: string;
+        activation_id: string;
+        /**
+         * The name of the dynamic variable to update
+         */
+        variable_name: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/environments/{environment_id}/activations/{activation_id}/variables/{variable_name}';
+};
+export type SetDynamicVariableErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type SetDynamicVariableError = SetDynamicVariableErrors[keyof SetDynamicVariableErrors];
+export type SetDynamicVariableResponses = {
+    /**
+     * Variable updated successfully
+     */
+    200: DynamicVariables;
+};
+export type SetDynamicVariableResponse = SetDynamicVariableResponses[keyof SetDynamicVariableResponses];
+export type ListUserActivationsData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        environment_id: string;
+        /**
+         * The external ID of the user
+         */
+        external_user_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/environment/{environment_id}/users/{external_user_id}/activations';
+};
+export type ListUserActivationsErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type ListUserActivationsError = ListUserActivationsErrors[keyof ListUserActivationsErrors];
+export type ListUserActivationsResponses = {
+    /**
+     * OK
+     */
+    200: Array<Activation>;
+};
+export type ListUserActivationsResponse = ListUserActivationsResponses[keyof ListUserActivationsResponses];
+export type DeleteEndUserData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        /**
+         * The ID of the user
+         */
+        user_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/users/{user_id}';
+};
+export type DeleteEndUserErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type DeleteEndUserError = DeleteEndUserErrors[keyof DeleteEndUserErrors];
+export type DeleteEndUserResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type DeleteEndUserResponse = DeleteEndUserResponses[keyof DeleteEndUserResponses];
+export type GetEndUserData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        /**
+         * The ID of the user
+         */
+        user_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/users/{user_id}';
+};
+export type GetEndUserErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type GetEndUserError = GetEndUserErrors[keyof GetEndUserErrors];
+export type GetEndUserResponses = {
+    /**
+     * OK
+     */
+    200: EndUser;
+};
+export type GetEndUserResponse = GetEndUserResponses[keyof GetEndUserResponses];
+export type GetActivationConnectionData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        env_system_id: string;
+        activation_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/environment-systems/{env_system_id}/activations/{activation_id}';
+};
+export type GetActivationConnectionResponses = {
+    /**
+     * OK
+     */
+    200: Connection;
+};
+export type GetActivationConnectionResponse = GetActivationConnectionResponses[keyof GetActivationConnectionResponses];
+export type ListSystemsData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+    };
+    query?: {
+        first?: number;
+        after?: string;
+        before?: string;
+        search?: string;
+    };
+    url: '/o/{organisation_id}/systems';
+};
+export type ListSystemsResponses = {
+    /**
+     * OK
+     */
+    200: SystemPage;
+};
+export type ListSystemsResponse = ListSystemsResponses[keyof ListSystemsResponses];
+export type CreateSystemData = {
+    body?: SystemCreate;
+    path: {
+        organisation_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/systems';
+};
+export type CreateSystemErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type CreateSystemError = CreateSystemErrors[keyof CreateSystemErrors];
+export type CreateSystemResponses = {
+    /**
+     * Created
+     */
+    201: System;
+};
+export type CreateSystemResponse = CreateSystemResponses[keyof CreateSystemResponses];
+export type GetSystemData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        system_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/systems/{system_id}';
+};
+export type GetSystemErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type GetSystemError = GetSystemErrors[keyof GetSystemErrors];
+export type GetSystemResponses = {
+    /**
+     * OK
+     */
+    200: System;
+};
+export type GetSystemResponse = GetSystemResponses[keyof GetSystemResponses];
+export type UpdateSystemData = {
+    body?: UpdateSystem;
+    path: {
+        organisation_id: string;
+        system_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/systems/{system_id}';
+};
+export type UpdateSystemErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type UpdateSystemError = UpdateSystemErrors[keyof UpdateSystemErrors];
+export type UpdateSystemResponses = {
+    /**
+     * Created
+     */
+    201: System;
+};
+export type UpdateSystemResponse = UpdateSystemResponses[keyof UpdateSystemResponses];
+export type LinkSystemActionsData = {
+    body?: Array<string>;
+    path: {
+        organisation_id: string;
+        project_id: string;
+        system_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/systems/{system_id}/projects/{project_id}/actions-link';
+};
+export type LinkSystemActionsErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type LinkSystemActionsError = LinkSystemActionsErrors[keyof LinkSystemActionsErrors];
+export type LinkSystemActionsResponses = {
+    /**
+     * Created
+     */
+    201: unknown;
+};
+export type LinkSystemTriggersData = {
+    body?: Array<string>;
+    path: {
+        organisation_id: string;
+        project_id: string;
+        system_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/systems/{system_id}/projects/{project_id}/triggers-link';
+};
+export type LinkSystemTriggersErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type LinkSystemTriggersError = LinkSystemTriggersErrors[keyof LinkSystemTriggersErrors];
+export type LinkSystemTriggersResponses = {
+    /**
+     * Created
+     */
+    201: unknown;
+};
+export type ListSystemActionsData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        system_id: string;
+    };
+    query?: {
+        project_id?: string;
+    };
+    url: '/o/{organisation_id}/systems/{system_id}/actions';
+};
+export type ListSystemActionsErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type ListSystemActionsError = ListSystemActionsErrors[keyof ListSystemActionsErrors];
+export type ListSystemActionsResponses = {
+    /**
+     * OK
+     */
+    200: ActionPage;
+};
+export type ListSystemActionsResponse = ListSystemActionsResponses[keyof ListSystemActionsResponses];
+export type CreateSystemActionsData = {
+    body?: CreateActions;
+    path: {
+        organisation_id: string;
+        system_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/systems/{system_id}/actions';
+};
+export type CreateSystemActionsErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type CreateSystemActionsError = CreateSystemActionsErrors[keyof CreateSystemActionsErrors];
+export type CreateSystemActionsResponses = {
+    /**
+     * OK
+     */
+    200: Array<Action>;
+};
+export type CreateSystemActionsResponse = CreateSystemActionsResponses[keyof CreateSystemActionsResponses];
+export type DeleteSystemActionData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        system_id: string;
+        action_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/systems/{system_id}/actions/{action_id}';
+};
+export type DeleteSystemActionErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type DeleteSystemActionError = DeleteSystemActionErrors[keyof DeleteSystemActionErrors];
+export type DeleteSystemActionResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type DeleteSystemActionResponse = DeleteSystemActionResponses[keyof DeleteSystemActionResponses];
+export type GetSystemActionData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        system_id: string;
+        action_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/systems/{system_id}/actions/{action_id}';
+};
+export type GetSystemActionErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type GetSystemActionError = GetSystemActionErrors[keyof GetSystemActionErrors];
+export type GetSystemActionResponses = {
+    /**
+     * OK
+     */
+    200: Action;
+};
+export type GetSystemActionResponse = GetSystemActionResponses[keyof GetSystemActionResponses];
+export type UpdateSystemActionData = {
+    body?: Action;
+    path: {
+        organisation_id: string;
+        system_id: string;
+        action_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/systems/{system_id}/actions/{action_id}';
+};
+export type UpdateSystemActionErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type UpdateSystemActionError = UpdateSystemActionErrors[keyof UpdateSystemActionErrors];
+export type UpdateSystemActionResponses = {
+    /**
+     * OK
+     */
+    200: Action;
+};
+export type UpdateSystemActionResponse = UpdateSystemActionResponses[keyof UpdateSystemActionResponses];
+export type ListSystemTriggersData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        system_id: string;
+    };
+    query?: {
+        project_id?: string;
+    };
+    url: '/o/{organisation_id}/systems/{system_id}/triggers';
+};
+export type ListSystemTriggersErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type ListSystemTriggersError = ListSystemTriggersErrors[keyof ListSystemTriggersErrors];
+export type ListSystemTriggersResponses = {
+    /**
+     * OK
+     */
+    200: TriggerPage;
+};
+export type ListSystemTriggersResponse = ListSystemTriggersResponses[keyof ListSystemTriggersResponses];
+export type CreateSystemTriggersData = {
+    body?: CreateTriggers;
+    path: {
+        organisation_id: string;
+        system_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/systems/{system_id}/triggers';
+};
+export type CreateSystemTriggersErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type CreateSystemTriggersError = CreateSystemTriggersErrors[keyof CreateSystemTriggersErrors];
+export type CreateSystemTriggersResponses = {
+    /**
+     * OK
+     */
+    200: Array<Trigger>;
+};
+export type CreateSystemTriggersResponse = CreateSystemTriggersResponses[keyof CreateSystemTriggersResponses];
+export type DeleteAuthSchemeConfigData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        system_id: string;
+        auth_scheme_config_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/systems/{system_id}/auth-scheme-configs/{auth_scheme_config_id}';
+};
+export type DeleteAuthSchemeConfigErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type DeleteAuthSchemeConfigError = DeleteAuthSchemeConfigErrors[keyof DeleteAuthSchemeConfigErrors];
+export type DeleteAuthSchemeConfigResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type DeleteAuthSchemeConfigResponse = DeleteAuthSchemeConfigResponses[keyof DeleteAuthSchemeConfigResponses];
+export type UpsertAuthSchemeConfigData = {
+    body?: AuthSchemeConfig;
+    path: {
+        organisation_id: string;
+        system_id: string;
+        auth_scheme_config_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/systems/{system_id}/auth-scheme-configs/{auth_scheme_config_id}';
+};
+export type UpsertAuthSchemeConfigErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type UpsertAuthSchemeConfigError = UpsertAuthSchemeConfigErrors[keyof UpsertAuthSchemeConfigErrors];
+export type UpsertAuthSchemeConfigResponses = {
+    /**
+     * Created
+     */
+    201: AuthSchemeConfig;
+};
+export type UpsertAuthSchemeConfigResponse = UpsertAuthSchemeConfigResponses[keyof UpsertAuthSchemeConfigResponses];
+export type ListEnvironmentConnectionsData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        project_id: string;
+    };
+    query?: {
+        env_id?: string;
+    };
+    url: '/o/{organisation_id}/projects/{project_id}/connections';
+};
+export type ListEnvironmentConnectionsErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type ListEnvironmentConnectionsError = ListEnvironmentConnectionsErrors[keyof ListEnvironmentConnectionsErrors];
+export type ListEnvironmentConnectionsResponses = {
+    /**
+     * OK
+     */
+    200: ConnectionPage;
+};
+export type ListEnvironmentConnectionsResponse = ListEnvironmentConnectionsResponses[keyof ListEnvironmentConnectionsResponses];
+export type ListProjectConnectionTemplatesData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        project_id: string;
+    };
+    query?: {
+        env_id?: string;
+    };
+    url: '/o/{organisation_id}/projects/{project_id}/connection-templates';
+};
+export type ListProjectConnectionTemplatesResponses = {
+    /**
+     * OK
+     */
+    200: EnvironmentSystemPage;
+};
+export type ListProjectConnectionTemplatesResponse = ListProjectConnectionTemplatesResponses[keyof ListProjectConnectionTemplatesResponses];
+export type CreateConnectionTemplateData = {
+    body?: LinkSystem;
+    path: {
+        organisation_id: string;
+        project_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/projects/{project_id}/connection-templates';
+};
+export type CreateConnectionTemplateErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type CreateConnectionTemplateError = CreateConnectionTemplateErrors[keyof CreateConnectionTemplateErrors];
+export type CreateConnectionTemplateResponses = {
+    /**
+     * OK
+     */
+    200: ConnectionTemplate;
+};
+export type CreateConnectionTemplateResponse = CreateConnectionTemplateResponses[keyof CreateConnectionTemplateResponses];
+export type DeleteConnectionTemplateData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        project_id: string;
+        template_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/projects/{project_id}/connection-templates/{template_id}';
+};
+export type DeleteConnectionTemplateErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type DeleteConnectionTemplateError = DeleteConnectionTemplateErrors[keyof DeleteConnectionTemplateErrors];
+export type DeleteConnectionTemplateResponses = {
+    /**
+     * OK
+     */
+    204: void;
+};
+export type DeleteConnectionTemplateResponse = DeleteConnectionTemplateResponses[keyof DeleteConnectionTemplateResponses];
+export type UpdateConnectionTemplateData = {
+    body?: UpdateConnectionTemplate;
+    path: {
+        organisation_id: string;
+        project_id: string;
+        template_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/projects/{project_id}/connection-templates/{template_id}';
+};
+export type UpdateConnectionTemplateErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type UpdateConnectionTemplateError = UpdateConnectionTemplateErrors[keyof UpdateConnectionTemplateErrors];
+export type UpdateConnectionTemplateResponses = {
+    /**
+     * OK
+     */
+    200: ConnectionTemplate;
+};
+export type UpdateConnectionTemplateResponse = UpdateConnectionTemplateResponses[keyof UpdateConnectionTemplateResponses];
+export type InitialiseOAuth2ConnectionData = {
+    body?: InitialiseOAuth2ConnectionRequest;
+    path: {
+        organisation_id: string;
+        system_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/systems/{system_id}/oauth2/initialise';
+};
+export type InitialiseOAuth2ConnectionErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type InitialiseOAuth2ConnectionError = InitialiseOAuth2ConnectionErrors[keyof InitialiseOAuth2ConnectionErrors];
+export type InitialiseOAuth2ConnectionResponses = {
+    /**
+     * OK
+     */
+    200: InitialiseOAuth2ConnectionResponse;
+};
+export type InitialiseOAuth2ConnectionResponse2 = InitialiseOAuth2ConnectionResponses[keyof InitialiseOAuth2ConnectionResponses];
+export type InitialiseOAuth1ConnectionData = {
+    body?: InitialiseOAuth1ConnectionRequest;
+    path: {
+        organisation_id: string;
+        system_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/systems/{system_id}/oauth1/initialise';
+};
+export type InitialiseOAuth1ConnectionErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type InitialiseOAuth1ConnectionError = InitialiseOAuth1ConnectionErrors[keyof InitialiseOAuth1ConnectionErrors];
+export type InitialiseOAuth1ConnectionResponses = {
+    /**
+     * OK
+     */
+    200: InitialiseOAuth1ConnectionResponse;
+};
+export type InitialiseOAuth1ConnectionResponse2 = InitialiseOAuth1ConnectionResponses[keyof InitialiseOAuth1ConnectionResponses];
+export type ListIssuesData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+    };
+    query?: {
+        first?: number;
+        after?: string;
+        before?: string;
+        /**
+         * Which date to use in after and before queries. If not provided, defaults to createdAt.
+         * The result will also be ordered by this date.
+         *
+         */
+        search_date?: 'createdAt' | 'lastSeenAt';
+        /**
+         * Filter issues by status. Can be one of 'open', 'closed', 'acked' or 'resolved'.
+         * If not provided, defaults to getting issues of all statuses.
+         *
+         */
+        status?: IssueStatusEnum;
+        /**
+         * Filter issues by project ID. If not provided, issues from all projects are returned.
+         * This is useful for filtering issues related to a specific project.
+         *
+         */
+        project_id?: string;
+        /**
+         * Filter issues by environment ID. If not provided, issues from all projects are returned.
+         * This is useful for filtering issues related to a specific environment.
+         *
+         */
+        environment_id?: string;
+        /**
+         * Filter issues by severity. Can be one of 'low', 'medium', or 'high'.
+         * If not provided, issues of all severities are returned.
+         *
+         */
+        severity?: IssueSeverityEnum;
+    };
+    url: '/o/{organisation_id}/issues';
+};
+export type ListIssuesErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type ListIssuesError = ListIssuesErrors[keyof ListIssuesErrors];
+export type ListIssuesResponses = {
+    /**
+     * OK
+     */
+    200: Array<Issue>;
+};
+export type ListIssuesResponse = ListIssuesResponses[keyof ListIssuesResponses];
+export type CreateIssueData = {
+    body?: CreateIssue;
+    path: {
+        organisation_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/issues';
+};
+export type CreateIssueErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type CreateIssueError = CreateIssueErrors[keyof CreateIssueErrors];
+export type CreateIssueResponses = {
+    /**
+     * Created
+     */
+    201: Issue;
+};
+export type CreateIssueResponse = CreateIssueResponses[keyof CreateIssueResponses];
+export type UpdateIssueData = {
+    body?: UpdateIssue;
+    path: {
+        organisation_id: string;
+        issue_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/issues/{issue_id}';
+};
+export type UpdateIssueErrors = {
+    /**
+     * Error
+     */
+    default: _Error;
+};
+export type UpdateIssueError = UpdateIssueErrors[keyof UpdateIssueErrors];
+export type UpdateIssueResponses = {
+    /**
+     * OK
+     */
+    200: Issue;
+};
+export type UpdateIssueResponse = UpdateIssueResponses[keyof UpdateIssueResponses];
+export type ListNotificationChannelsData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/notification_channels';
+};
+export type ListNotificationChannelsResponses = {
+    /**
+     * A list of notification channels
+     */
+    200: NotificationChannelList;
+};
+export type ListNotificationChannelsResponse = ListNotificationChannelsResponses[keyof ListNotificationChannelsResponses];
+export type CreateNotificationChannelData = {
+    body: CreateNotificationChannel;
+    path: {
+        organisation_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/notification_channels';
+};
+export type CreateNotificationChannelResponses = {
+    /**
+     * Notification channel created successfully
+     */
+    201: NotificationChannel;
+};
+export type CreateNotificationChannelResponse = CreateNotificationChannelResponses[keyof CreateNotificationChannelResponses];
+export type DeleteNotificationChannelData = {
+    body?: never;
+    path: {
+        organisation_id: string;
+        channel_id: string;
+    };
+    query?: never;
+    url: '/o/{organisation_id}/notification_channels/{channel_id}';
+};
+export type DeleteNotificationChannelResponses = {
+    /**
+     * Notification channel deleted successfully
+     */
+    204: void;
+};
+export type DeleteNotificationChannelResponse = DeleteNotificationChannelResponses[keyof DeleteNotificationChannelResponses];
+export type ListProjectNotificationsData = {
+    body?: never;
+    path: {
+        project_id: string;
+    };
+    query?: {
+        env_id?: string;
+    };
+    url: '/projects/{project_id}/notifications';
+};
+export type ListProjectNotificationsResponses = {
+    /**
+     * A list of project notifications
+     */
+    200: ProjectNotificationList;
+};
+export type ListProjectNotificationsResponse = ListProjectNotificationsResponses[keyof ListProjectNotificationsResponses];
+export type CreateProjectNotificationData = {
+    body: CreateProjectNotification;
+    path: {
+        project_id: string;
+    };
+    query?: never;
+    url: '/projects/{project_id}/notifications';
+};
+export type CreateProjectNotificationResponses = {
+    /**
+     * Project notification created successfully
+     */
+    201: ProjectNotification;
+};
+export type CreateProjectNotificationResponse = CreateProjectNotificationResponses[keyof CreateProjectNotificationResponses];
+export type DeleteProjectNotificationData = {
+    body?: never;
+    path: {
+        project_id: string;
+        notification_id: string;
+    };
+    query?: {
+        env_id?: string;
+    };
+    url: '/projects/{project_id}/notifications/{notification_id}';
+};
+export type DeleteProjectNotificationResponses = {
+    /**
+     * Project notification deleted successfully
+     */
+    204: void;
+};
+export type DeleteProjectNotificationResponse = DeleteProjectNotificationResponses[keyof DeleteProjectNotificationResponses];
+export type ClientOptions = {
+    baseUrl: 'https://platform.versori.com/api/v2' | 'https://platform-staging.versori.com/api/v2' | 'http://localhost:8901' | (string & {});
+};
+//# sourceMappingURL=types.gen.d.ts.map