@azerothian/infisical 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,3973 @@
+type AuthConfig = {
+    mode: "jwt";
+    token: string;
+} | {
+    mode: "apiKey";
+    apiKey: string;
+} | {
+    mode: "serviceToken";
+    serviceToken: string;
+} | {
+    mode: "identityAccessToken";
+    accessToken: string;
+};
+
+interface LoginResponse {
+    accessToken: string;
+    expiresIn: number;
+    accessTokenMaxTTL: number;
+    tokenType: string;
+}
+interface RenewResult {
+    auth: AuthConfig;
+    expiresIn: number;
+}
+declare class AuthState {
+    private _auth;
+    private _expiresAt;
+    private _renewFn;
+    private _renewPromise;
+    setAuth(auth: AuthConfig, expiresIn?: number): void;
+    clearAuth(): void;
+    setRenewFn(fn: () => Promise<RenewResult>): void;
+    get current(): AuthConfig | null;
+    get isAuthenticated(): boolean;
+    get mode(): AuthConfig["mode"] | null;
+    get canRenew(): boolean;
+    forceRenew(): Promise<void>;
+    ensureValid(): Promise<void>;
+    private _renew;
+}
+
+type FetchFunction = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+interface HttpClientConfig {
+    baseUrl: string;
+    authState: AuthState;
+    fetch: FetchFunction;
+    timeout: number;
+    headers?: Record<string, string>;
+}
+declare class HttpClient {
+    private readonly config;
+    constructor(config: HttpClientConfig);
+    private request;
+    get<T>(path: string, query?: Record<string, unknown>): Promise<T>;
+    post<T>(path: string, body?: unknown, query?: Record<string, unknown>): Promise<T>;
+    postNoAuth<T>(path: string, body?: unknown, query?: Record<string, unknown>): Promise<T>;
+    put<T>(path: string, body?: unknown, query?: Record<string, unknown>): Promise<T>;
+    patch<T>(path: string, body?: unknown, query?: Record<string, unknown>): Promise<T>;
+    delete<T>(path: string, body?: unknown, query?: Record<string, unknown>): Promise<T>;
+}
+
+type AuthMode = "jwt" | "apiKey" | "serviceToken" | "identityAccessToken";
+type ResourceCategory = "secrets" | "secretFolders" | "secretImports" | "projects" | "organizations" | "organizationIdentities" | "identities" | "identityAuth" | "identityAccessTokens" | "pki" | "kms" | "secretTags" | "appConnections" | "secretSyncs" | "integrationAuth" | "admin" | "orgAdmin" | "secretSharing" | "webhooks" | "users" | "mfa" | "mfaSessions" | "serviceTokens" | "password";
+declare const RESOURCE_AUTH_MODES: Record<ResourceCategory, readonly AuthMode[]>;
+
+declare abstract class BaseResource {
+    protected readonly http: HttpClient;
+    protected readonly authState: AuthState;
+    private readonly authCategory;
+    constructor(http: HttpClient, authState: AuthState, authCategory: ResourceCategory);
+    protected requireAuth(): void;
+}
+
+interface IdentityUniversalAuth {
+    id: string;
+    identityId: string;
+    clientId: string;
+    clientSecretTrustedIps: Array<{
+        ipAddress: string;
+        prefix?: number;
+    }>;
+    accessTokenTTL: number;
+    accessTokenMaxTTL: number;
+    accessTokenNumUsesLimit: number;
+    accessTokenTrustedIps: Array<{
+        ipAddress: string;
+        prefix?: number;
+    }>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface UniversalAuthClientSecret {
+    id: string;
+    identityUniversalAuthId: string;
+    isClientSecretRevoked: boolean;
+    description: string;
+    clientSecretPrefix: string;
+    clientSecretNumUses: number;
+    clientSecretNumUsesLimit: number;
+    clientSecretTTL: number;
+    createdAt: string;
+    updatedAt: string;
+}
+interface LoginUniversalAuthParams {
+    clientId: string;
+    clientSecret: string;
+}
+interface LoginUniversalAuthResponse {
+    accessToken: string;
+    expiresIn: number;
+    accessTokenMaxTTL: number;
+    tokenType: string;
+}
+interface AttachUniversalAuthParams {
+    identityId: string;
+    clientSecretTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+}
+interface AttachUniversalAuthResponse {
+    identityUniversalAuth: IdentityUniversalAuth;
+}
+interface UpdateUniversalAuthParams {
+    identityId: string;
+    clientSecretTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+}
+interface UpdateUniversalAuthResponse {
+    identityUniversalAuth: IdentityUniversalAuth;
+}
+interface GetUniversalAuthParams {
+    identityId: string;
+}
+interface GetUniversalAuthResponse {
+    identityUniversalAuth: IdentityUniversalAuth;
+}
+interface RevokeUniversalAuthParams {
+    identityId: string;
+}
+interface RevokeUniversalAuthResponse {
+    identityUniversalAuth: IdentityUniversalAuth;
+}
+interface CreateUniversalAuthClientSecretParams {
+    identityId: string;
+    description?: string;
+    numUsesLimit?: number;
+    ttl?: number;
+}
+interface CreateUniversalAuthClientSecretResponse {
+    clientSecret: string;
+    clientSecretData: UniversalAuthClientSecret;
+}
+interface ListUniversalAuthClientSecretsParams {
+    identityId: string;
+}
+interface ListUniversalAuthClientSecretsResponse {
+    clientSecretData: UniversalAuthClientSecret[];
+}
+interface GetUniversalAuthClientSecretParams {
+    identityId: string;
+    clientSecretId: string;
+}
+interface GetUniversalAuthClientSecretResponse {
+    clientSecretData: UniversalAuthClientSecret;
+}
+interface RevokeUniversalAuthClientSecretParams {
+    identityId: string;
+    clientSecretId: string;
+}
+interface RevokeUniversalAuthClientSecretResponse {
+    clientSecretData: UniversalAuthClientSecret;
+}
+
+declare class IdentityUniversalAuthResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    login(params: LoginUniversalAuthParams): Promise<LoginUniversalAuthResponse>;
+    attach(params: AttachUniversalAuthParams): Promise<AttachUniversalAuthResponse>;
+    update(params: UpdateUniversalAuthParams): Promise<UpdateUniversalAuthResponse>;
+    get(params: GetUniversalAuthParams): Promise<GetUniversalAuthResponse>;
+    revoke(params: RevokeUniversalAuthParams): Promise<RevokeUniversalAuthResponse>;
+    createClientSecret(params: CreateUniversalAuthClientSecretParams): Promise<CreateUniversalAuthClientSecretResponse>;
+    listClientSecrets(params: ListUniversalAuthClientSecretsParams): Promise<ListUniversalAuthClientSecretsResponse>;
+    getClientSecret(params: GetUniversalAuthClientSecretParams): Promise<GetUniversalAuthClientSecretResponse>;
+    revokeClientSecret(params: RevokeUniversalAuthClientSecretParams): Promise<RevokeUniversalAuthClientSecretResponse>;
+}
+
+interface IdentityTokenAuth {
+    id: string;
+    identityId: string;
+    accessTokenTTL: number;
+    accessTokenMaxTTL: number;
+    accessTokenNumUsesLimit: number;
+    accessTokenTrustedIps: Array<{
+        ipAddress: string;
+        prefix?: number;
+    }>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface IdentityTokenAuthToken {
+    id: string;
+    identityTokenAuthId: string;
+    name: string;
+    isTokenRevoked: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface LoginTokenAuthParams {
+    identityId: string;
+}
+interface LoginTokenAuthResponse {
+    accessToken: string;
+    expiresIn: number;
+    accessTokenMaxTTL: number;
+    tokenType: string;
+}
+interface AttachTokenAuthParams {
+    identityId: string;
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+}
+interface AttachTokenAuthResponse {
+    identityTokenAuth: IdentityTokenAuth;
+}
+interface UpdateTokenAuthParams {
+    identityId: string;
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+}
+interface UpdateTokenAuthResponse {
+    identityTokenAuth: IdentityTokenAuth;
+}
+interface GetTokenAuthParams {
+    identityId: string;
+}
+interface GetTokenAuthResponse {
+    identityTokenAuth: IdentityTokenAuth;
+}
+interface RevokeTokenAuthParams {
+    identityId: string;
+}
+interface RevokeTokenAuthResponse {
+    identityTokenAuth: IdentityTokenAuth;
+}
+interface CreateTokenAuthTokenParams {
+    identityId: string;
+    name?: string;
+}
+interface CreateTokenAuthTokenResponse {
+    accessToken: string;
+    tokenData: IdentityTokenAuthToken;
+}
+interface ListTokenAuthTokensParams {
+    identityId: string;
+    offset?: number;
+    limit?: number;
+}
+interface ListTokenAuthTokensResponse {
+    tokens: IdentityTokenAuthToken[];
+}
+interface GetTokenAuthTokenParams {
+    identityId: string;
+    tokenId: string;
+}
+interface GetTokenAuthTokenResponse {
+    token: IdentityTokenAuthToken;
+}
+interface UpdateTokenAuthTokenParams {
+    identityId: string;
+    tokenId: string;
+    name?: string;
+}
+interface UpdateTokenAuthTokenResponse {
+    token: IdentityTokenAuthToken;
+}
+interface RevokeTokenAuthTokenParams {
+    identityId: string;
+    tokenId: string;
+}
+interface RevokeTokenAuthTokenResponse {
+    token: IdentityTokenAuthToken;
+}
+
+declare class IdentityTokenAuthResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    login(params: LoginTokenAuthParams): Promise<LoginTokenAuthResponse>;
+    attach(params: AttachTokenAuthParams): Promise<AttachTokenAuthResponse>;
+    update(params: UpdateTokenAuthParams): Promise<UpdateTokenAuthResponse>;
+    get(params: GetTokenAuthParams): Promise<GetTokenAuthResponse>;
+    revoke(params: RevokeTokenAuthParams): Promise<RevokeTokenAuthResponse>;
+    createToken(params: CreateTokenAuthTokenParams): Promise<CreateTokenAuthTokenResponse>;
+    listTokens(params: ListTokenAuthTokensParams): Promise<ListTokenAuthTokensResponse>;
+    getToken(params: GetTokenAuthTokenParams): Promise<GetTokenAuthTokenResponse>;
+    updateToken(params: UpdateTokenAuthTokenParams): Promise<UpdateTokenAuthTokenResponse>;
+    revokeToken(params: RevokeTokenAuthTokenParams): Promise<RevokeTokenAuthTokenResponse>;
+}
+
+interface IdentityAwsAuth {
+    id: string;
+    identityId: string;
+    stsEndpoint: string;
+    allowedPrincipalArns: string;
+    allowedAccountIds: string;
+    accessTokenTTL: number;
+    accessTokenMaxTTL: number;
+    accessTokenNumUsesLimit: number;
+    accessTokenTrustedIps: Array<{
+        ipAddress: string;
+        prefix?: number;
+    }>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface LoginAwsAuthParams {
+    identityId: string;
+    iamHttpRequestMethod: string;
+    iamRequestBody: string;
+    iamRequestHeaders: string;
+}
+interface LoginAwsAuthResponse {
+    accessToken: string;
+    expiresIn: number;
+    accessTokenMaxTTL: number;
+    tokenType: string;
+}
+interface AttachAwsAuthParams {
+    identityId: string;
+    stsEndpoint?: string;
+    allowedPrincipalArns?: string;
+    allowedAccountIds?: string;
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+}
+interface AttachAwsAuthResponse {
+    identityAwsAuth: IdentityAwsAuth;
+}
+interface UpdateAwsAuthParams {
+    identityId: string;
+    stsEndpoint?: string;
+    allowedPrincipalArns?: string;
+    allowedAccountIds?: string;
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+}
+interface UpdateAwsAuthResponse {
+    identityAwsAuth: IdentityAwsAuth;
+}
+interface GetAwsAuthParams {
+    identityId: string;
+}
+interface GetAwsAuthResponse {
+    identityAwsAuth: IdentityAwsAuth;
+}
+interface RevokeAwsAuthParams {
+    identityId: string;
+}
+interface RevokeAwsAuthResponse {
+    identityAwsAuth: IdentityAwsAuth;
+}
+
+declare class IdentityAwsAuthResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    login(params: LoginAwsAuthParams): Promise<LoginAwsAuthResponse>;
+    attach(params: AttachAwsAuthParams): Promise<AttachAwsAuthResponse>;
+    update(params: UpdateAwsAuthParams): Promise<UpdateAwsAuthResponse>;
+    get(params: GetAwsAuthParams): Promise<GetAwsAuthResponse>;
+    revoke(params: RevokeAwsAuthParams): Promise<RevokeAwsAuthResponse>;
+}
+
+interface IdentityGcpAuth {
+    id: string;
+    identityId: string;
+    type: string;
+    allowedServiceAccounts: string;
+    allowedProjects: string;
+    allowedZones: string;
+    accessTokenTTL: number;
+    accessTokenMaxTTL: number;
+    accessTokenNumUsesLimit: number;
+    accessTokenTrustedIps: Array<{
+        ipAddress: string;
+        prefix?: number;
+    }>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface LoginGcpAuthParams {
+    identityId: string;
+    jwt: string;
+}
+interface LoginGcpAuthResponse {
+    accessToken: string;
+    expiresIn: number;
+    accessTokenMaxTTL: number;
+    tokenType: string;
+}
+interface AttachGcpAuthParams {
+    identityId: string;
+    type?: string;
+    allowedServiceAccounts?: string;
+    allowedProjects?: string;
+    allowedZones?: string;
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+}
+interface AttachGcpAuthResponse {
+    identityGcpAuth: IdentityGcpAuth;
+}
+interface UpdateGcpAuthParams {
+    identityId: string;
+    type?: string;
+    allowedServiceAccounts?: string;
+    allowedProjects?: string;
+    allowedZones?: string;
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+}
+interface UpdateGcpAuthResponse {
+    identityGcpAuth: IdentityGcpAuth;
+}
+interface GetGcpAuthParams {
+    identityId: string;
+}
+interface GetGcpAuthResponse {
+    identityGcpAuth: IdentityGcpAuth;
+}
+interface RevokeGcpAuthParams {
+    identityId: string;
+}
+interface RevokeGcpAuthResponse {
+    identityGcpAuth: IdentityGcpAuth;
+}
+
+declare class IdentityGcpAuthResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    login(params: LoginGcpAuthParams): Promise<LoginGcpAuthResponse>;
+    attach(params: AttachGcpAuthParams): Promise<AttachGcpAuthResponse>;
+    update(params: UpdateGcpAuthParams): Promise<UpdateGcpAuthResponse>;
+    get(params: GetGcpAuthParams): Promise<GetGcpAuthResponse>;
+    revoke(params: RevokeGcpAuthParams): Promise<RevokeGcpAuthResponse>;
+}
+
+interface IdentityAzureAuth {
+    id: string;
+    identityId: string;
+    tenantId: string;
+    resource: string;
+    allowedServicePrincipalIds: string;
+    accessTokenTTL: number;
+    accessTokenMaxTTL: number;
+    accessTokenNumUsesLimit: number;
+    accessTokenTrustedIps: Array<{
+        ipAddress: string;
+        prefix?: number;
+    }>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface LoginAzureAuthParams {
+    identityId: string;
+    jwt: string;
+}
+interface LoginAzureAuthResponse {
+    accessToken: string;
+    expiresIn: number;
+    accessTokenMaxTTL: number;
+    tokenType: string;
+}
+interface AttachAzureAuthParams {
+    identityId: string;
+    tenantId?: string;
+    resource?: string;
+    allowedServicePrincipalIds?: string;
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+}
+interface AttachAzureAuthResponse {
+    identityAzureAuth: IdentityAzureAuth;
+}
+interface UpdateAzureAuthParams {
+    identityId: string;
+    tenantId?: string;
+    resource?: string;
+    allowedServicePrincipalIds?: string;
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+}
+interface UpdateAzureAuthResponse {
+    identityAzureAuth: IdentityAzureAuth;
+}
+interface GetAzureAuthParams {
+    identityId: string;
+}
+interface GetAzureAuthResponse {
+    identityAzureAuth: IdentityAzureAuth;
+}
+interface RevokeAzureAuthParams {
+    identityId: string;
+}
+interface RevokeAzureAuthResponse {
+    identityAzureAuth: IdentityAzureAuth;
+}
+
+declare class IdentityAzureAuthResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    login(params: LoginAzureAuthParams): Promise<LoginAzureAuthResponse>;
+    attach(params: AttachAzureAuthParams): Promise<AttachAzureAuthResponse>;
+    update(params: UpdateAzureAuthParams): Promise<UpdateAzureAuthResponse>;
+    get(params: GetAzureAuthParams): Promise<GetAzureAuthResponse>;
+    revoke(params: RevokeAzureAuthParams): Promise<RevokeAzureAuthResponse>;
+}
+
+interface IdentityKubernetesAuth {
+    id: string;
+    identityId: string;
+    kubernetesHost: string;
+    caCert: string;
+    tokenReviewerJwt: string;
+    allowedNamespaces: string;
+    allowedNames: string;
+    allowedAudience: string;
+    accessTokenTTL: number;
+    accessTokenMaxTTL: number;
+    accessTokenNumUsesLimit: number;
+    accessTokenTrustedIps: Array<{
+        ipAddress: string;
+        prefix?: number;
+    }>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface LoginKubernetesAuthParams {
+    identityId: string;
+    jwt: string;
+}
+interface LoginKubernetesAuthResponse {
+    accessToken: string;
+    expiresIn: number;
+    accessTokenMaxTTL: number;
+    tokenType: string;
+}
+interface AttachKubernetesAuthParams {
+    identityId: string;
+    kubernetesHost?: string;
+    caCert?: string;
+    tokenReviewerJwt?: string;
+    allowedNamespaces?: string;
+    allowedNames?: string;
+    allowedAudience?: string;
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+}
+interface AttachKubernetesAuthResponse {
+    identityKubernetesAuth: IdentityKubernetesAuth;
+}
+interface UpdateKubernetesAuthParams {
+    identityId: string;
+    kubernetesHost?: string;
+    caCert?: string;
+    tokenReviewerJwt?: string;
+    allowedNamespaces?: string;
+    allowedNames?: string;
+    allowedAudience?: string;
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+}
+interface UpdateKubernetesAuthResponse {
+    identityKubernetesAuth: IdentityKubernetesAuth;
+}
+interface GetKubernetesAuthParams {
+    identityId: string;
+}
+interface GetKubernetesAuthResponse {
+    identityKubernetesAuth: IdentityKubernetesAuth;
+}
+interface RevokeKubernetesAuthParams {
+    identityId: string;
+}
+interface RevokeKubernetesAuthResponse {
+    identityKubernetesAuth: IdentityKubernetesAuth;
+}
+
+declare class IdentityKubernetesAuthResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    login(params: LoginKubernetesAuthParams): Promise<LoginKubernetesAuthResponse>;
+    attach(params: AttachKubernetesAuthParams): Promise<AttachKubernetesAuthResponse>;
+    update(params: UpdateKubernetesAuthParams): Promise<UpdateKubernetesAuthResponse>;
+    get(params: GetKubernetesAuthParams): Promise<GetKubernetesAuthResponse>;
+    revoke(params: RevokeKubernetesAuthParams): Promise<RevokeKubernetesAuthResponse>;
+}
+
+interface IdentityOidcAuth {
+    id: string;
+    identityId: string;
+    oidcDiscoveryUrl: string;
+    caCert: string;
+    boundIssuer: string;
+    boundAudiences: string;
+    boundClaims: Record<string, string>;
+    boundSubject: string;
+    accessTokenTTL: number;
+    accessTokenMaxTTL: number;
+    accessTokenNumUsesLimit: number;
+    accessTokenTrustedIps: Array<{
+        ipAddress: string;
+        prefix?: number;
+    }>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface LoginOidcAuthParams {
+    identityId: string;
+    jwt: string;
+}
+interface LoginOidcAuthResponse {
+    accessToken: string;
+    expiresIn: number;
+    accessTokenMaxTTL: number;
+    tokenType: string;
+}
+interface AttachOidcAuthParams {
+    identityId: string;
+    oidcDiscoveryUrl?: string;
+    caCert?: string;
+    boundIssuer?: string;
+    boundAudiences?: string;
+    boundClaims?: Record<string, string>;
+    boundSubject?: string;
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+}
+interface AttachOidcAuthResponse {
+    identityOidcAuth: IdentityOidcAuth;
+}
+interface UpdateOidcAuthParams {
+    identityId: string;
+    oidcDiscoveryUrl?: string;
+    caCert?: string;
+    boundIssuer?: string;
+    boundAudiences?: string;
+    boundClaims?: Record<string, string>;
+    boundSubject?: string;
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+}
+interface UpdateOidcAuthResponse {
+    identityOidcAuth: IdentityOidcAuth;
+}
+interface GetOidcAuthParams {
+    identityId: string;
+}
+interface GetOidcAuthResponse {
+    identityOidcAuth: IdentityOidcAuth;
+}
+interface RevokeOidcAuthParams {
+    identityId: string;
+}
+interface RevokeOidcAuthResponse {
+    identityOidcAuth: IdentityOidcAuth;
+}
+
+declare class IdentityOidcAuthResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    login(params: LoginOidcAuthParams): Promise<LoginOidcAuthResponse>;
+    attach(params: AttachOidcAuthParams): Promise<AttachOidcAuthResponse>;
+    update(params: UpdateOidcAuthParams): Promise<UpdateOidcAuthResponse>;
+    get(params: GetOidcAuthParams): Promise<GetOidcAuthResponse>;
+    revoke(params: RevokeOidcAuthParams): Promise<RevokeOidcAuthResponse>;
+}
+
+interface IdentityJwtAuth {
+    id: string;
+    identityId: string;
+    configurationType: string;
+    jwksUrl: string;
+    jwksCaCert: string;
+    publicKeys: string[];
+    boundIssuer: string;
+    boundAudiences: string;
+    boundClaims: Record<string, string>;
+    boundSubject: string;
+    accessTokenTTL: number;
+    accessTokenMaxTTL: number;
+    accessTokenNumUsesLimit: number;
+    accessTokenTrustedIps: Array<{
+        ipAddress: string;
+        prefix?: number;
+    }>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface LoginJwtAuthParams {
+    identityId: string;
+    jwt: string;
+}
+interface LoginJwtAuthResponse {
+    accessToken: string;
+    expiresIn: number;
+    accessTokenMaxTTL: number;
+    tokenType: string;
+}
+interface AttachJwtAuthParams {
+    identityId: string;
+    configurationType?: string;
+    jwksUrl?: string;
+    jwksCaCert?: string;
+    publicKeys?: string[];
+    boundIssuer?: string;
+    boundAudiences?: string;
+    boundClaims?: Record<string, string>;
+    boundSubject?: string;
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+}
+interface AttachJwtAuthResponse {
+    identityJwtAuth: IdentityJwtAuth;
+}
+interface UpdateJwtAuthParams {
+    identityId: string;
+    configurationType?: string;
+    jwksUrl?: string;
+    jwksCaCert?: string;
+    publicKeys?: string[];
+    boundIssuer?: string;
+    boundAudiences?: string;
+    boundClaims?: Record<string, string>;
+    boundSubject?: string;
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+}
+interface UpdateJwtAuthResponse {
+    identityJwtAuth: IdentityJwtAuth;
+}
+interface GetJwtAuthParams {
+    identityId: string;
+}
+interface GetJwtAuthResponse {
+    identityJwtAuth: IdentityJwtAuth;
+}
+interface RevokeJwtAuthParams {
+    identityId: string;
+}
+interface RevokeJwtAuthResponse {
+    identityJwtAuth: IdentityJwtAuth;
+}
+
+declare class IdentityJwtAuthResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    login(params: LoginJwtAuthParams): Promise<LoginJwtAuthResponse>;
+    attach(params: AttachJwtAuthParams): Promise<AttachJwtAuthResponse>;
+    update(params: UpdateJwtAuthParams): Promise<UpdateJwtAuthResponse>;
+    get(params: GetJwtAuthParams): Promise<GetJwtAuthResponse>;
+    revoke(params: RevokeJwtAuthParams): Promise<RevokeJwtAuthResponse>;
+}
+
+interface IdentityLdapAuth {
+    id: string;
+    identityId: string;
+    ldapConfigId: string;
+    allowedGroups: string;
+    allowedGroupsDN: string;
+    accessTokenTTL: number;
+    accessTokenMaxTTL: number;
+    accessTokenNumUsesLimit: number;
+    accessTokenTrustedIps: Array<{
+        ipAddress: string;
+        prefix?: number;
+    }>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface LoginLdapAuthParams {
+    identityId: string;
+    username: string;
+    password: string;
+    ldapConfigId?: string;
+}
+interface LoginLdapAuthResponse {
+    accessToken: string;
+    expiresIn: number;
+    accessTokenMaxTTL: number;
+    tokenType: string;
+}
+interface AttachLdapAuthParams {
+    identityId: string;
+    ldapConfigId?: string;
+    allowedGroups?: string;
+    allowedGroupsDN?: string;
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+}
+interface AttachLdapAuthResponse {
+    identityLdapAuth: IdentityLdapAuth;
+}
+interface UpdateLdapAuthParams {
+    identityId: string;
+    ldapConfigId?: string;
+    allowedGroups?: string;
+    allowedGroupsDN?: string;
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+}
+interface UpdateLdapAuthResponse {
+    identityLdapAuth: IdentityLdapAuth;
+}
+interface GetLdapAuthParams {
+    identityId: string;
+}
+interface GetLdapAuthResponse {
+    identityLdapAuth: IdentityLdapAuth;
+}
+interface RevokeLdapAuthParams {
+    identityId: string;
+}
+interface RevokeLdapAuthResponse {
+    identityLdapAuth: IdentityLdapAuth;
+}
+
+declare class IdentityLdapAuthResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    login(params: LoginLdapAuthParams): Promise<LoginLdapAuthResponse>;
+    attach(params: AttachLdapAuthParams): Promise<AttachLdapAuthResponse>;
+    update(params: UpdateLdapAuthParams): Promise<UpdateLdapAuthResponse>;
+    get(params: GetLdapAuthParams): Promise<GetLdapAuthResponse>;
+    revoke(params: RevokeLdapAuthParams): Promise<RevokeLdapAuthResponse>;
+}
+
+interface IdentityTlsCertAuth {
+    id: string;
+    identityId: string;
+    caCert: string;
+    allowedCommonNames: string;
+    allowedOrganizations: string;
+    accessTokenTTL: number;
+    accessTokenMaxTTL: number;
+    accessTokenNumUsesLimit: number;
+    accessTokenTrustedIps: Array<{
+        ipAddress: string;
+        prefix?: number;
+    }>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface LoginTlsCertAuthParams {
+    identityId: string;
+    clientCertificate: string;
+}
+interface LoginTlsCertAuthResponse {
+    accessToken: string;
+    expiresIn: number;
+    accessTokenMaxTTL: number;
+    tokenType: string;
+}
+interface AttachTlsCertAuthParams {
+    identityId: string;
+    caCert?: string;
+    allowedCommonNames?: string;
+    allowedOrganizations?: string;
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+}
+interface AttachTlsCertAuthResponse {
+    identityTlsCertAuth: IdentityTlsCertAuth;
+}
+interface UpdateTlsCertAuthParams {
+    identityId: string;
+    caCert?: string;
+    allowedCommonNames?: string;
+    allowedOrganizations?: string;
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+}
+interface UpdateTlsCertAuthResponse {
+    identityTlsCertAuth: IdentityTlsCertAuth;
+}
+interface GetTlsCertAuthParams {
+    identityId: string;
+}
+interface GetTlsCertAuthResponse {
+    identityTlsCertAuth: IdentityTlsCertAuth;
+}
+interface RevokeTlsCertAuthParams {
+    identityId: string;
+}
+interface RevokeTlsCertAuthResponse {
+    identityTlsCertAuth: IdentityTlsCertAuth;
+}
+
+declare class IdentityTlsCertAuthResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    login(params: LoginTlsCertAuthParams): Promise<LoginTlsCertAuthResponse>;
+    attach(params: AttachTlsCertAuthParams): Promise<AttachTlsCertAuthResponse>;
+    update(params: UpdateTlsCertAuthParams): Promise<UpdateTlsCertAuthResponse>;
+    get(params: GetTlsCertAuthParams): Promise<GetTlsCertAuthResponse>;
+    revoke(params: RevokeTlsCertAuthParams): Promise<RevokeTlsCertAuthResponse>;
+}
+
+interface IdentityOciAuth {
+    id: string;
+    identityId: string;
+    tenancyOcid: string;
+    allowedUserOcids: string;
+    allowedCompartmentOcids: string;
+    accessTokenTTL: number;
+    accessTokenMaxTTL: number;
+    accessTokenNumUsesLimit: number;
+    accessTokenTrustedIps: Array<{
+        ipAddress: string;
+        prefix?: number;
+    }>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface LoginOciAuthParams {
+    identityId: string;
+    userOcid: string;
+    requestHeaders: string;
+}
+interface LoginOciAuthResponse {
+    accessToken: string;
+    expiresIn: number;
+    accessTokenMaxTTL: number;
+    tokenType: string;
+}
+interface AttachOciAuthParams {
+    identityId: string;
+    tenancyOcid?: string;
+    allowedUserOcids?: string;
+    allowedCompartmentOcids?: string;
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+}
+interface AttachOciAuthResponse {
+    identityOciAuth: IdentityOciAuth;
+}
+interface UpdateOciAuthParams {
+    identityId: string;
+    tenancyOcid?: string;
+    allowedUserOcids?: string;
+    allowedCompartmentOcids?: string;
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+}
+interface UpdateOciAuthResponse {
+    identityOciAuth: IdentityOciAuth;
+}
+interface GetOciAuthParams {
+    identityId: string;
+}
+interface GetOciAuthResponse {
+    identityOciAuth: IdentityOciAuth;
+}
+interface RevokeOciAuthParams {
+    identityId: string;
+}
+interface RevokeOciAuthResponse {
+    identityOciAuth: IdentityOciAuth;
+}
+
+declare class IdentityOciAuthResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    login(params: LoginOciAuthParams): Promise<LoginOciAuthResponse>;
+    attach(params: AttachOciAuthParams): Promise<AttachOciAuthResponse>;
+    update(params: UpdateOciAuthParams): Promise<UpdateOciAuthResponse>;
+    get(params: GetOciAuthParams): Promise<GetOciAuthResponse>;
+    revoke(params: RevokeOciAuthParams): Promise<RevokeOciAuthResponse>;
+}
+
+interface IdentityAlicloudAuth {
+    id: string;
+    identityId: string;
+    allowedArns: string;
+    allowedAccountIds: string;
+    accessTokenTTL: number;
+    accessTokenMaxTTL: number;
+    accessTokenNumUsesLimit: number;
+    accessTokenTrustedIps: Array<{
+        ipAddress: string;
+        prefix?: number;
+    }>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface LoginAlicloudAuthParams {
+    identityId: string;
+    stsToken: string;
+    identityArn: string;
+}
+interface LoginAlicloudAuthResponse {
+    accessToken: string;
+    expiresIn: number;
+    accessTokenMaxTTL: number;
+    tokenType: string;
+}
+interface AttachAlicloudAuthParams {
+    identityId: string;
+    allowedArns?: string;
+    allowedAccountIds?: string;
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+}
+interface AttachAlicloudAuthResponse {
+    identityAlicloudAuth: IdentityAlicloudAuth;
+}
+interface UpdateAlicloudAuthParams {
+    identityId: string;
+    allowedArns?: string;
+    allowedAccountIds?: string;
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: Array<{
+        ipAddress: string;
+    }>;
+}
+interface UpdateAlicloudAuthResponse {
+    identityAlicloudAuth: IdentityAlicloudAuth;
+}
+interface GetAlicloudAuthParams {
+    identityId: string;
+}
+interface GetAlicloudAuthResponse {
+    identityAlicloudAuth: IdentityAlicloudAuth;
+}
+interface RevokeAlicloudAuthParams {
+    identityId: string;
+}
+interface RevokeAlicloudAuthResponse {
+    identityAlicloudAuth: IdentityAlicloudAuth;
+}
+
+declare class IdentityAlicloudAuthResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    login(params: LoginAlicloudAuthParams): Promise<LoginAlicloudAuthResponse>;
+    attach(params: AttachAlicloudAuthParams): Promise<AttachAlicloudAuthResponse>;
+    update(params: UpdateAlicloudAuthParams): Promise<UpdateAlicloudAuthResponse>;
+    get(params: GetAlicloudAuthParams): Promise<GetAlicloudAuthResponse>;
+    revoke(params: RevokeAlicloudAuthParams): Promise<RevokeAlicloudAuthResponse>;
+}
+
+type LoginParams = {
+    universalAuth: LoginUniversalAuthParams;
+} | {
+    tokenAuth: LoginTokenAuthParams;
+} | {
+    awsAuth: LoginAwsAuthParams;
+} | {
+    gcpAuth: LoginGcpAuthParams;
+} | {
+    azureAuth: LoginAzureAuthParams;
+} | {
+    kubernetesAuth: LoginKubernetesAuthParams;
+} | {
+    oidcAuth: LoginOidcAuthParams;
+} | {
+    jwtAuth: LoginJwtAuthParams;
+} | {
+    ldapAuth: LoginLdapAuthParams;
+} | {
+    tlsCertAuth: LoginTlsCertAuthParams;
+} | {
+    ociAuth: LoginOciAuthParams;
+} | {
+    alicloudAuth: LoginAlicloudAuthParams;
+};
+type LoginParamsOrFactory = LoginParams | (() => Promise<LoginParams> | LoginParams);
+interface IdentityAuthResources {
+    universal: IdentityUniversalAuthResource;
+    token: IdentityTokenAuthResource;
+    aws: IdentityAwsAuthResource;
+    gcp: IdentityGcpAuthResource;
+    azure: IdentityAzureAuthResource;
+    kubernetes: IdentityKubernetesAuthResource;
+    oidc: IdentityOidcAuthResource;
+    jwt: IdentityJwtAuthResource;
+    ldap: IdentityLdapAuthResource;
+    tlsCert: IdentityTlsCertAuthResource;
+    oci: IdentityOciAuthResource;
+    alicloud: IdentityAlicloudAuthResource;
+}
+declare class AuthManager {
+    private readonly authState;
+    private readonly resources;
+    constructor(authState: AuthState, resources: IdentityAuthResources);
+    login(params: LoginParams | (() => Promise<LoginParams> | LoginParams)): Promise<LoginResponse>;
+    private resolveLoginFn;
+}
+
+declare enum AuthMethod {
+    EMAIL = "email",
+    GOOGLE = "google",
+    GITHUB = "github",
+    GITLAB = "gitlab"
+}
+declare enum MfaMethod {
+    EMAIL = "email",
+    TOTP = "totp",
+    WEBAUTHN = "webauthn"
+}
+declare enum OrgMembershipStatus {
+    Accepted = "accepted",
+    Invited = "invited"
+}
+declare enum OrgIdentityOrderBy {
+    Name = "name"
+}
+declare enum OrderByDirection {
+    ASC = "asc",
+    DESC = "desc"
+}
+declare enum MfaSessionStatus {
+    PENDING = "pending",
+    VERIFIED = "verified",
+    EXPIRED = "expired"
+}
+declare enum PkiAlertEventType {
+    EXPIRING = "expiring"
+}
+declare enum PkiAlertChannelType {
+    EMAIL = "email",
+    WEBHOOK = "webhook",
+    SLACK = "slack",
+    PAGERDUTY = "pagerduty"
+}
+declare enum CertKeyUsage {
+    DIGITAL_SIGNATURE = "digitalSignature",
+    KEY_ENCIPHERMENT = "keyEncipherment",
+    DATA_ENCIPHERMENT = "dataEncipherment",
+    KEY_AGREEMENT = "keyAgreement",
+    KEY_CERT_SIGN = "keyCertSign",
+    CRL_SIGN = "cRLSign",
+    NON_REPUDIATION = "nonRepudiation",
+    ENCIPHER_ONLY = "encipherOnly",
+    DECIPHER_ONLY = "decipherOnly"
+}
+declare enum CertExtendedKeyUsage {
+    SERVER_AUTH = "serverAuth",
+    CLIENT_AUTH = "clientAuth",
+    CODE_SIGNING = "codeSigning",
+    EMAIL_PROTECTION = "emailProtection",
+    TIME_STAMPING = "timeStamping",
+    OCSP_SIGNING = "ocspSigning"
+}
+declare enum CaType {
+    INTERNAL = "internal",
+    ACME = "acme",
+    AZURE_AD_CS = "azure-ad-cs"
+}
+declare enum JwtSignatureAlgorithm {
+    RS256 = "RS256",
+    RS384 = "RS384",
+    RS512 = "RS512",
+    ES256 = "ES256",
+    ES384 = "ES384",
+    ES512 = "ES512",
+    PS256 = "PS256",
+    PS384 = "PS384",
+    PS512 = "PS512",
+    EdDSA = "EdDSA"
+}
+
+interface ResendMfaTokenResponse {
+    message: string;
+}
+interface CheckTotpResponse {
+    isVerified: boolean;
+}
+interface CheckWebAuthnResponse {
+    hasPasskeys: boolean;
+}
+interface VerifyMfaParams {
+    mfaToken: string;
+    mfaMethod?: MfaMethod;
+}
+interface VerifyMfaResponse {
+    encryptionVersion?: number | null;
+    protectedKey?: string | null;
+    protectedKeyIV?: string | null;
+    protectedKeyTag?: string | null;
+    publicKey?: string | null;
+    encryptedPrivateKey?: string | null;
+    iv?: string | null;
+    tag?: string | null;
+    token: string;
+}
+interface VerifyMfaRecoveryCodeParams {
+    recoveryCode: string;
+}
+
+declare class MfaResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    resendToken(): Promise<ResendMfaTokenResponse>;
+    checkTotp(): Promise<CheckTotpResponse>;
+    checkWebAuthn(): Promise<CheckWebAuthnResponse>;
+    verify(params: VerifyMfaParams): Promise<VerifyMfaResponse>;
+    verifyRecoveryCode(params: VerifyMfaRecoveryCodeParams): Promise<VerifyMfaResponse>;
+}
+
+interface VerifyMfaSessionParams {
+    mfaSessionId: string;
+    mfaToken: string;
+    mfaMethod: MfaMethod;
+}
+interface VerifyMfaSessionResponse {
+    success: boolean;
+    message: string;
+}
+interface GetMfaSessionStatusParams {
+    mfaSessionId: string;
+}
+interface GetMfaSessionStatusResponse {
+    status: MfaSessionStatus;
+    mfaMethod: MfaMethod;
+}
+
+declare class MfaSessionsResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    verify(params: VerifyMfaSessionParams): Promise<VerifyMfaSessionResponse>;
+    getStatus(params: GetMfaSessionStatusParams): Promise<GetMfaSessionStatusResponse>;
+}
+
+interface User {
+    id: string;
+    email?: string | null;
+    username: string;
+    firstName?: string | null;
+    lastName?: string | null;
+    isEmailVerified?: boolean | null;
+    authMethods?: string[] | null;
+    isMfaEnabled: boolean;
+    mfaMethods?: string[] | null;
+    selectedMfaMethod?: string | null;
+    devices?: unknown;
+    createdAt: string;
+    updatedAt: string;
+    isGhost: boolean;
+    isLocked?: boolean;
+    consecutiveFailedMfaAttempts?: number;
+    isAccepted?: boolean;
+}
+interface UserWithEncryptionKeys extends User {
+    clientPublicKey?: string | null;
+    serverPrivateKey?: string | null;
+    encryptionVersion?: number | null;
+    protectedKey?: string | null;
+    protectedKeyIV?: string | null;
+    protectedKeyTag?: string | null;
+    publicKey?: string | null;
+    encryptedPrivateKey?: string | null;
+    iv?: string | null;
+    tag?: string | null;
+    salt?: string | null;
+    verifier?: string | null;
+    userId?: string | null;
+}
+interface Organization {
+    id: string;
+    name: string;
+    slug: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface ApiKey {
+    id: string;
+    name: string;
+    userId: string;
+    lastUsed?: string | null;
+    expiresAt?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface AuthTokenSession {
+    id: string;
+    userId: string;
+    ip?: string | null;
+    userAgent?: string | null;
+    accessVersion: number;
+    refreshVersion: number;
+    lastUsed: string;
+    createdAt: string;
+    updatedAt: string;
+    orgId?: string | null;
+}
+interface SendEmailVerificationCodeParams {
+    token: string;
+}
+interface VerifyEmailVerificationCodeParams {
+    username: string;
+    code: string;
+}
+interface UpdateMfaParams {
+    isMfaEnabled?: boolean;
+    selectedMfaMethod?: MfaMethod;
+}
+interface UpdateMfaResponse {
+    user: User;
+}
+interface UpdateNameParams {
+    firstName: string;
+    lastName: string;
+}
+interface UpdateNameResponse {
+    user: User;
+}
+interface UpdateAuthMethodsParams {
+    authMethods: AuthMethod[];
+}
+interface UpdateAuthMethodsResponse {
+    user: User;
+}
+interface RequestEmailChangeOtpParams {
+    newEmail: string;
+}
+interface RequestEmailChangeOtpResponse {
+    success: boolean;
+    message: string;
+}
+interface UpdateEmailParams {
+    newEmail: string;
+    otpCode: string;
+}
+interface UpdateEmailResponse {
+    user: User;
+}
+interface ListOrganizationsResponse {
+    organizations: Organization[];
+}
+interface CreateApiKeyParams {
+    name: string;
+    expiresIn: number;
+}
+interface CreateApiKeyResponse {
+    apiKey: string;
+    apiKeyData: ApiKey;
+}
+interface DeleteApiKeyResponse {
+    apiKeyData: ApiKey;
+}
+interface RevokeAllSessionsResponse {
+    message: string;
+}
+interface RevokeSessionResponse {
+    message: string;
+}
+interface GetMeResponse {
+    user: UserWithEncryptionKeys;
+}
+interface DeleteMeResponse {
+    user: User;
+}
+
+declare class UsersResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    sendEmailVerificationCode(params: SendEmailVerificationCodeParams): Promise<void>;
+    verifyEmailVerificationCode(params: VerifyEmailVerificationCodeParams): Promise<void>;
+    updateMfa(params: UpdateMfaParams): Promise<UpdateMfaResponse>;
+    updateName(params: UpdateNameParams): Promise<UpdateNameResponse>;
+    updateAuthMethods(params: UpdateAuthMethodsParams): Promise<UpdateAuthMethodsResponse>;
+    requestEmailChangeOtp(params: RequestEmailChangeOtpParams): Promise<RequestEmailChangeOtpResponse>;
+    updateEmail(params: UpdateEmailParams): Promise<UpdateEmailResponse>;
+    listOrganizations(): Promise<ListOrganizationsResponse>;
+    listApiKeys(): Promise<ApiKey[]>;
+    createApiKey(params: CreateApiKeyParams): Promise<CreateApiKeyResponse>;
+    deleteApiKey(apiKeyDataId: string): Promise<DeleteApiKeyResponse>;
+    listSessions(): Promise<AuthTokenSession[]>;
+    revokeAllSessions(): Promise<RevokeAllSessionsResponse>;
+    revokeSession(sessionId: string): Promise<RevokeSessionResponse>;
+    getMe(): Promise<GetMeResponse>;
+    deleteMe(): Promise<DeleteMeResponse>;
+}
+
+interface ResetPasswordParams {
+    newPassword: string;
+}
+interface ResetPasswordAuthenticatedParams {
+    oldPassword: string;
+    newPassword: string;
+}
+
+declare class PasswordResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    reset(params: ResetPasswordParams): Promise<void>;
+    resetAuthenticated(params: ResetPasswordAuthenticatedParams): Promise<void>;
+}
+
+interface ServiceToken {
+    id: string;
+    name: string;
+    projectId: string;
+    userId?: string | null;
+    scopes: Array<{
+        environment: string;
+        secretPath: string;
+    }>;
+    lastUsed?: string | null;
+    expiresAt?: string | null;
+    encryptedKey: string;
+    iv: string;
+    tag: string;
+    secretHash: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SanitizedServiceToken {
+    id: string;
+    name: string;
+    projectId: string;
+    userId?: string | null;
+    scopes: Array<{
+        environment: string;
+        secretPath: string;
+    }>;
+    lastUsed?: string | null;
+    expiresAt?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface GetServiceTokenResponse extends ServiceToken {
+    workspace: string;
+    user: {
+        id: string;
+        username: string;
+        email?: string | null;
+        firstName?: string | null;
+        lastName?: string | null;
+        _id: string;
+        __v: number;
+    };
+    _id: string;
+    __v: number;
+}
+interface CreateServiceTokenParams {
+    name: string;
+    workspaceId: string;
+    scopes: Array<{
+        environment: string;
+        secretPath: string;
+    }>;
+    encryptedKey: string;
+    iv: string;
+    tag: string;
+    expiresIn: number | null;
+    permissions: Array<"read" | "write">;
+}
+interface CreateServiceTokenResponse {
+    serviceToken: string;
+    serviceTokenData: SanitizedServiceToken;
+}
+interface DeleteServiceTokenResponse {
+    serviceTokenData: SanitizedServiceToken;
+}
+
+declare class ServiceTokensResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    get(): Promise<GetServiceTokenResponse>;
+    create(params: CreateServiceTokenParams): Promise<CreateServiceTokenResponse>;
+    delete(serviceTokenId: string): Promise<DeleteServiceTokenResponse>;
+}
+
+interface OrgMembership {
+    id: string;
+    orgId: string;
+    userId: string;
+    role: string;
+    roleId?: string | null;
+    status: OrgMembershipStatus;
+    isActive: boolean;
+    inviteEmail?: string | null;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface OrgMembershipUser {
+    id: string;
+    username: string;
+    email?: string | null;
+    isEmailVerified?: boolean | null;
+    firstName?: string | null;
+    lastName?: string | null;
+    publicKey?: string | null;
+}
+interface OrgMembershipWithUser extends Omit<OrgMembership, "createdAt" | "updatedAt"> {
+    user: OrgMembershipUser;
+}
+interface OrgProject {
+    id: string;
+    name: string;
+    slug: string;
+    organization: string;
+    environments: Array<{
+        name: string;
+        slug: string;
+    }>;
+}
+interface OrgMembershipMetadata {
+    key: string;
+    id: string;
+    value: string;
+}
+interface DetailedOrgMembership extends Omit<OrgMembership, "createdAt" | "updatedAt"> {
+    customRoleSlug?: string | null;
+    metadata?: OrgMembershipMetadata[];
+    user: OrgMembershipUser & {
+        publicKey?: string | null;
+    };
+}
+interface ProjectMembershipRole {
+    id: string;
+    role: string;
+    customRoleId?: string | null;
+    customRoleName?: string | null;
+    customRoleSlug?: string | null;
+    isTemporary: boolean;
+    temporaryMode?: string | null;
+    temporaryRange?: string | null;
+    temporaryAccessStartTime?: string | null;
+    temporaryAccessEndTime?: string | null;
+}
+interface ProjectMembership {
+    id: string;
+    projectId: string;
+    userId: string;
+    user: {
+        id: string;
+        email?: string | null;
+        username: string;
+        firstName?: string | null;
+        lastName?: string | null;
+        publicKey?: string | null;
+    };
+    project: {
+        name: string;
+        id: string;
+        type: string;
+    };
+    roles: ProjectMembershipRole[];
+}
+interface OrgInfo {
+    id: string;
+    name: string;
+    slug: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface ListMembershipsParams {
+    orgId: string;
+}
+interface ListMembershipsResponse {
+    users: OrgMembershipWithUser[];
+}
+interface ListOrgProjectsParams {
+    orgId: string;
+}
+interface ListOrgProjectsResponse {
+    workspaces: OrgProject[];
+}
+interface GetMembershipParams {
+    orgId: string;
+    membershipId: string;
+}
+interface GetMembershipResponse {
+    membership: DetailedOrgMembership;
+}
+interface UpdateMembershipParams {
+    orgId: string;
+    membershipId: string;
+    role?: string;
+    isActive?: boolean;
+    metadata?: Array<{
+        key: string;
+        value: string;
+    }>;
+}
+interface UpdateMembershipResponse {
+    membership: OrgMembership;
+}
+interface DeleteMembershipParams {
+    orgId: string;
+    membershipId: string;
+}
+interface DeleteMembershipResponse {
+    membership: OrgMembership;
+}
+interface BulkDeleteMembershipsParams {
+    orgId: string;
+    membershipIds: string[];
+}
+interface BulkDeleteMembershipsResponse {
+    memberships: OrgMembership[];
+}
+interface ListProjectMembershipsByOrgMembershipParams {
+    orgId: string;
+    membershipId: string;
+}
+interface ListProjectMembershipsByOrgMembershipResponse {
+    memberships: ProjectMembership[];
+}
+interface CreateOrganizationParams {
+    name: string;
+}
+interface CreateOrganizationResponse {
+    organization: OrgInfo;
+}
+interface DeleteOrganizationParams {
+    orgId: string;
+}
+interface DeleteOrganizationResponse {
+    organization: OrgInfo;
+    accessToken: string;
+}
+interface UpgradePrivilegeSystemResponse {
+    organization: OrgInfo;
+}
+
+declare class OrganizationsResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    list(): Promise<ListOrganizationsResponse>;
+    listMemberships(params: ListMembershipsParams): Promise<ListMembershipsResponse>;
+    listProjects(params: ListOrgProjectsParams): Promise<ListOrgProjectsResponse>;
+    getMembership(params: GetMembershipParams): Promise<GetMembershipResponse>;
+    updateMembership(params: UpdateMembershipParams): Promise<UpdateMembershipResponse>;
+    deleteMembership(params: DeleteMembershipParams): Promise<DeleteMembershipResponse>;
+    bulkDeleteMemberships(params: BulkDeleteMembershipsParams): Promise<BulkDeleteMembershipsResponse>;
+    listProjectMembershipsByOrgMembership(params: ListProjectMembershipsByOrgMembershipParams): Promise<ListProjectMembershipsByOrgMembershipResponse>;
+    create(params: CreateOrganizationParams): Promise<CreateOrganizationResponse>;
+    delete(params: DeleteOrganizationParams): Promise<DeleteOrganizationResponse>;
+    upgradePrivilegeSystem(): Promise<UpgradePrivilegeSystemResponse>;
+}
+
+interface IdentityOrgMembership {
+    id: string;
+    identityId: string;
+    orgId: string;
+    role: string;
+    roleId?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    customRole?: {
+        id: string;
+        name: string;
+        slug: string;
+        permissions: unknown;
+        description?: string | null;
+    };
+    identity: {
+        id: string;
+        name: string;
+        orgId: string;
+        authMethods: string[];
+    };
+}
+interface ListIdentityMembershipsParams {
+    orgId: string;
+    offset?: number;
+    limit?: number;
+    orderBy?: OrgIdentityOrderBy;
+    orderDirection?: OrderByDirection;
+    search?: string;
+}
+interface ListIdentityMembershipsResponse {
+    identityMemberships: IdentityOrgMembership[];
+    totalCount: number;
+}
+
+declare class OrganizationIdentitiesResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    list(params: ListIdentityMembershipsParams): Promise<ListIdentityMembershipsResponse>;
+}
+
+interface SecretFolder {
+    id: string;
+    name: string;
+    envId: string;
+    parentId?: string | null;
+    isReserved?: boolean;
+    description?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SecretFolderWithPath extends SecretFolder {
+    path: string;
+}
+interface CreateSecretFolderParams {
+    projectId: string;
+    environment: string;
+    name: string;
+    path?: string;
+    description?: string | null;
+}
+interface CreateSecretFolderResponse {
+    folder: SecretFolderWithPath;
+}
+interface UpdateSecretFolderParams {
+    folderId: string;
+    projectId: string;
+    environment: string;
+    name: string;
+    path?: string;
+    description?: string | null;
+}
+interface UpdateSecretFolderResponse {
+    folder: SecretFolderWithPath;
+}
+interface UpdateSecretFolderBatchItem {
+    id: string;
+    environment: string;
+    name: string;
+    path?: string;
+    description?: string | null;
+}
+interface UpdateSecretFolderBatchParams {
+    projectId: string;
+    folders: UpdateSecretFolderBatchItem[];
+}
+interface UpdateSecretFolderBatchResponse {
+    folders: SecretFolder[];
+}
+interface DeleteSecretFolderParams {
+    folderIdOrName: string;
+    projectId: string;
+    environment: string;
+    path?: string;
+    forceDelete?: boolean;
+}
+interface DeleteSecretFolderResponse {
+    folder: SecretFolder;
+}
+interface ListSecretFoldersParams {
+    projectId: string;
+    environment: string;
+    path?: string;
+    recursive?: boolean;
+    lastSecretModified?: string;
+}
+interface SecretFolderWithRelativePath extends SecretFolder {
+    relativePath?: string;
+}
+interface ListSecretFoldersResponse {
+    folders: SecretFolderWithRelativePath[];
+}
+interface GetSecretFolderByIdParams {
+    id: string;
+}
+interface SecretFolderDetailed extends SecretFolder {
+    environment: {
+        envId: string;
+        envName: string;
+        envSlug: string;
+    };
+    path: string;
+    projectId: string;
+}
+interface GetSecretFolderByIdResponse {
+    folder: SecretFolderDetailed;
+}
+
+declare class SecretFoldersResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    create(params: CreateSecretFolderParams): Promise<CreateSecretFolderResponse>;
+    update(params: UpdateSecretFolderParams): Promise<UpdateSecretFolderResponse>;
+    updateBatch(params: UpdateSecretFolderBatchParams): Promise<UpdateSecretFolderBatchResponse>;
+    delete(params: DeleteSecretFolderParams): Promise<DeleteSecretFolderResponse>;
+    list(params: ListSecretFoldersParams): Promise<ListSecretFoldersResponse>;
+    getById(params: GetSecretFolderByIdParams): Promise<GetSecretFolderByIdResponse>;
+}
+
+interface SecretImportEnv {
+    name: string;
+    slug: string;
+    id: string;
+}
+interface SecretImport {
+    id: string;
+    folderId: string;
+    importPath: string;
+    importEnv: SecretImportEnv;
+    position: number;
+    isReplication?: boolean;
+    isReplicationSuccess?: boolean | null;
+    replicationStatus?: string | null;
+    lastReplicated?: string | null;
+    isReserved?: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateSecretImportParams {
+    projectId: string;
+    environment: string;
+    path?: string;
+    import: {
+        environment: string;
+        path: string;
+    };
+    isReplication?: boolean;
+}
+interface CreateSecretImportResponse {
+    message: string;
+    secretImport: SecretImport;
+}
+interface UpdateSecretImportParams {
+    secretImportId: string;
+    projectId: string;
+    environment: string;
+    path?: string;
+    import: {
+        environment?: string;
+        path?: string;
+        position?: number;
+    };
+}
+interface UpdateSecretImportResponse {
+    message: string;
+    secretImport: SecretImport;
+}
+interface DeleteSecretImportParams {
+    secretImportId: string;
+    projectId: string;
+    environment: string;
+    path?: string;
+}
+interface DeleteSecretImportResponse {
+    message: string;
+    secretImport: SecretImport;
+}
+interface ResyncReplicationParams {
+    secretImportId: string;
+    projectId: string;
+    environment: string;
+    path?: string;
+}
+interface ResyncReplicationResponse {
+    message: string;
+}
+interface ListSecretImportsParams {
+    projectId: string;
+    environment: string;
+    path?: string;
+}
+interface ListSecretImportsResponse {
+    message: string;
+    secretImports: SecretImport[];
+}
+interface GetSecretImportParams {
+    secretImportId: string;
+}
+interface SecretImportDetailed extends SecretImport {
+    environment: {
+        id: string;
+        name: string;
+        slug: string;
+    };
+    projectId: string;
+    secretPath: string;
+}
+interface GetSecretImportResponse {
+    secretImport: SecretImportDetailed;
+}
+interface GetRawSecretsFromImportsParams {
+    projectId: string;
+    environment: string;
+    path?: string;
+}
+interface RawSecret {
+    id: string;
+    version: number;
+    type: string;
+    secretKey: string;
+    secretValue: string;
+    secretComment?: string;
+    secretReminderNote?: string | null;
+    secretReminderRepeatDays?: number | null;
+    skipMultilineEncoding?: boolean | null;
+    metadata?: Record<string, string>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface ImportedSecretGroup {
+    secretPath: string;
+    environment: string;
+    environmentInfo: {
+        id: string;
+        name: string;
+        slug: string;
+    };
+    folderId?: string;
+    secrets: RawSecret[];
+}
+interface GetRawSecretsFromImportsResponse {
+    secrets: ImportedSecretGroup[];
+}
+
+declare class SecretImportsResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    create(params: CreateSecretImportParams): Promise<CreateSecretImportResponse>;
+    update(params: UpdateSecretImportParams): Promise<UpdateSecretImportResponse>;
+    delete(params: DeleteSecretImportParams): Promise<DeleteSecretImportResponse>;
+    resyncReplication(params: ResyncReplicationParams): Promise<ResyncReplicationResponse>;
+    list(params: ListSecretImportsParams): Promise<ListSecretImportsResponse>;
+    get(params: GetSecretImportParams): Promise<GetSecretImportResponse>;
+    getRawSecrets(params: GetRawSecretsFromImportsParams): Promise<GetRawSecretsFromImportsResponse>;
+}
+
+interface CertificateAuthority {
+    id: string;
+    type: string;
+    name: string;
+    projectId: string;
+    status: string;
+    createdAt: string;
+    updatedAt: string;
+    [key: string]: unknown;
+}
+interface ListCertificateAuthoritiesParams {
+    projectId: string;
+}
+interface ListCertificateAuthoritiesResponse {
+    certificateAuthorities: CertificateAuthority[];
+}
+interface GetCaParams {
+    caId: string;
+}
+interface GetCaResponse {
+    ca: CertificateAuthority;
+}
+interface CreateCaParams {
+    projectSlug: string;
+    type: string;
+    friendlyName?: string;
+    commonName: string;
+    organization?: string;
+    ou?: string;
+    country?: string;
+    province?: string;
+    locality?: string;
+    notBefore?: string;
+    notAfter?: string;
+    maxPathLength?: number;
+    keyAlgorithm?: string;
+    requireTemplateForIssuance?: boolean;
+}
+interface CreateCaResponse {
+    ca: CertificateAuthority;
+}
+interface UpdateCaParams {
+    caId: string;
+    status?: string;
+    requireTemplateForIssuance?: boolean;
+}
+interface UpdateCaResponse {
+    ca: CertificateAuthority;
+}
+interface DeleteCaParams {
+    caId: string;
+}
+interface DeleteCaResponse {
+    ca: CertificateAuthority;
+}
+interface GetCaCsrParams {
+    caId: string;
+}
+interface GetCaCsrResponse {
+    csr: string;
+}
+interface GetCaCertificateParams {
+    caId: string;
+}
+interface GetCaCertificateResponse {
+    certificate: string;
+    certificateChain: string;
+    serialNumber: string;
+}
+interface ListCaCertificatesParams {
+    caId: string;
+}
+interface CaCertificateEntry {
+    certificate: string;
+    certificateChain: string;
+    serialNumber: string;
+    version: number;
+}
+type ListCaCertificatesResponse = CaCertificateEntry[];
+interface GetCaCrlsParams {
+    caId: string;
+}
+interface CaCrlEntry {
+    id: string;
+    crl: string;
+}
+type GetCaCrlsResponse = CaCrlEntry[];
+interface RenewCaParams {
+    caId: string;
+    type: string;
+    notAfter: string;
+}
+interface RenewCaResponse {
+    certificate: string;
+    certificateChain: string;
+    serialNumber: string;
+}
+interface SignIntermediateCaParams {
+    caId: string;
+    csr: string;
+    notBefore?: string;
+    notAfter: string;
+    maxPathLength?: number;
+}
+interface SignIntermediateCaResponse {
+    certificate: string;
+    certificateChain: string;
+    issuingCaCertificate: string;
+    serialNumber: string;
+}
+
+declare class PkiCaResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    list(params: ListCertificateAuthoritiesParams): Promise<ListCertificateAuthoritiesResponse>;
+    get(params: GetCaParams): Promise<GetCaResponse>;
+    create(params: CreateCaParams): Promise<CreateCaResponse>;
+    update(params: UpdateCaParams): Promise<UpdateCaResponse>;
+    delete(params: DeleteCaParams): Promise<DeleteCaResponse>;
+    getCsr(params: GetCaCsrParams): Promise<GetCaCsrResponse>;
+    getCertificate(params: GetCaCertificateParams): Promise<GetCaCertificateResponse>;
+    listCertificates(params: ListCaCertificatesParams): Promise<ListCaCertificatesResponse>;
+    getCrls(params: GetCaCrlsParams): Promise<GetCaCrlsResponse>;
+    renew(params: RenewCaParams): Promise<RenewCaResponse>;
+    signIntermediate(params: SignIntermediateCaParams): Promise<SignIntermediateCaResponse>;
+}
+
+interface CertificateTemplate {
+    id: string;
+    caId: string;
+    name: string;
+    commonName: string;
+    subjectAlternativeName: string;
+    ttl: string;
+    projectId: string;
+    keyUsages?: CertKeyUsage[];
+    extendedKeyUsages?: CertExtendedKeyUsage[];
+    createdAt: string;
+    updatedAt: string;
+}
+interface CertificateTemplateWithCa extends CertificateTemplate {
+    ca: {
+        id: string;
+        name: string;
+    };
+}
+interface CreatePkiTemplateParams {
+    name: string;
+    caName: string;
+    projectId: string;
+    commonName: string;
+    subjectAlternativeName: string;
+    ttl: string;
+    keyUsages?: CertKeyUsage[];
+    extendedKeyUsages?: CertExtendedKeyUsage[];
+}
+interface CreatePkiTemplateResponse {
+    certificateTemplate: CertificateTemplate;
+}
+interface UpdatePkiTemplateParams {
+    templateName: string;
+    name?: string;
+    caName: string;
+    projectId: string;
+    commonName?: string;
+    subjectAlternativeName?: string;
+    ttl?: string;
+    keyUsages?: CertKeyUsage[];
+    extendedKeyUsages?: CertExtendedKeyUsage[];
+}
+interface UpdatePkiTemplateResponse {
+    certificateTemplate: CertificateTemplate;
+}
+interface DeletePkiTemplateParams {
+    templateName: string;
+    projectId: string;
+}
+interface DeletePkiTemplateResponse {
+    certificateTemplate: CertificateTemplate;
+}
+interface GetPkiTemplateParams {
+    templateName: string;
+    projectId: string;
+}
+interface GetPkiTemplateResponse {
+    certificateTemplate: CertificateTemplateWithCa;
+}
+interface ListPkiTemplatesParams {
+    projectId: string;
+    limit?: number;
+    offset?: number;
+}
+interface ListPkiTemplatesResponse {
+    certificateTemplates: CertificateTemplateWithCa[];
+    totalCount: number;
+}
+interface IssueCertificateParams {
+    templateName: string;
+    projectId: string;
+    commonName: string;
+    ttl: string;
+    keyUsages?: CertKeyUsage[];
+    extendedKeyUsages?: CertExtendedKeyUsage[];
+    notBefore?: string;
+    notAfter?: string;
+    altNames?: string;
+}
+interface IssueCertificateResponse {
+    certificate: string;
+    issuingCaCertificate: string;
+    certificateChain: string;
+    privateKey: string;
+    serialNumber: string;
+}
+interface SignCertificateParams {
+    templateName: string;
+    projectId: string;
+    ttl: string;
+    csr: string;
+}
+interface SignCertificateResponse {
+    certificate: string;
+    issuingCaCertificate: string;
+    certificateChain: string;
+    serialNumber: string;
+}
+
+declare class PkiTemplatesResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    create(params: CreatePkiTemplateParams): Promise<CreatePkiTemplateResponse>;
+    update(params: UpdatePkiTemplateParams): Promise<UpdatePkiTemplateResponse>;
+    delete(params: DeletePkiTemplateParams): Promise<DeletePkiTemplateResponse>;
+    get(params: GetPkiTemplateParams): Promise<GetPkiTemplateResponse>;
+    list(params: ListPkiTemplatesParams): Promise<ListPkiTemplatesResponse>;
+    issueCertificate(params: IssueCertificateParams): Promise<IssueCertificateResponse>;
+    signCertificate(params: SignCertificateParams): Promise<SignCertificateResponse>;
+}
+
+interface PkiFilterRule {
+    field: string;
+    operator: string;
+    value: string;
+}
+interface PkiAlertChannel {
+    id: string;
+    channelType: PkiAlertChannelType;
+    config: Record<string, unknown>;
+    enabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface PkiAlert {
+    id: string;
+    name: string;
+    description: string | null;
+    eventType: PkiAlertEventType;
+    alertBefore: string;
+    filters: PkiFilterRule[];
+    enabled: boolean;
+    projectId: string;
+    channels: PkiAlertChannel[];
+    createdAt: string;
+    updatedAt: string;
+}
+interface PkiAlertCertificate {
+    id: string;
+    serialNumber: string;
+    commonName: string;
+    san: string[];
+    profileName: string | null;
+    enrollmentType: string | null;
+    notBefore: string;
+    notAfter: string;
+    status: string;
+}
+interface CreatePkiAlertParams {
+    projectId: string;
+    name: string;
+    description?: string | null;
+    eventType: PkiAlertEventType;
+    alertBefore: string;
+    filters?: PkiFilterRule[];
+    enabled?: boolean;
+    channels?: Array<{
+        channelType: PkiAlertChannelType;
+        config: Record<string, unknown>;
+        enabled?: boolean;
+    }>;
+}
+interface CreatePkiAlertResponse {
+    alert: PkiAlert;
+}
+interface ListPkiAlertsParams {
+    projectId: string;
+    search?: string;
+    eventType?: PkiAlertEventType;
+    enabled?: boolean;
+    limit?: number;
+    offset?: number;
+}
+interface ListPkiAlertsResponse {
+    alerts: PkiAlert[];
+    total: number;
+}
+interface GetPkiAlertParams {
+    alertId: string;
+}
+interface GetPkiAlertResponse {
+    alert: PkiAlert;
+}
+interface UpdatePkiAlertParams {
+    alertId: string;
+    name?: string;
+    description?: string | null;
+    eventType?: PkiAlertEventType;
+    alertBefore?: string;
+    filters?: PkiFilterRule[];
+    enabled?: boolean;
+    channels?: Array<{
+        id?: string;
+        channelType: PkiAlertChannelType;
+        config: Record<string, unknown>;
+        enabled?: boolean;
+    }>;
+}
+interface UpdatePkiAlertResponse {
+    alert: PkiAlert;
+}
+interface DeletePkiAlertParams {
+    alertId: string;
+}
+interface DeletePkiAlertResponse {
+    alert: PkiAlert;
+}
+interface ListPkiAlertCertificatesParams {
+    alertId: string;
+    limit?: number;
+    offset?: number;
+}
+interface ListPkiAlertCertificatesResponse {
+    certificates: PkiAlertCertificate[];
+    total: number;
+}
+interface PreviewPkiAlertCertificatesParams {
+    projectId: string;
+    filters: PkiFilterRule[];
+    alertBefore: string;
+    limit?: number;
+    offset?: number;
+}
+interface PreviewPkiAlertCertificatesResponse {
+    certificates: PkiAlertCertificate[];
+    total: number;
+}
+
+declare class PkiAlertsResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    create(params: CreatePkiAlertParams): Promise<CreatePkiAlertResponse>;
+    list(params: ListPkiAlertsParams): Promise<ListPkiAlertsResponse>;
+    get(params: GetPkiAlertParams): Promise<GetPkiAlertResponse>;
+    update(params: UpdatePkiAlertParams): Promise<UpdatePkiAlertResponse>;
+    delete(params: DeletePkiAlertParams): Promise<DeletePkiAlertResponse>;
+    listCertificates(params: ListPkiAlertCertificatesParams): Promise<ListPkiAlertCertificatesResponse>;
+    previewCertificates(params: PreviewPkiAlertCertificatesParams): Promise<PreviewPkiAlertCertificatesResponse>;
+}
+
+interface Certificate {
+    id: string;
+    caId?: string | null;
+    status: string;
+    friendlyName?: string;
+    commonName?: string;
+    serialNumber?: string;
+    notBefore?: string;
+    notAfter?: string;
+    keyAlgorithm?: string;
+    createdAt: string;
+    updatedAt: string;
+    [key: string]: unknown;
+}
+interface CreateCertificateParams {
+    profileId: string;
+    csr?: string;
+    attributes?: {
+        commonName?: string;
+        organization?: string;
+        organizationalUnit?: string;
+        country?: string;
+        state?: string;
+        locality?: string;
+        keyUsages?: string[];
+        extendedKeyUsages?: string[];
+        altNames?: Array<{
+            type: string;
+            value: string;
+        }>;
+        signatureAlgorithm?: string;
+        keyAlgorithm?: string;
+        ttl?: string;
+        notBefore?: string;
+        notAfter?: string;
+        basicConstraints?: {
+            isCA: boolean;
+            pathLength?: number;
+        };
+    };
+    removeRootsFromChain?: boolean;
+}
+interface CreateCertificateResponse {
+    certificate: {
+        certificate: string;
+        issuingCaCertificate: string;
+        certificateChain: string;
+        privateKey?: string;
+        serialNumber: string;
+        certificateId: string;
+    } | null;
+    certificateRequestId: string;
+    status?: string;
+    message?: string;
+}
+interface GetCertificateParams {
+    certificateId: string;
+}
+interface GetCertificateResponse {
+    certificate: Certificate & {
+        subject?: {
+            commonName?: string;
+            organization?: string;
+            organizationalUnit?: string;
+            country?: string;
+            state?: string;
+            locality?: string;
+        };
+        fingerprints?: {
+            sha256: string;
+            sha1: string;
+        };
+        basicConstraints?: {
+            isCA: boolean;
+            pathLength?: number;
+        };
+        caName?: string | null;
+        caType?: string | null;
+        profileName?: string | null;
+    };
+}
+interface GetCertificateBodyParams {
+    certificateId: string;
+}
+interface GetCertificateBodyResponse {
+    certificate: string;
+    certificateChain: string | null;
+    serialNumber: string;
+}
+interface GetCertificateBundleParams {
+    certificateId: string;
+}
+interface GetCertificateBundleResponse {
+    certificate: string;
+    certificateChain: string | null;
+    privateKey: string | null;
+    serialNumber: string;
+}
+interface GetCertificatePrivateKeyParams {
+    certificateId: string;
+}
+type GetCertificatePrivateKeyResponse = string;
+interface RenewCertificateParams {
+    certificateId: string;
+    removeRootsFromChain?: boolean;
+}
+interface RenewCertificateResponse {
+    certificate: string;
+    issuingCaCertificate: string;
+    certificateChain: string;
+    privateKey?: string;
+    serialNumber: string;
+    certificateId: string;
+    certificateRequestId: string;
+}
+interface RevokeCertificateParams {
+    certificateId: string;
+    revocationReason: string;
+}
+interface RevokeCertificateResponse {
+    message: string;
+    serialNumber: string;
+    revokedAt: string;
+}
+interface DeleteCertificateParams {
+    certificateId: string;
+}
+interface DeleteCertificateResponse {
+    certificate: Certificate;
+}
+interface UpdateCertificateConfigParams {
+    certificateId: string;
+    renewBeforeDays?: number;
+    enableAutoRenewal?: boolean;
+}
+interface UpdateCertificateConfigResponse {
+    message: string;
+    renewBeforeDays?: number;
+}
+
+declare class PkiCertificatesResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    create(params: CreateCertificateParams): Promise<CreateCertificateResponse>;
+    get(params: GetCertificateParams): Promise<GetCertificateResponse>;
+    getBody(params: GetCertificateBodyParams): Promise<GetCertificateBodyResponse>;
+    getBundle(params: GetCertificateBundleParams): Promise<GetCertificateBundleResponse>;
+    getPrivateKey(params: GetCertificatePrivateKeyParams): Promise<GetCertificatePrivateKeyResponse>;
+    renew(params: RenewCertificateParams): Promise<RenewCertificateResponse>;
+    revoke(params: RevokeCertificateParams): Promise<RevokeCertificateResponse>;
+    delete(params: DeleteCertificateParams): Promise<DeleteCertificateResponse>;
+    updateConfig(params: UpdateCertificateConfigParams): Promise<UpdateCertificateConfigResponse>;
+}
+
+interface SecretTag {
+    id: string;
+    slug: string;
+    name: string;
+    color?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface ListSecretTagsParams {
+    projectId: string;
+}
+interface ListSecretTagsResponse {
+    tags: SecretTag[];
+}
+interface GetSecretTagByIdParams {
+    projectId: string;
+    tagId: string;
+}
+interface GetSecretTagByIdResponse {
+    tag: SecretTag;
+}
+interface GetSecretTagBySlugParams {
+    projectId: string;
+    tagSlug: string;
+}
+interface GetSecretTagBySlugResponse {
+    tag: SecretTag;
+}
+interface CreateSecretTagParams {
+    projectId: string;
+    slug: string;
+    color: string;
+}
+interface CreateSecretTagResponse {
+    tag: SecretTag;
+}
+interface UpdateSecretTagParams {
+    projectId: string;
+    tagId: string;
+    slug: string;
+    color: string;
+}
+interface UpdateSecretTagResponse {
+    tag: SecretTag;
+}
+interface DeleteSecretTagParams {
+    projectId: string;
+    tagId: string;
+}
+interface DeleteSecretTagResponse {
+    tag: SecretTag;
+}
+
+declare class SecretTagsResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    list(params: ListSecretTagsParams): Promise<ListSecretTagsResponse>;
+    getById(params: GetSecretTagByIdParams): Promise<GetSecretTagByIdResponse>;
+    getBySlug(params: GetSecretTagBySlugParams): Promise<GetSecretTagBySlugResponse>;
+    create(params: CreateSecretTagParams): Promise<CreateSecretTagResponse>;
+    update(params: UpdateSecretTagParams): Promise<UpdateSecretTagResponse>;
+    delete(params: DeleteSecretTagParams): Promise<DeleteSecretTagResponse>;
+}
+
+interface Identity {
+    id: string;
+    name: string;
+    authMethod?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface IdentityWithMetadata extends Identity {
+    metadata?: Array<{
+        key: string;
+        value: string;
+    }>;
+}
+interface IdentityProjectMembership {
+    id: string;
+    identityId: string;
+    projectId: string;
+    roles: Array<{
+        id: string;
+        role: string;
+        customRoleId?: string | null;
+        customRoleName?: string | null;
+        customRoleSlug?: string | null;
+        isTemporary: boolean;
+        temporaryMode?: string | null;
+        temporaryRange?: string | null;
+        temporaryAccessStartTime?: string | null;
+        temporaryAccessEndTime?: string | null;
+    }>;
+    project: {
+        name: string;
+        id: string;
+        type: string;
+    };
+    identity: {
+        id: string;
+        name: string;
+        authMethod?: string | null;
+    };
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateIdentityParams {
+    name: string;
+    organizationId: string;
+    role?: string;
+    metadata?: Record<string, string>;
+}
+interface CreateIdentityResponse {
+    identity: Identity;
+}
+interface UpdateIdentityParams {
+    identityId: string;
+    name?: string;
+    role?: string;
+    metadata?: Record<string, string>;
+}
+interface UpdateIdentityResponse {
+    identity: Identity;
+}
+interface DeleteIdentityParams {
+    identityId: string;
+}
+interface DeleteIdentityResponse {
+    identity: Identity;
+}
+interface GetIdentityParams {
+    identityId: string;
+}
+interface GetIdentityResponse {
+    identity: IdentityWithMetadata;
+}
+interface ListIdentityProjectMembershipsParams {
+    identityId: string;
+}
+interface ListIdentityProjectMembershipsResponse {
+    identityMemberships: IdentityProjectMembership[];
+}
+interface SearchIdentitiesParams {
+    organizationId: string;
+    searchFilter?: string;
+    offset?: number;
+    limit?: number;
+    orderBy?: string;
+    orderDirection?: string;
+}
+interface SearchIdentitiesResponse {
+    identities: IdentityWithMetadata[];
+    totalCount: number;
+}
+
+declare class IdentitiesResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    create(params: CreateIdentityParams): Promise<CreateIdentityResponse>;
+    update(params: UpdateIdentityParams): Promise<UpdateIdentityResponse>;
+    delete(params: DeleteIdentityParams): Promise<DeleteIdentityResponse>;
+    get(params: GetIdentityParams): Promise<GetIdentityResponse>;
+    listProjectMemberships(params: ListIdentityProjectMembershipsParams): Promise<ListIdentityProjectMembershipsResponse>;
+    search(params: SearchIdentitiesParams): Promise<SearchIdentitiesResponse>;
+}
+
+interface RenewAccessTokenParams {
+    accessToken: string;
+}
+interface RenewAccessTokenResponse {
+    accessToken: string;
+    expiresIn: number;
+    accessTokenMaxTTL: number;
+    tokenType: string;
+}
+interface RevokeAccessTokenParams {
+    accessToken: string;
+}
+interface RevokeAccessTokenResponse {
+    message: string;
+}
+
+declare class IdentityAccessTokensResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    renew(params: RenewAccessTokenParams): Promise<RenewAccessTokenResponse>;
+    revoke(params: RevokeAccessTokenParams): Promise<RevokeAccessTokenResponse>;
+}
+
+interface Project {
+    id: string;
+    name: string;
+    slug: string;
+    orgId: string;
+    type: string;
+    version: number;
+    environments: Array<{
+        id: string;
+        name: string;
+        slug: string;
+        position: number;
+    }>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface ProjectMembershipEntry {
+    id: string;
+    userId: string;
+    projectId: string;
+    roles: Array<{
+        id: string;
+        role: string;
+        customRoleId?: string | null;
+        customRoleName?: string | null;
+        customRoleSlug?: string | null;
+        isTemporary: boolean;
+        temporaryMode?: string | null;
+        temporaryRange?: string | null;
+        temporaryAccessStartTime?: string | null;
+        temporaryAccessEndTime?: string | null;
+    }>;
+    user: {
+        id: string;
+        email?: string | null;
+        username: string;
+        firstName?: string | null;
+        lastName?: string | null;
+    };
+    createdAt: string;
+    updatedAt: string;
+}
+interface ProjectRole {
+    id: string;
+    name: string;
+    slug: string;
+    description?: string | null;
+    permissions: unknown[];
+    createdAt: string;
+    updatedAt: string;
+}
+interface ProjectTag {
+    id: string;
+    name: string;
+    slug: string;
+    color?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface GetProjectParams {
+    projectId: string;
+}
+interface GetProjectResponse {
+    workspace: Project;
+}
+interface UpdateProjectParams {
+    projectId: string;
+    name?: string;
+    autoCapitalization?: boolean;
+}
+interface UpdateProjectResponse {
+    workspace: Project;
+}
+interface DeleteProjectParams {
+    projectId: string;
+}
+interface DeleteProjectResponse {
+    workspace: Project;
+}
+interface ListProjectMembershipsParams {
+    projectId: string;
+}
+interface ListProjectMembershipsResponse {
+    memberships: ProjectMembershipEntry[];
+}
+interface ListProjectEnvironmentsParams {
+    projectId: string;
+}
+interface ListProjectEnvironmentsResponse {
+    environments: Array<{
+        id: string;
+        name: string;
+        slug: string;
+        position: number;
+    }>;
+}
+interface CreateProjectEnvironmentParams {
+    projectId: string;
+    name: string;
+    slug: string;
+    position?: number;
+}
+interface CreateProjectEnvironmentResponse {
+    environment: {
+        id: string;
+        name: string;
+        slug: string;
+        position: number;
+    };
+}
+interface UpdateProjectEnvironmentParams {
+    projectId: string;
+    environmentId: string;
+    name?: string;
+    slug?: string;
+    position?: number;
+}
+interface UpdateProjectEnvironmentResponse {
+    environment: {
+        id: string;
+        name: string;
+        slug: string;
+        position: number;
+    };
+}
+interface DeleteProjectEnvironmentParams {
+    projectId: string;
+    environmentId: string;
+}
+interface DeleteProjectEnvironmentResponse {
+    environment: {
+        id: string;
+        name: string;
+        slug: string;
+        position: number;
+    };
+}
+interface ListProjectRolesParams {
+    projectId: string;
+}
+interface ListProjectRolesResponse {
+    roles: ProjectRole[];
+}
+interface ListProjectTagsParams {
+    projectId: string;
+}
+interface ListProjectTagsResponse {
+    tags: ProjectTag[];
+}
+interface CreateProjectParams {
+    projectName: string;
+    projectDescription?: string;
+    slug?: string;
+    kmsKeyId?: string;
+    template?: string;
+    type?: string;
+    shouldCreateDefaultEnvs?: boolean;
+    hasDeleteProtection?: boolean;
+}
+interface CreateProjectResponse {
+    project: Project & {
+        _id: string;
+    };
+}
+interface ListProjectsParams {
+    includeRoles?: boolean;
+    type?: string;
+}
+interface ListProjectsResponse {
+    projects: Array<Project & {
+        _id: string;
+    }>;
+}
+interface GetProjectBySlugParams {
+    slug: string;
+}
+interface GetProjectBySlugResponse extends Project {
+    _id: string;
+}
+
+declare class ProjectsResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    create(params: CreateProjectParams): Promise<CreateProjectResponse>;
+    list(params?: ListProjectsParams): Promise<ListProjectsResponse>;
+    get(params: GetProjectParams): Promise<GetProjectResponse>;
+    getBySlug(params: GetProjectBySlugParams): Promise<GetProjectBySlugResponse>;
+    update(params: UpdateProjectParams): Promise<UpdateProjectResponse>;
+    delete(params: DeleteProjectParams): Promise<DeleteProjectResponse>;
+    listMemberships(params: ListProjectMembershipsParams): Promise<ListProjectMembershipsResponse>;
+    listEnvironments(params: ListProjectEnvironmentsParams): Promise<ListProjectEnvironmentsResponse>;
+    createEnvironment(params: CreateProjectEnvironmentParams): Promise<CreateProjectEnvironmentResponse>;
+    updateEnvironment(params: UpdateProjectEnvironmentParams): Promise<UpdateProjectEnvironmentResponse>;
+    deleteEnvironment(params: DeleteProjectEnvironmentParams): Promise<DeleteProjectEnvironmentResponse>;
+    listRoles(params: ListProjectRolesParams): Promise<ListProjectRolesResponse>;
+    listTags(params: ListProjectTagsParams): Promise<ListProjectTagsResponse>;
+}
+
+interface Webhook {
+    id: string;
+    projectId: string;
+    environment: string;
+    secretPath: string;
+    url: string;
+    isDisabled: boolean;
+    lastStatus?: string | null;
+    lastRunErrorMessage?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateWebhookParams {
+    projectId: string;
+    environment: string;
+    secretPath?: string;
+    webhookUrl: string;
+    webhookSecretKey?: string;
+}
+interface CreateWebhookResponse {
+    webhook: Webhook;
+}
+interface UpdateWebhookParams {
+    webhookId: string;
+    isDisabled?: boolean;
+}
+interface UpdateWebhookResponse {
+    webhook: Webhook;
+}
+interface DeleteWebhookParams {
+    webhookId: string;
+}
+interface DeleteWebhookResponse {
+    webhook: Webhook;
+}
+interface ListWebhooksParams {
+    projectId: string;
+    environment?: string;
+    secretPath?: string;
+}
+interface ListWebhooksResponse {
+    webhooks: Webhook[];
+}
+interface TestWebhookParams {
+    webhookId: string;
+}
+interface TestWebhookResponse {
+    webhook: Webhook;
+}
+
+declare class WebhooksResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    create(params: CreateWebhookParams): Promise<CreateWebhookResponse>;
+    update(params: UpdateWebhookParams): Promise<UpdateWebhookResponse>;
+    delete(params: DeleteWebhookParams): Promise<DeleteWebhookResponse>;
+    list(params: ListWebhooksParams): Promise<ListWebhooksResponse>;
+    test(params: TestWebhookParams): Promise<TestWebhookResponse>;
+}
+
+interface SharedSecret {
+    id: string;
+    encryptedValue: string;
+    iv: string;
+    tag: string;
+    hashedHex: string;
+    expiresAt: string;
+    expiresAfterViews?: number | null;
+    accessType: string;
+    orgId?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateSharedSecretParams {
+    encryptedValue: string;
+    iv: string;
+    tag: string;
+    hashedHex: string;
+    expiresAt: string;
+    expiresAfterViews?: number;
+    accessType?: string;
+}
+interface CreateSharedSecretResponse {
+    id: string;
+}
+interface GetSharedSecretParams {
+    sharedSecretId: string;
+    hashedHex: string;
+}
+interface GetSharedSecretResponse {
+    encryptedValue: string;
+    iv: string;
+    tag: string;
+    expiresAt: string;
+    accessType: string;
+    orgId?: string | null;
+}
+interface DeleteSharedSecretParams {
+    sharedSecretId: string;
+}
+interface DeleteSharedSecretResponse {
+    secret: SharedSecret;
+}
+interface ListSharedSecretsResponse {
+    secrets: SharedSecret[];
+}
+
+declare class SecretSharingResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    create(params: CreateSharedSecretParams): Promise<CreateSharedSecretResponse>;
+    get(params: GetSharedSecretParams): Promise<GetSharedSecretResponse>;
+    delete(params: DeleteSharedSecretParams): Promise<DeleteSharedSecretResponse>;
+    list(): Promise<ListSharedSecretsResponse>;
+}
+
+interface SecretAccessEntry {
+    allowedMembership: {
+        id: string;
+        userId: string;
+        user: {
+            id: string;
+            email?: string | null;
+            username: string;
+        };
+    } | null;
+    allowedIdentity: {
+        id: string;
+        name: string;
+    } | null;
+}
+interface GetSecretAccessListParams {
+    secretName: string;
+    projectId: string;
+    environment: string;
+    secretPath?: string;
+}
+interface GetSecretAccessListResponse {
+    accessList: SecretAccessEntry[];
+}
+interface Secret {
+    id: string;
+    version: number;
+    type: string;
+    secretKey: string;
+    secretValue: string;
+    secretComment?: string;
+    secretReminderNote?: string | null;
+    secretReminderRepeatDays?: number | null;
+    skipMultilineEncoding?: boolean;
+    metadata?: Record<string, string>;
+    createdAt: string;
+    updatedAt: string;
+    [key: string]: unknown;
+}
+interface SecretTagRef {
+    id: string;
+    slug: string;
+    name: string;
+    color?: string | null;
+}
+interface ListSecretsParams {
+    projectId: string;
+    environment: string;
+    secretPath?: string;
+    expandSecretReferences?: boolean;
+    recursive?: boolean;
+    include_imports?: boolean;
+    tagSlugs?: string;
+    viewSecretValue?: boolean;
+    metadataFilter?: string;
+}
+interface ListSecretsResponse {
+    secrets: Secret[];
+    imports?: Array<{
+        secretPath: string;
+        environment: string;
+        folderId?: string;
+        secrets: Secret[];
+    }>;
+}
+interface GetSecretByNameParams {
+    secretName: string;
+    projectId: string;
+    environment: string;
+    secretPath?: string;
+    version?: number;
+    type?: string;
+    viewSecretValue?: boolean;
+    expandSecretReferences?: boolean;
+    include_imports?: boolean;
+}
+interface GetSecretByNameResponse {
+    secret: Secret & {
+        secretPath: string;
+        tags?: SecretTagRef[];
+    };
+}
+interface GetSecretByIdParams {
+    secretId: string;
+}
+interface GetSecretByIdResponse {
+    secret: Secret & {
+        secretPath: string;
+        tags?: SecretTagRef[];
+    };
+}
+interface CreateSecretParams {
+    secretName: string;
+    projectId: string;
+    environment: string;
+    secretValue: string;
+    secretPath?: string;
+    secretComment?: string;
+    tagIds?: string[];
+    skipMultilineEncoding?: boolean;
+    type?: string;
+    secretReminderRepeatDays?: number | null;
+    secretReminderNote?: string | null;
+    secretMetadata?: Record<string, string>;
+}
+interface CreateSecretResponse {
+    secret: Secret;
+}
+interface UpdateSecretParams {
+    secretName: string;
+    projectId: string;
+    environment: string;
+    secretValue?: string;
+    secretPath?: string;
+    skipMultilineEncoding?: boolean;
+    type?: string;
+    tagIds?: string[];
+    metadata?: Record<string, string>;
+    secretMetadata?: Record<string, string>;
+    secretReminderNote?: string | null;
+    secretReminderRepeatDays?: number | null;
+    secretReminderRecipients?: string[];
+    newSecretName?: string;
+    secretComment?: string;
+}
+interface UpdateSecretResponse {
+    secret: Secret;
+}
+interface DeleteSecretParams {
+    secretName: string;
+    projectId: string;
+    environment: string;
+    secretPath?: string;
+    type?: string;
+}
+interface DeleteSecretResponse {
+    secret: Secret;
+}
+interface BatchCreateSecretsParams {
+    projectId: string;
+    environment: string;
+    secretPath?: string;
+    secrets: Array<{
+        secretKey: string;
+        secretValue: string;
+        secretComment?: string;
+        skipMultilineEncoding?: boolean;
+        metadata?: Record<string, string>;
+        secretMetadata?: Record<string, string>;
+        tagIds?: string[];
+    }>;
+}
+interface BatchCreateSecretsResponse {
+    secrets: Secret[];
+}
+interface BatchUpdateSecretsParams {
+    projectId: string;
+    environment: string;
+    secretPath?: string;
+    mode?: string;
+    secrets: Array<{
+        secretKey: string;
+        secretValue?: string;
+        secretPath?: string;
+        secretComment?: string;
+        skipMultilineEncoding?: boolean;
+        newSecretName?: string;
+        tagIds?: string[];
+        secretReminderNote?: string | null;
+        secretMetadata?: Record<string, string>;
+        secretReminderRepeatDays?: number | null;
+    }>;
+}
+interface BatchUpdateSecretsResponse {
+    secrets: Secret[];
+}
+interface BatchDeleteSecretsParams {
+    projectId: string;
+    environment: string;
+    secretPath?: string;
+    secrets: Array<{
+        secretKey: string;
+        type?: string;
+    }>;
+}
+interface BatchDeleteSecretsResponse {
+    secrets: Secret[];
+}
+interface MoveSecretsParams {
+    projectId: string;
+    sourceEnvironment: string;
+    sourceSecretPath?: string;
+    destinationEnvironment: string;
+    destinationSecretPath?: string;
+    secretIds: string[];
+    shouldOverwrite?: boolean;
+}
+interface MoveSecretsResponse {
+    isSourceUpdated: boolean;
+    isDestinationUpdated: boolean;
+}
+
+declare class SecretsResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    getAccessList(params: GetSecretAccessListParams): Promise<GetSecretAccessListResponse>;
+    list(params: ListSecretsParams): Promise<ListSecretsResponse>;
+    getByName(params: GetSecretByNameParams): Promise<GetSecretByNameResponse>;
+    getById(params: GetSecretByIdParams): Promise<GetSecretByIdResponse>;
+    create(params: CreateSecretParams): Promise<CreateSecretResponse>;
+    update(params: UpdateSecretParams): Promise<UpdateSecretResponse>;
+    delete(params: DeleteSecretParams): Promise<DeleteSecretResponse>;
+    batchCreate(params: BatchCreateSecretsParams): Promise<BatchCreateSecretsResponse>;
+    batchUpdate(params: BatchUpdateSecretsParams): Promise<BatchUpdateSecretsResponse>;
+    batchDelete(params: BatchDeleteSecretsParams): Promise<BatchDeleteSecretsResponse>;
+    move(params: MoveSecretsParams): Promise<MoveSecretsResponse>;
+}
+
+interface KmsKey {
+    id: string;
+    name: string;
+    description?: string | null;
+    projectId: string;
+    isDisabled: boolean;
+    encryptionAlgorithm: string;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateKmsKeyParams {
+    projectId: string;
+    name: string;
+    description?: string;
+    encryptionAlgorithm?: string;
+}
+interface CreateKmsKeyResponse {
+    key: KmsKey;
+}
+interface UpdateKmsKeyParams {
+    keyId: string;
+    name?: string;
+    description?: string;
+    isDisabled?: boolean;
+}
+interface UpdateKmsKeyResponse {
+    key: KmsKey;
+}
+interface DeleteKmsKeyParams {
+    keyId: string;
+}
+interface DeleteKmsKeyResponse {
+    key: KmsKey;
+}
+interface GetKmsKeyParams {
+    keyId: string;
+}
+interface GetKmsKeyResponse {
+    key: KmsKey;
+}
+interface ListKmsKeysParams {
+    projectId: string;
+    offset?: number;
+    limit?: number;
+}
+interface ListKmsKeysResponse {
+    keys: KmsKey[];
+    totalCount: number;
+}
+interface KmsEncryptParams {
+    keyId: string;
+    plaintext: string;
+}
+interface KmsEncryptResponse {
+    ciphertext: string;
+}
+interface KmsDecryptParams {
+    keyId: string;
+    ciphertext: string;
+}
+interface KmsDecryptResponse {
+    plaintext: string;
+}
+interface GetKmsKeyByNameParams {
+    keyName: string;
+    projectId: string;
+}
+interface GetKmsKeyByNameResponse {
+    key: KmsKey;
+}
+interface GetKmsPublicKeyParams {
+    keyId: string;
+}
+interface GetKmsPublicKeyResponse {
+    publicKey: string;
+}
+interface GetKmsPrivateKeyParams {
+    keyId: string;
+}
+interface GetKmsPrivateKeyResponse {
+    privateKey: string;
+}
+interface ListKmsSigningAlgorithmsParams {
+    keyId: string;
+}
+interface ListKmsSigningAlgorithmsResponse {
+    signingAlgorithms: string[];
+}
+interface KmsSignParams {
+    keyId: string;
+    signingAlgorithm: string;
+    data: string;
+    isDigest?: boolean;
+}
+interface KmsSignResponse {
+    signature: string;
+    keyId: string;
+    signingAlgorithm: string;
+}
+interface KmsVerifyParams {
+    keyId: string;
+    data: string;
+    signature: string;
+    signingAlgorithm: string;
+    isDigest?: boolean;
+}
+interface KmsVerifyResponse {
+    signatureValid: boolean;
+    keyId: string;
+    signingAlgorithm: string;
+}
+
+declare class KmsResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    createKey(params: CreateKmsKeyParams): Promise<CreateKmsKeyResponse>;
+    updateKey(params: UpdateKmsKeyParams): Promise<UpdateKmsKeyResponse>;
+    deleteKey(params: DeleteKmsKeyParams): Promise<DeleteKmsKeyResponse>;
+    getKey(params: GetKmsKeyParams): Promise<GetKmsKeyResponse>;
+    listKeys(params: ListKmsKeysParams): Promise<ListKmsKeysResponse>;
+    encrypt(params: KmsEncryptParams): Promise<KmsEncryptResponse>;
+    decrypt(params: KmsDecryptParams): Promise<KmsDecryptResponse>;
+    getKeyByName(params: GetKmsKeyByNameParams): Promise<GetKmsKeyByNameResponse>;
+    getPublicKey(params: GetKmsPublicKeyParams): Promise<GetKmsPublicKeyResponse>;
+    getPrivateKey(params: GetKmsPrivateKeyParams): Promise<GetKmsPrivateKeyResponse>;
+    listSigningAlgorithms(params: ListKmsSigningAlgorithmsParams): Promise<ListKmsSigningAlgorithmsResponse>;
+    sign(params: KmsSignParams): Promise<KmsSignResponse>;
+    verify(params: KmsVerifyParams): Promise<KmsVerifyResponse>;
+}
+
+interface IntegrationAuth {
+    id: string;
+    projectId: string;
+    integration: string;
+    teamId?: string | null;
+    accountId?: string | null;
+    url?: string | null;
+    namespace?: string | null;
+    metadata?: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateIntegrationAuthParams {
+    projectId: string;
+    integration: string;
+    accessId?: string;
+    accessToken?: string;
+    url?: string;
+    namespace?: string;
+    refreshToken?: string;
+}
+interface CreateIntegrationAuthResponse {
+    integrationAuth: IntegrationAuth;
+}
+interface GetIntegrationAuthParams {
+    integrationAuthId: string;
+}
+interface GetIntegrationAuthResponse {
+    integrationAuth: IntegrationAuth;
+}
+interface DeleteIntegrationAuthParams {
+    integrationAuthId: string;
+}
+interface DeleteIntegrationAuthResponse {
+    integrationAuth: IntegrationAuth;
+}
+interface ListIntegrationAuthParams {
+    projectId: string;
+}
+interface ListIntegrationAuthResponse {
+    integrationAuths: IntegrationAuth[];
+}
+
+declare class IntegrationAuthResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    create(params: CreateIntegrationAuthParams): Promise<CreateIntegrationAuthResponse>;
+    get(params: GetIntegrationAuthParams): Promise<GetIntegrationAuthResponse>;
+    delete(params: DeleteIntegrationAuthParams): Promise<DeleteIntegrationAuthResponse>;
+    list(params: ListIntegrationAuthParams): Promise<ListIntegrationAuthResponse>;
+}
+
+interface AppConnection {
+    id: string;
+    name: string;
+    description?: string | null;
+    app: string;
+    orgId: string;
+    method: string;
+    credentials: Record<string, unknown>;
+    isPlatformManaged: boolean;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateAppConnectionParams {
+    app: string;
+    name: string;
+    description?: string;
+    method: string;
+    credentials: Record<string, unknown>;
+}
+interface CreateAppConnectionResponse {
+    appConnection: AppConnection;
+}
+interface UpdateAppConnectionParams {
+    app: string;
+    connectionId: string;
+    name?: string;
+    description?: string;
+    credentials?: Record<string, unknown>;
+}
+interface UpdateAppConnectionResponse {
+    appConnection: AppConnection;
+}
+interface DeleteAppConnectionParams {
+    app: string;
+    connectionId: string;
+}
+interface DeleteAppConnectionResponse {
+    appConnection: AppConnection;
+}
+interface GetAppConnectionParams {
+    app: string;
+    connectionId: string;
+}
+interface GetAppConnectionResponse {
+    appConnection: AppConnection;
+}
+interface ListAppConnectionsParams {
+    app: string;
+}
+interface ListAppConnectionsResponse {
+    appConnections: AppConnection[];
+}
+interface GetAppConnectionByNameParams {
+    app: string;
+    connectionName: string;
+}
+interface GetAppConnectionByNameResponse {
+    appConnection: AppConnection;
+}
+interface CheckAppConnectionAvailabilityParams {
+    app: string;
+}
+interface CheckAppConnectionAvailabilityResponse {
+    available: boolean;
+}
+interface ListAllAppConnectionsResponse {
+    appConnections: AppConnection[];
+}
+
+declare class AppConnectionsResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    create(params: CreateAppConnectionParams): Promise<CreateAppConnectionResponse>;
+    update(params: UpdateAppConnectionParams): Promise<UpdateAppConnectionResponse>;
+    delete(params: DeleteAppConnectionParams): Promise<DeleteAppConnectionResponse>;
+    get(params: GetAppConnectionParams): Promise<GetAppConnectionResponse>;
+    list(params: ListAppConnectionsParams): Promise<ListAppConnectionsResponse>;
+    getByName(params: GetAppConnectionByNameParams): Promise<GetAppConnectionByNameResponse>;
+    checkAvailability(params: CheckAppConnectionAvailabilityParams): Promise<CheckAppConnectionAvailabilityResponse>;
+    listAll(): Promise<ListAllAppConnectionsResponse>;
+}
+
+interface SecretSync {
+    id: string;
+    name: string;
+    description?: string | null;
+    destination: string;
+    projectId: string;
+    sourceEnvironment: string;
+    sourceSecretPath: string;
+    connectionId: string;
+    destinationConfig: Record<string, unknown>;
+    syncOptions: Record<string, unknown>;
+    isAutoSyncEnabled: boolean;
+    lastSyncedAt?: string | null;
+    syncStatus?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateSecretSyncParams {
+    destination: string;
+    name: string;
+    description?: string;
+    projectId: string;
+    sourceEnvironment: string;
+    sourceSecretPath: string;
+    connectionId: string;
+    destinationConfig: Record<string, unknown>;
+    syncOptions?: Record<string, unknown>;
+    isAutoSyncEnabled?: boolean;
+}
+interface CreateSecretSyncResponse {
+    secretSync: SecretSync;
+}
+interface UpdateSecretSyncParams {
+    destination: string;
+    syncId: string;
+    name?: string;
+    description?: string;
+    connectionId?: string;
+    sourceEnvironment?: string;
+    sourceSecretPath?: string;
+    destinationConfig?: Record<string, unknown>;
+    syncOptions?: Record<string, unknown>;
+    isAutoSyncEnabled?: boolean;
+}
+interface UpdateSecretSyncResponse {
+    secretSync: SecretSync;
+}
+interface DeleteSecretSyncParams {
+    destination: string;
+    syncId: string;
+    removeSecrets?: boolean;
+}
+interface DeleteSecretSyncResponse {
+    secretSync: SecretSync;
+}
+interface GetSecretSyncParams {
+    destination: string;
+    syncId: string;
+}
+interface GetSecretSyncResponse {
+    secretSync: SecretSync;
+}
+interface ListSecretSyncsParams {
+    destination: string;
+    projectId: string;
+}
+interface ListSecretSyncsResponse {
+    secretSyncs: SecretSync[];
+}
+interface TriggerSecretSyncParams {
+    destination: string;
+    syncId: string;
+}
+interface TriggerSecretSyncResponse {
+    secretSync: SecretSync;
+}
+interface ImportSecretSyncParams {
+    destination: string;
+    syncId: string;
+}
+interface ImportSecretSyncResponse {
+    secretSync: SecretSync;
+}
+interface RemoveSecretSyncSecretsParams {
+    destination: string;
+    syncId: string;
+}
+interface RemoveSecretSyncSecretsResponse {
+    secretSync: SecretSync;
+}
+interface GetSecretSyncByNameParams {
+    destination: string;
+    syncName: string;
+}
+interface GetSecretSyncByNameResponse {
+    secretSync: SecretSync;
+}
+
+declare class SecretSyncsResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    create(params: CreateSecretSyncParams): Promise<CreateSecretSyncResponse>;
+    update(params: UpdateSecretSyncParams): Promise<UpdateSecretSyncResponse>;
+    delete(params: DeleteSecretSyncParams): Promise<DeleteSecretSyncResponse>;
+    get(params: GetSecretSyncParams): Promise<GetSecretSyncResponse>;
+    list(params: ListSecretSyncsParams): Promise<ListSecretSyncsResponse>;
+    trigger(params: TriggerSecretSyncParams): Promise<TriggerSecretSyncResponse>;
+    importSecrets(params: ImportSecretSyncParams): Promise<ImportSecretSyncResponse>;
+    removeSecrets(params: RemoveSecretSyncSecretsParams): Promise<RemoveSecretSyncSecretsResponse>;
+    getByName(params: GetSecretSyncByNameParams): Promise<GetSecretSyncByNameResponse>;
+}
+
+interface SuperAdminConfig {
+    id?: string;
+    initialized: boolean;
+    allowSignUp: boolean;
+    defaultAuthOrgId?: string | null;
+    defaultAuthOrgSlug?: string | null;
+    enabledLoginMethods?: string[];
+    trustSamlEmails?: boolean;
+    trustLdapEmails?: boolean;
+    trustOidcEmails?: boolean;
+    isSecretScanningDisabled?: boolean;
+    instancerId?: string | null;
+    projectLimit?: number;
+    [key: string]: unknown;
+}
+interface BootstrapInstanceParams {
+    email: string;
+    password: string;
+    organization: string;
+}
+interface BootstrapInstanceResponse {
+    message: string;
+    user: Record<string, unknown>;
+    organization: Record<string, unknown>;
+    identity: {
+        credentials: {
+            token: string;
+        };
+    };
+}
+interface AdminSignUpParams {
+    email: string;
+    password: string;
+    firstName: string;
+    lastName?: string;
+}
+interface AdminSignUpResponse {
+    message: string;
+    user: Record<string, unknown>;
+    organization: Record<string, unknown>;
+    token: string;
+    new: boolean;
+}
+interface GetAdminConfigResponse {
+    config: SuperAdminConfig;
+}
+interface UpdateAdminConfigParams {
+    allowSignUp?: boolean;
+    defaultAuthOrgId?: string | null;
+    enabledLoginMethods?: string[];
+    trustSamlEmails?: boolean;
+    trustLdapEmails?: boolean;
+    trustOidcEmails?: boolean;
+    isSecretScanningDisabled?: boolean;
+    projectLimit?: number;
+    [key: string]: unknown;
+}
+interface UpdateAdminConfigResponse {
+    config: SuperAdminConfig;
+}
+interface ListAdminUsersParams {
+    searchTerm?: string;
+    offset?: number;
+    limit?: number;
+}
+interface ListAdminUsersResponse {
+    users: Record<string, unknown>[];
+    totalCount: number;
+}
+interface DeleteAdminUserParams {
+    userId: string;
+}
+interface DeleteAdminUserResponse {
+    user: Record<string, unknown>;
+}
+interface DeleteAdminUsersParams {
+    userIds: string[];
+}
+interface DeleteAdminUsersResponse {
+    users: Record<string, unknown>[];
+}
+interface GrantAdminAccessParams {
+    userId: string;
+}
+interface GrantAdminAccessResponse {
+    user: Record<string, unknown>;
+}
+interface RevokeAdminAccessParams {
+    userId: string;
+}
+interface RevokeAdminAccessResponse {
+    user: Record<string, unknown>;
+}
+interface ListAdminOrganizationsParams {
+    searchTerm?: string;
+    offset?: number;
+    limit?: number;
+}
+interface ListAdminOrganizationsResponse {
+    organizations: Record<string, unknown>[];
+    totalCount: number;
+}
+interface CreateAdminOrganizationParams {
+    name: string;
+    inviteAdminEmails: string[];
+}
+interface CreateAdminOrganizationResponse {
+    organization: Record<string, unknown>;
+}
+interface DeleteAdminOrganizationParams {
+    organizationId: string;
+}
+interface DeleteAdminOrganizationResponse {
+    organization: Record<string, unknown>;
+}
+interface DeleteAdminOrgMembershipParams {
+    organizationId: string;
+    membershipId: string;
+}
+interface DeleteAdminOrgMembershipResponse {
+    membership: Record<string, unknown>;
+}
+interface ResendOrgInviteParams {
+    organizationId: string;
+    membershipId: string;
+}
+interface ResendOrgInviteResponse {
+    membership: Record<string, unknown>;
+}
+interface JoinOrganizationParams {
+    organizationId: string;
+}
+interface JoinOrganizationResponse {
+    membership: Record<string, unknown>;
+}
+interface ListAdminIdentitiesParams {
+    searchTerm?: string;
+    offset?: number;
+    limit?: number;
+}
+interface ListAdminIdentitiesResponse {
+    identities: Record<string, unknown>[];
+    totalCount: number;
+}
+interface GrantIdentitySuperAdminParams {
+    identityId: string;
+}
+interface GrantIdentitySuperAdminResponse {
+    identity: Record<string, unknown>;
+}
+interface RevokeIdentitySuperAdminParams {
+    identityId: string;
+}
+interface RevokeIdentitySuperAdminResponse {
+    identity: Record<string, unknown>;
+}
+interface GetAdminIntegrationsResponse {
+    slack: Record<string, unknown>;
+    microsoftTeams: Record<string, unknown>;
+    githubAppConnection: Record<string, unknown>;
+}
+interface GetEncryptionStrategiesResponse {
+    strategies: Array<{
+        strategy: string;
+        enabled: boolean;
+    }>;
+}
+interface UpdateEncryptionStrategyParams {
+    strategy: string;
+}
+interface UpdateEncryptionStrategyResponse {
+    strategies: Array<{
+        strategy: string;
+        enabled: boolean;
+    }>;
+}
+interface GetEnvOverridesResponse {
+    overrides: Record<string, unknown>;
+}
+interface InvalidateCacheParams {
+    type: "all" | "secrets";
+}
+interface InvalidateCacheResponse {
+    message: string;
+}
+interface GetCacheStatusResponse {
+    invalidating: boolean;
+}
+interface GenerateUsageReportResponse {
+    csvContent: string;
+    signature: string;
+    filename: string;
+}
+
+declare class AdminResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    bootstrap(params: BootstrapInstanceParams): Promise<BootstrapInstanceResponse>;
+    signup(params: AdminSignUpParams): Promise<AdminSignUpResponse>;
+    getConfig(): Promise<GetAdminConfigResponse>;
+    updateConfig(params: UpdateAdminConfigParams): Promise<UpdateAdminConfigResponse>;
+    listUsers(params?: ListAdminUsersParams): Promise<ListAdminUsersResponse>;
+    deleteUser(params: DeleteAdminUserParams): Promise<DeleteAdminUserResponse>;
+    deleteUsers(params: DeleteAdminUsersParams): Promise<DeleteAdminUsersResponse>;
+    grantAdminAccess(params: GrantAdminAccessParams): Promise<GrantAdminAccessResponse>;
+    revokeAdminAccess(params: RevokeAdminAccessParams): Promise<RevokeAdminAccessResponse>;
+    listOrganizations(params?: ListAdminOrganizationsParams): Promise<ListAdminOrganizationsResponse>;
+    createOrganization(params: CreateAdminOrganizationParams): Promise<CreateAdminOrganizationResponse>;
+    deleteOrganization(params: DeleteAdminOrganizationParams): Promise<DeleteAdminOrganizationResponse>;
+    deleteOrgMembership(params: DeleteAdminOrgMembershipParams): Promise<DeleteAdminOrgMembershipResponse>;
+    resendOrgInvite(params: ResendOrgInviteParams): Promise<ResendOrgInviteResponse>;
+    joinOrganization(params: JoinOrganizationParams): Promise<JoinOrganizationResponse>;
+    listIdentities(params?: ListAdminIdentitiesParams): Promise<ListAdminIdentitiesResponse>;
+    grantIdentitySuperAdmin(params: GrantIdentitySuperAdminParams): Promise<GrantIdentitySuperAdminResponse>;
+    revokeIdentitySuperAdmin(params: RevokeIdentitySuperAdminParams): Promise<RevokeIdentitySuperAdminResponse>;
+    getIntegrations(): Promise<GetAdminIntegrationsResponse>;
+    getEncryptionStrategies(): Promise<GetEncryptionStrategiesResponse>;
+    updateEncryptionStrategy(params: UpdateEncryptionStrategyParams): Promise<UpdateEncryptionStrategyResponse>;
+    getEnvOverrides(): Promise<GetEnvOverridesResponse>;
+    invalidateCache(params: InvalidateCacheParams): Promise<InvalidateCacheResponse>;
+    getCacheStatus(): Promise<GetCacheStatusResponse>;
+    generateUsageReport(): Promise<GenerateUsageReportResponse>;
+}
+
+interface ListOrgAdminProjectsParams {
+    search?: string;
+    offset?: number;
+    limit?: number;
+}
+interface ListOrgAdminProjectsResponse {
+    projects: Record<string, unknown>[];
+    count: number;
+}
+interface GrantOrgAdminProjectAccessParams {
+    projectId: string;
+}
+interface GrantOrgAdminProjectAccessResponse {
+    membership: Record<string, unknown>;
+}
+
+declare class OrgAdminResource extends BaseResource {
+    constructor(http: HttpClient, authState: AuthState);
+    listProjects(params?: ListOrgAdminProjectsParams): Promise<ListOrgAdminProjectsResponse>;
+    grantProjectAccess(params: GrantOrgAdminProjectAccessParams): Promise<GrantOrgAdminProjectAccessResponse>;
+}
+
+interface InfisicalClientConfig {
+    baseUrl?: string;
+    fetch?: FetchFunction;
+    timeout?: number;
+    headers?: Record<string, string>;
+}
+declare class InfisicalClient {
+    readonly mfa: MfaResource;
+    readonly mfaSessions: MfaSessionsResource;
+    readonly users: UsersResource;
+    readonly password: PasswordResource;
+    readonly serviceTokens: ServiceTokensResource;
+    readonly organizations: OrganizationsResource;
+    readonly organizationIdentities: OrganizationIdentitiesResource;
+    readonly secretFolders: SecretFoldersResource;
+    readonly secretImports: SecretImportsResource;
+    readonly pki: {
+        readonly ca: PkiCaResource;
+        readonly templates: PkiTemplatesResource;
+        readonly alerts: PkiAlertsResource;
+        readonly certificates: PkiCertificatesResource;
+    };
+    readonly secretTags: SecretTagsResource;
+    readonly identities: IdentitiesResource;
+    readonly identityAccessTokens: IdentityAccessTokensResource;
+    readonly identityAuth: {
+        readonly universal: IdentityUniversalAuthResource;
+        readonly token: IdentityTokenAuthResource;
+        readonly aws: IdentityAwsAuthResource;
+        readonly gcp: IdentityGcpAuthResource;
+        readonly azure: IdentityAzureAuthResource;
+        readonly kubernetes: IdentityKubernetesAuthResource;
+        readonly oidc: IdentityOidcAuthResource;
+        readonly jwt: IdentityJwtAuthResource;
+        readonly ldap: IdentityLdapAuthResource;
+        readonly tlsCert: IdentityTlsCertAuthResource;
+        readonly oci: IdentityOciAuthResource;
+        readonly alicloud: IdentityAlicloudAuthResource;
+    };
+    readonly projects: ProjectsResource;
+    readonly webhooks: WebhooksResource;
+    readonly secretSharing: SecretSharingResource;
+    readonly secrets: SecretsResource;
+    readonly kms: KmsResource;
+    readonly integrationAuth: IntegrationAuthResource;
+    readonly appConnections: AppConnectionsResource;
+    readonly secretSyncs: SecretSyncsResource;
+    readonly admin: AdminResource;
+    readonly orgAdmin: OrgAdminResource;
+    private readonly _authState;
+    private readonly _authManager;
+    constructor(config?: InfisicalClientConfig);
+    login(params: LoginParamsOrFactory): Promise<LoginResponse>;
+    /**
+     * Set a pre-existing identity access token directly (e.g., from external auth).
+     * This bypasses the login flow and sets the token directly on the auth state.
+     */
+    setAccessToken(accessToken: string, expiresIn?: number, renewFn?: () => Promise<{
+        accessToken: string;
+        expiresIn: number;
+    }>): void;
+    /**
+     * Set a pre-existing JWT token directly (e.g., from bootstrap or user login).
+     * Use this for admin operations that require JWT auth mode.
+     */
+    setJwtToken(token: string, expiresIn?: number, renewFn?: () => Promise<{
+        token: string;
+        expiresIn: number;
+    }>): void;
+    get isAuthenticated(): boolean;
+    get authMode(): AuthMode | null;
+    logout(): void;
+}
+
+declare class InfisicalApiError extends Error {
+    readonly statusCode: number;
+    readonly requestId?: string;
+    readonly errorType?: string;
+    readonly details?: unknown;
+    constructor(message: string, options: {
+        statusCode: number;
+        requestId?: string;
+        errorType?: string;
+        details?: unknown;
+    });
+}
+type ApiErrorOptions = Omit<ConstructorParameters<typeof InfisicalApiError>[1], "statusCode">;
+declare class BadRequestError extends InfisicalApiError {
+    constructor(message: string, options?: ApiErrorOptions);
+}
+declare class UnauthorizedError extends InfisicalApiError {
+    constructor(message: string, options?: ApiErrorOptions);
+}
+declare class ForbiddenError extends InfisicalApiError {
+    constructor(message: string, options?: ApiErrorOptions);
+}
+declare class NotFoundError extends InfisicalApiError {
+    constructor(message: string, options?: ApiErrorOptions);
+}
+declare class ValidationError extends InfisicalApiError {
+    constructor(message: string, options?: ApiErrorOptions);
+}
+declare class RateLimitError extends InfisicalApiError {
+    constructor(message: string, options?: ApiErrorOptions);
+}
+declare class InternalServerError extends InfisicalApiError {
+    constructor(message: string, options?: ApiErrorOptions);
+}
+declare class AuthenticationError extends Error {
+    readonly currentMode: string | null;
+    readonly allowedModes: readonly string[];
+    constructor(message: string, options: {
+        currentMode: string | null;
+        allowedModes: readonly string[];
+    });
+}
+declare class InfisicalNetworkError extends Error {
+    readonly cause?: Error;
+    constructor(message: string, options?: {
+        cause?: Error;
+    });
+}
+
+export { AdminResource, type AdminSignUpParams, type AdminSignUpResponse, type ApiKey, type AppConnection, AppConnectionsResource, type AttachAlicloudAuthParams, type AttachAlicloudAuthResponse, type AttachAwsAuthParams, type AttachAwsAuthResponse, type AttachAzureAuthParams, type AttachAzureAuthResponse, type AttachGcpAuthParams, type AttachGcpAuthResponse, type AttachJwtAuthParams, type AttachJwtAuthResponse, type AttachKubernetesAuthParams, type AttachKubernetesAuthResponse, type AttachLdapAuthParams, type AttachLdapAuthResponse, type AttachOciAuthParams, type AttachOciAuthResponse, type AttachOidcAuthParams, type AttachOidcAuthResponse, type AttachTlsCertAuthParams, type AttachTlsCertAuthResponse, type AttachTokenAuthParams, type AttachTokenAuthResponse, type AttachUniversalAuthParams, type AttachUniversalAuthResponse, type AuthConfig, AuthManager, AuthMethod, type AuthMode, AuthState, type AuthTokenSession, AuthenticationError, BadRequestError, type BatchCreateSecretsParams, type BatchCreateSecretsResponse, type BatchDeleteSecretsParams, type BatchDeleteSecretsResponse, type BatchUpdateSecretsParams, type BatchUpdateSecretsResponse, type BootstrapInstanceParams, type BootstrapInstanceResponse, type BulkDeleteMembershipsParams, type BulkDeleteMembershipsResponse, type CaCertificateEntry, type CaCrlEntry, CaType, CertExtendedKeyUsage, CertKeyUsage, type Certificate, type CertificateAuthority, type CertificateTemplate, type CertificateTemplateWithCa, type CheckAppConnectionAvailabilityParams, type CheckAppConnectionAvailabilityResponse, type CheckTotpResponse, type CheckWebAuthnResponse, type CreateAdminOrganizationParams, type CreateAdminOrganizationResponse, type CreateApiKeyParams, type CreateApiKeyResponse, type CreateAppConnectionParams, type CreateAppConnectionResponse, type CreateCaParams, type CreateCaResponse, type CreateCertificateParams, type CreateCertificateResponse, type CreateIdentityParams, type CreateIdentityResponse, type CreateIntegrationAuthParams, type CreateIntegrationAuthResponse, type CreateKmsKeyParams, type CreateKmsKeyResponse, type CreateOrganizationParams, type CreateOrganizationResponse, type CreatePkiAlertParams, type CreatePkiAlertResponse, type CreatePkiTemplateParams, type CreatePkiTemplateResponse, type CreateProjectEnvironmentParams, type CreateProjectEnvironmentResponse, type CreateProjectParams, type CreateProjectResponse, type CreateSecretFolderParams, type CreateSecretFolderResponse, type CreateSecretImportParams, type CreateSecretImportResponse, type CreateSecretParams, type CreateSecretResponse, type CreateSecretSyncParams, type CreateSecretSyncResponse, type CreateSecretTagParams, type CreateSecretTagResponse, type CreateServiceTokenParams, type CreateServiceTokenResponse, type CreateSharedSecretParams, type CreateSharedSecretResponse, type CreateTokenAuthTokenParams, type CreateTokenAuthTokenResponse, type CreateUniversalAuthClientSecretParams, type CreateUniversalAuthClientSecretResponse, type CreateWebhookParams, type CreateWebhookResponse, type DeleteAdminOrgMembershipParams, type DeleteAdminOrgMembershipResponse, type DeleteAdminOrganizationParams, type DeleteAdminOrganizationResponse, type DeleteAdminUserParams, type DeleteAdminUserResponse, type DeleteAdminUsersParams, type DeleteAdminUsersResponse, type DeleteApiKeyResponse, type DeleteAppConnectionParams, type DeleteAppConnectionResponse, type DeleteCaParams, type DeleteCaResponse, type DeleteCertificateParams, type DeleteCertificateResponse, type DeleteIdentityParams, type DeleteIdentityResponse, type DeleteIntegrationAuthParams, type DeleteIntegrationAuthResponse, type DeleteKmsKeyParams, type DeleteKmsKeyResponse, type DeleteMeResponse, type DeleteMembershipParams, type DeleteMembershipResponse, type DeleteOrganizationParams, type DeleteOrganizationResponse, type DeletePkiAlertParams, type DeletePkiAlertResponse, type DeletePkiTemplateParams, type DeletePkiTemplateResponse, type DeleteProjectEnvironmentParams, type DeleteProjectEnvironmentResponse, type DeleteProjectParams, type DeleteProjectResponse, type DeleteSecretFolderParams, type DeleteSecretFolderResponse, type DeleteSecretImportParams, type DeleteSecretImportResponse, type DeleteSecretParams, type DeleteSecretResponse, type DeleteSecretSyncParams, type DeleteSecretSyncResponse, type DeleteSecretTagParams, type DeleteSecretTagResponse, type DeleteServiceTokenResponse, type DeleteSharedSecretParams, type DeleteSharedSecretResponse, type DeleteWebhookParams, type DeleteWebhookResponse, type DetailedOrgMembership, type FetchFunction, ForbiddenError, type GenerateUsageReportResponse, type GetAdminConfigResponse, type GetAdminIntegrationsResponse, type GetAlicloudAuthParams, type GetAlicloudAuthResponse, type GetAppConnectionByNameParams, type GetAppConnectionByNameResponse, type GetAppConnectionParams, type GetAppConnectionResponse, type GetAwsAuthParams, type GetAwsAuthResponse, type GetAzureAuthParams, type GetAzureAuthResponse, type GetCaCertificateParams, type GetCaCertificateResponse, type GetCaCrlsParams, type GetCaCrlsResponse, type GetCaCsrParams, type GetCaCsrResponse, type GetCaParams, type GetCaResponse, type GetCacheStatusResponse, type GetCertificateBodyParams, type GetCertificateBodyResponse, type GetCertificateBundleParams, type GetCertificateBundleResponse, type GetCertificateParams, type GetCertificatePrivateKeyParams, type GetCertificatePrivateKeyResponse, type GetCertificateResponse, type GetEncryptionStrategiesResponse, type GetEnvOverridesResponse, type GetGcpAuthParams, type GetGcpAuthResponse, type GetIdentityParams, type GetIdentityResponse, type GetIntegrationAuthParams, type GetIntegrationAuthResponse, type GetJwtAuthParams, type GetJwtAuthResponse, type GetKmsKeyByNameParams, type GetKmsKeyByNameResponse, type GetKmsKeyParams, type GetKmsKeyResponse, type GetKmsPrivateKeyParams, type GetKmsPrivateKeyResponse, type GetKmsPublicKeyParams, type GetKmsPublicKeyResponse, type GetKubernetesAuthParams, type GetKubernetesAuthResponse, type GetLdapAuthParams, type GetLdapAuthResponse, type GetMeResponse, type GetMembershipParams, type GetMembershipResponse, type GetMfaSessionStatusParams, type GetMfaSessionStatusResponse, type GetOciAuthParams, type GetOciAuthResponse, type GetOidcAuthParams, type GetOidcAuthResponse, type GetPkiAlertParams, type GetPkiAlertResponse, type GetPkiTemplateParams, type GetPkiTemplateResponse, type GetProjectBySlugParams, type GetProjectBySlugResponse, type GetProjectParams, type GetProjectResponse, type GetRawSecretsFromImportsParams, type GetRawSecretsFromImportsResponse, type GetSecretAccessListParams, type GetSecretAccessListResponse, type GetSecretByIdParams, type GetSecretByIdResponse, type GetSecretByNameParams, type GetSecretByNameResponse, type GetSecretFolderByIdParams, type GetSecretFolderByIdResponse, type GetSecretImportParams, type GetSecretImportResponse, type GetSecretSyncByNameParams, type GetSecretSyncByNameResponse, type GetSecretSyncParams, type GetSecretSyncResponse, type GetSecretTagByIdParams, type GetSecretTagByIdResponse, type GetSecretTagBySlugParams, type GetSecretTagBySlugResponse, type GetServiceTokenResponse, type GetSharedSecretParams, type GetSharedSecretResponse, type GetTlsCertAuthParams, type GetTlsCertAuthResponse, type GetTokenAuthParams, type GetTokenAuthResponse, type GetTokenAuthTokenParams, type GetTokenAuthTokenResponse, type GetUniversalAuthClientSecretParams, type GetUniversalAuthClientSecretResponse, type GetUniversalAuthParams, type GetUniversalAuthResponse, type GrantAdminAccessParams, type GrantAdminAccessResponse, type GrantIdentitySuperAdminParams, type GrantIdentitySuperAdminResponse, type GrantOrgAdminProjectAccessParams, type GrantOrgAdminProjectAccessResponse, HttpClient, type HttpClientConfig, IdentitiesResource, type Identity, IdentityAccessTokensResource, type IdentityAlicloudAuth, IdentityAlicloudAuthResource, type IdentityAuthResources, type IdentityAwsAuth, IdentityAwsAuthResource, type IdentityAzureAuth, IdentityAzureAuthResource, type IdentityGcpAuth, IdentityGcpAuthResource, type IdentityJwtAuth, IdentityJwtAuthResource, type IdentityKubernetesAuth, IdentityKubernetesAuthResource, type IdentityLdapAuth, IdentityLdapAuthResource, type IdentityOciAuth, IdentityOciAuthResource, type IdentityOidcAuth, IdentityOidcAuthResource, type IdentityOrgMembership, type IdentityProjectMembership, type IdentityTlsCertAuth, IdentityTlsCertAuthResource, type IdentityTokenAuth, IdentityTokenAuthResource, type IdentityTokenAuthToken, type IdentityUniversalAuth, IdentityUniversalAuthResource, type IdentityWithMetadata, type ImportSecretSyncParams, type ImportSecretSyncResponse, type ImportedSecretGroup, InfisicalApiError, InfisicalClient, type InfisicalClientConfig, InfisicalNetworkError, type IntegrationAuth, IntegrationAuthResource, InternalServerError, type InvalidateCacheParams, type InvalidateCacheResponse, type IssueCertificateParams, type IssueCertificateResponse, type JoinOrganizationParams, type JoinOrganizationResponse, JwtSignatureAlgorithm, type KmsDecryptParams, type KmsDecryptResponse, type KmsEncryptParams, type KmsEncryptResponse, type KmsKey, KmsResource, type KmsSignParams, type KmsSignResponse, type KmsVerifyParams, type KmsVerifyResponse, type ListAdminIdentitiesParams, type ListAdminIdentitiesResponse, type ListAdminOrganizationsParams, type ListAdminOrganizationsResponse, type ListAdminUsersParams, type ListAdminUsersResponse, type ListAllAppConnectionsResponse, type ListAppConnectionsParams, type ListAppConnectionsResponse, type ListCaCertificatesParams, type ListCaCertificatesResponse, type ListCertificateAuthoritiesParams, type ListCertificateAuthoritiesResponse, type ListIdentityMembershipsParams, type ListIdentityMembershipsResponse, type ListIdentityProjectMembershipsParams, type ListIdentityProjectMembershipsResponse, type ListIntegrationAuthParams, type ListIntegrationAuthResponse, type ListKmsKeysParams, type ListKmsKeysResponse, type ListKmsSigningAlgorithmsParams, type ListKmsSigningAlgorithmsResponse, type ListMembershipsParams, type ListMembershipsResponse, type ListOrgAdminProjectsParams, type ListOrgAdminProjectsResponse, type ListOrgProjectsParams, type ListOrgProjectsResponse, type ListOrganizationsResponse, type ListPkiAlertCertificatesParams, type ListPkiAlertCertificatesResponse, type ListPkiAlertsParams, type ListPkiAlertsResponse, type ListPkiTemplatesParams, type ListPkiTemplatesResponse, type ListProjectEnvironmentsParams, type ListProjectEnvironmentsResponse, type ListProjectMembershipsByOrgMembershipParams, type ListProjectMembershipsByOrgMembershipResponse, type ListProjectMembershipsParams, type ListProjectMembershipsResponse, type ListProjectRolesParams, type ListProjectRolesResponse, type ListProjectTagsParams, type ListProjectTagsResponse, type ListProjectsParams, type ListProjectsResponse, type ListSecretFoldersParams, type ListSecretFoldersResponse, type ListSecretImportsParams, type ListSecretImportsResponse, type ListSecretSyncsParams, type ListSecretSyncsResponse, type ListSecretTagsParams, type ListSecretTagsResponse, type ListSecretsParams, type ListSecretsResponse, type ListSharedSecretsResponse, type ListTokenAuthTokensParams, type ListTokenAuthTokensResponse, type ListUniversalAuthClientSecretsParams, type ListUniversalAuthClientSecretsResponse, type ListWebhooksParams, type ListWebhooksResponse, type LoginAlicloudAuthParams, type LoginAlicloudAuthResponse, type LoginAwsAuthParams, type LoginAwsAuthResponse, type LoginAzureAuthParams, type LoginAzureAuthResponse, type LoginGcpAuthParams, type LoginGcpAuthResponse, type LoginJwtAuthParams, type LoginJwtAuthResponse, type LoginKubernetesAuthParams, type LoginKubernetesAuthResponse, type LoginLdapAuthParams, type LoginLdapAuthResponse, type LoginOciAuthParams, type LoginOciAuthResponse, type LoginOidcAuthParams, type LoginOidcAuthResponse, type LoginParams, type LoginParamsOrFactory, type LoginResponse, type LoginTlsCertAuthParams, type LoginTlsCertAuthResponse, type LoginTokenAuthParams, type LoginTokenAuthResponse, type LoginUniversalAuthParams, type LoginUniversalAuthResponse, MfaMethod, MfaResource, MfaSessionStatus, MfaSessionsResource, type MoveSecretsParams, type MoveSecretsResponse, NotFoundError, OrderByDirection, OrgAdminResource, OrgIdentityOrderBy, type OrgInfo, type OrgMembership, type OrgMembershipMetadata, OrgMembershipStatus, type OrgMembershipUser, type OrgMembershipWithUser, type OrgProject, type Organization, OrganizationIdentitiesResource, OrganizationsResource, PasswordResource, type PkiAlert, type PkiAlertCertificate, type PkiAlertChannel, PkiAlertChannelType, PkiAlertEventType, PkiAlertsResource, PkiCaResource, PkiCertificatesResource, type PkiFilterRule, PkiTemplatesResource, type PreviewPkiAlertCertificatesParams, type PreviewPkiAlertCertificatesResponse, type Project, type ProjectMembership, type ProjectMembershipEntry, type ProjectMembershipRole, type ProjectRole, type ProjectTag, ProjectsResource, RESOURCE_AUTH_MODES, RateLimitError, type RawSecret, type RemoveSecretSyncSecretsParams, type RemoveSecretSyncSecretsResponse, type RenewAccessTokenParams, type RenewAccessTokenResponse, type RenewCaParams, type RenewCaResponse, type RenewCertificateParams, type RenewCertificateResponse, type RenewResult, type RequestEmailChangeOtpParams, type RequestEmailChangeOtpResponse, type ResendMfaTokenResponse, type ResendOrgInviteParams, type ResendOrgInviteResponse, type ResetPasswordAuthenticatedParams, type ResetPasswordParams, type ResourceCategory, type ResyncReplicationParams, type ResyncReplicationResponse, type RevokeAccessTokenParams, type RevokeAccessTokenResponse, type RevokeAdminAccessParams, type RevokeAdminAccessResponse, type RevokeAlicloudAuthParams, type RevokeAlicloudAuthResponse, type RevokeAllSessionsResponse, type RevokeAwsAuthParams, type RevokeAwsAuthResponse, type RevokeAzureAuthParams, type RevokeAzureAuthResponse, type RevokeCertificateParams, type RevokeCertificateResponse, type RevokeGcpAuthParams, type RevokeGcpAuthResponse, type RevokeIdentitySuperAdminParams, type RevokeIdentitySuperAdminResponse, type RevokeJwtAuthParams, type RevokeJwtAuthResponse, type RevokeKubernetesAuthParams, type RevokeKubernetesAuthResponse, type RevokeLdapAuthParams, type RevokeLdapAuthResponse, type RevokeOciAuthParams, type RevokeOciAuthResponse, type RevokeOidcAuthParams, type RevokeOidcAuthResponse, type RevokeSessionResponse, type RevokeTlsCertAuthParams, type RevokeTlsCertAuthResponse, type RevokeTokenAuthParams, type RevokeTokenAuthResponse, type RevokeTokenAuthTokenParams, type RevokeTokenAuthTokenResponse, type RevokeUniversalAuthClientSecretParams, type RevokeUniversalAuthClientSecretResponse, type RevokeUniversalAuthParams, type RevokeUniversalAuthResponse, type SanitizedServiceToken, type SearchIdentitiesParams, type SearchIdentitiesResponse, type Secret, type SecretAccessEntry, type SecretFolder, type SecretFolderDetailed, type SecretFolderWithPath, type SecretFolderWithRelativePath, SecretFoldersResource, type SecretImport, type SecretImportDetailed, type SecretImportEnv, SecretImportsResource, SecretSharingResource, type SecretSync, SecretSyncsResource, type SecretTag, type SecretTagRef, SecretTagsResource, SecretsResource, type SendEmailVerificationCodeParams, type ServiceToken, ServiceTokensResource, type SharedSecret, type SignCertificateParams, type SignCertificateResponse, type SignIntermediateCaParams, type SignIntermediateCaResponse, type SuperAdminConfig, type TestWebhookParams, type TestWebhookResponse, type TriggerSecretSyncParams, type TriggerSecretSyncResponse, UnauthorizedError, type UniversalAuthClientSecret, type UpdateAdminConfigParams, type UpdateAdminConfigResponse, type UpdateAlicloudAuthParams, type UpdateAlicloudAuthResponse, type UpdateAppConnectionParams, type UpdateAppConnectionResponse, type UpdateAuthMethodsParams, type UpdateAuthMethodsResponse, type UpdateAwsAuthParams, type UpdateAwsAuthResponse, type UpdateAzureAuthParams, type UpdateAzureAuthResponse, type UpdateCaParams, type UpdateCaResponse, type UpdateCertificateConfigParams, type UpdateCertificateConfigResponse, type UpdateEmailParams, type UpdateEmailResponse, type UpdateEncryptionStrategyParams, type UpdateEncryptionStrategyResponse, type UpdateGcpAuthParams, type UpdateGcpAuthResponse, type UpdateIdentityParams, type UpdateIdentityResponse, type UpdateJwtAuthParams, type UpdateJwtAuthResponse, type UpdateKmsKeyParams, type UpdateKmsKeyResponse, type UpdateKubernetesAuthParams, type UpdateKubernetesAuthResponse, type UpdateLdapAuthParams, type UpdateLdapAuthResponse, type UpdateMembershipParams, type UpdateMembershipResponse, type UpdateMfaParams, type UpdateMfaResponse, type UpdateNameParams, type UpdateNameResponse, type UpdateOciAuthParams, type UpdateOciAuthResponse, type UpdateOidcAuthParams, type UpdateOidcAuthResponse, type UpdatePkiAlertParams, type UpdatePkiAlertResponse, type UpdatePkiTemplateParams, type UpdatePkiTemplateResponse, type UpdateProjectEnvironmentParams, type UpdateProjectEnvironmentResponse, type UpdateProjectParams, type UpdateProjectResponse, type UpdateSecretFolderBatchItem, type UpdateSecretFolderBatchParams, type UpdateSecretFolderBatchResponse, type UpdateSecretFolderParams, type UpdateSecretFolderResponse, type UpdateSecretImportParams, type UpdateSecretImportResponse, type UpdateSecretParams, type UpdateSecretResponse, type UpdateSecretSyncParams, type UpdateSecretSyncResponse, type UpdateSecretTagParams, type UpdateSecretTagResponse, type UpdateTlsCertAuthParams, type UpdateTlsCertAuthResponse, type UpdateTokenAuthParams, type UpdateTokenAuthResponse, type UpdateTokenAuthTokenParams, type UpdateTokenAuthTokenResponse, type UpdateUniversalAuthParams, type UpdateUniversalAuthResponse, type UpdateWebhookParams, type UpdateWebhookResponse, type UpgradePrivilegeSystemResponse, type User, type UserWithEncryptionKeys, UsersResource, ValidationError, type VerifyEmailVerificationCodeParams, type VerifyMfaParams, type VerifyMfaRecoveryCodeParams, type VerifyMfaResponse, type VerifyMfaSessionParams, type VerifyMfaSessionResponse, type Webhook, WebhooksResource };