@envsync-cloud/envsync-ts-sdk 0.1.0

package/README.md

@@ -0,0 +1,5 @@
+# envsync-ts-sdk
+
+This is generated SDK for EnvSync API developed by EnvSync Cloud
+
+## envsync-cloud

package/dist/index.d.mts

@@ -0,0 +1,702 @@
+type ApiRequestOptions = {
+    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+    readonly url: string;
+    readonly path?: Record<string, any>;
+    readonly cookies?: Record<string, any>;
+    readonly headers?: Record<string, any>;
+    readonly query?: Record<string, any>;
+    readonly formData?: Record<string, any>;
+    readonly body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number, string>;
+};
+
+declare class CancelError extends Error {
+    constructor(message: string);
+    get isCancelled(): boolean;
+}
+interface OnCancel {
+    readonly isResolved: boolean;
+    readonly isRejected: boolean;
+    readonly isCancelled: boolean;
+    (cancelHandler: () => void): void;
+}
+declare class CancelablePromise<T> implements Promise<T> {
+    #private;
+    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: OnCancel) => void);
+    get [Symbol.toStringTag](): string;
+    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onFinally?: (() => void) | null): Promise<T>;
+    cancel(): void;
+    get isCancelled(): boolean;
+}
+
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+type Headers = Record<string, string>;
+type OpenAPIConfig = {
+    BASE: string;
+    VERSION: string;
+    WITH_CREDENTIALS: boolean;
+    CREDENTIALS: 'include' | 'omit' | 'same-origin';
+    TOKEN?: string | Resolver<string> | undefined;
+    USERNAME?: string | Resolver<string> | undefined;
+    PASSWORD?: string | Resolver<string> | undefined;
+    HEADERS?: Headers | Resolver<Headers> | undefined;
+    ENCODE_PATH?: ((path: string) => string) | undefined;
+};
+declare const OpenAPI: OpenAPIConfig;
+
+declare abstract class BaseHttpRequest {
+    readonly config: OpenAPIConfig;
+    constructor(config: OpenAPIConfig);
+    abstract request<T>(options: ApiRequestOptions): CancelablePromise<T>;
+}
+
+type CreateAppRequest = {
+    name: string;
+    description: string;
+    metadata?: Record<string, any>;
+};
+
+type CreateAppResponse = {
+    message: string;
+    id: string;
+};
+
+type DeleteAppResponse = {
+    message: string;
+};
+
+type GetAppResponse = {
+    app: {
+        id: string;
+        name: string;
+        description: string;
+        metadata: Record<string, any>;
+        org_id: string;
+        created_at: string;
+        updated_at: string;
+    };
+};
+
+type GetAppsResponse = {
+    apps: Array<{
+        id: string;
+        name: string;
+        description: string;
+        metadata: Record<string, any>;
+        org_id: string;
+        created_at: string;
+        updated_at: string;
+    }>;
+};
+
+type UpdateAppRequest = {
+    name?: string;
+    description?: string;
+    metadata?: Record<string, any>;
+};
+
+type UpdateAppResponse = {
+    message: string;
+};
+
+declare class ApplicationsService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Get All Applications
+     * Retrieve all applications for the organization
+     * @returns GetAppsResponse Applications retrieved successfully
+     * @throws ApiError
+     */
+    getApps(): CancelablePromise<GetAppsResponse>;
+    /**
+     * Create Application
+     * Create a new application
+     * @param requestBody
+     * @returns CreateAppResponse Application created successfully
+     * @throws ApiError
+     */
+    createApp(requestBody?: CreateAppRequest): CancelablePromise<CreateAppResponse>;
+    /**
+     * Get Application
+     * Retrieve a specific application by ID
+     * @param id
+     * @returns GetAppResponse Application retrieved successfully
+     * @throws ApiError
+     */
+    getApp(id: string): CancelablePromise<GetAppResponse>;
+    /**
+     * Update Application
+     * Update an existing application
+     * @param id
+     * @param requestBody
+     * @returns UpdateAppResponse Application updated successfully
+     * @throws ApiError
+     */
+    updateApp(id: string, requestBody?: UpdateAppRequest): CancelablePromise<UpdateAppResponse>;
+    /**
+     * Delete Application
+     * Delete an existing application
+     * @param id
+     * @returns DeleteAppResponse Application deleted successfully
+     * @throws ApiError
+     */
+    deleteApp(id: string): CancelablePromise<DeleteAppResponse>;
+}
+
+type GetAuditLogsResponse = Array<{
+    id: string;
+    action: string;
+    org_id: string;
+    user_id: string;
+    details: string;
+    created_at: string;
+    updated_at: string;
+}>;
+
+declare class AuditLogsService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Get Audit Logs
+     * Retrieve audit logs for the organization with pagination
+     * @param page
+     * @param perPage
+     * @returns GetAuditLogsResponse Audit logs retrieved successfully
+     * @throws ApiError
+     */
+    getAuditLogs(page?: number, perPage?: number): CancelablePromise<GetAuditLogsResponse>;
+}
+
+type WhoAmIResponse = {
+    user: {
+        id: string;
+        email: string;
+        full_name: string;
+        org_id: string;
+        role_id: string;
+        profile_picture_url: string | null;
+        is_active: boolean;
+        created_at: string;
+        updated_at: string;
+    };
+    org: {
+        id: string;
+        name: string;
+        logo_url: string | null;
+        slug: string;
+        size: string | null;
+        website: string | null;
+        metadata: Record<string, any>;
+        created_at: string;
+        updated_at: string;
+    };
+};
+
+declare class AuthenticationService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Get Current User
+     * Retrieve the current authenticated user's information and their organization details
+     * @returns WhoAmIResponse User information retrieved successfully
+     * @throws ApiError
+     */
+    whoami(): CancelablePromise<WhoAmIResponse>;
+}
+
+type CreateEnvTypeRequest = {
+    name: string;
+};
+
+type DeleteEnvTypeRequest = {
+    id: string;
+};
+
+type EnvTypeResponse = {
+    id: string;
+    name: string;
+    org_id: string;
+    created_at: string;
+    updated_at: string;
+};
+
+type EnvTypesResponse = Array<EnvTypeResponse>;
+
+type UpdateEnvTypeRequest = {
+    id: string;
+    name: string;
+};
+
+declare class EnvironmentTypesService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Get Environment Types
+     * Retrieve all environment types for the organization
+     * @returns EnvTypesResponse Environment types retrieved successfully
+     * @throws ApiError
+     */
+    getEnvTypes(): CancelablePromise<EnvTypesResponse>;
+    /**
+     * Create Environment Type
+     * Create a new environment type
+     * @param requestBody
+     * @returns EnvTypeResponse Environment type created successfully
+     * @throws ApiError
+     */
+    createEnvType(requestBody?: CreateEnvTypeRequest): CancelablePromise<EnvTypeResponse>;
+    /**
+     * Get Environment Type
+     * Retrieve a specific environment type
+     * @param id
+     * @returns EnvTypeResponse Environment type retrieved successfully
+     * @throws ApiError
+     */
+    getEnvType(id: string): CancelablePromise<EnvTypeResponse>;
+    /**
+     * Update Environment Type
+     * Update an existing environment type
+     * @param id
+     * @param requestBody
+     * @returns EnvTypeResponse Environment type updated successfully
+     * @throws ApiError
+     */
+    updateEnvType(id: string, requestBody?: UpdateEnvTypeRequest): CancelablePromise<EnvTypeResponse>;
+    /**
+     * Delete Environment Type
+     * Delete an existing environment type
+     * @param id
+     * @returns DeleteEnvTypeRequest Environment type deleted successfully
+     * @throws ApiError
+     */
+    deleteEnvType(id: string): CancelablePromise<DeleteEnvTypeRequest>;
+}
+
+type BatchCreateEnvsRequest = {
+    app_id: string;
+    env_type_id: string;
+    envs: Array<{
+        key: string;
+        value: string;
+    }>;
+};
+
+type CreateEnvRequest = {
+    key: string;
+    value: string;
+    app_id: string;
+    env_type_id: string;
+};
+
+type DeleteEnvRequest = {
+    app_id: string;
+    env_type_id: string;
+    key: string;
+};
+
+type EnvResponse = {
+    id: string;
+    key: string;
+    value: string;
+    app_id: string;
+    env_type_id: string;
+    org_id: string;
+    created_at: string;
+    updated_at: string;
+};
+
+type EnvsResponse = Array<EnvResponse>;
+
+type GetEnvRequest = {
+    app_id: string;
+    env_type_id: string;
+};
+
+type UpdateEnvRequest = {
+    value: string;
+    app_id: string;
+    env_type_id: string;
+};
+
+declare class EnvironmentVariablesService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Get Environment Variables
+     * Retrieve all environment variables for an application and environment type
+     * @param requestBody
+     * @returns EnvsResponse Environment variables retrieved successfully
+     * @throws ApiError
+     */
+    getEnvs(requestBody?: GetEnvRequest): CancelablePromise<EnvsResponse>;
+    /**
+     * Delete Environment Variable
+     * Delete an existing environment variable
+     * @param requestBody
+     * @returns DeleteEnvRequest Environment variable deleted successfully
+     * @throws ApiError
+     */
+    deleteEnv(requestBody?: DeleteEnvRequest): CancelablePromise<DeleteEnvRequest>;
+    /**
+     * Get Single Environment Variable
+     * Retrieve a specific environment variable
+     * @param key
+     * @param requestBody
+     * @returns EnvResponse Environment variable retrieved successfully
+     * @throws ApiError
+     */
+    getEnv(key: string, requestBody?: GetEnvRequest): CancelablePromise<EnvResponse>;
+    /**
+     * Update Environment Variable
+     * Update an existing environment variable
+     * @param key
+     * @param requestBody
+     * @returns EnvResponse Environment variable updated successfully
+     * @throws ApiError
+     */
+    updateEnv(key: string, requestBody?: UpdateEnvRequest): CancelablePromise<EnvResponse>;
+    /**
+     * Create Environment Variable
+     * Create a new environment variable
+     * @param requestBody
+     * @returns EnvResponse Environment variable created successfully
+     * @throws ApiError
+     */
+    createEnv(requestBody?: CreateEnvRequest): CancelablePromise<EnvResponse>;
+    /**
+     * Batch Create Environment Variables
+     * Create multiple environment variables in a single request
+     * @param requestBody
+     * @returns EnvsResponse Environment variables created successfully
+     * @throws ApiError
+     */
+    batchCreateEnvs(requestBody?: BatchCreateEnvsRequest): CancelablePromise<EnvsResponse>;
+}
+
+type AcceptOrgInviteRequest = {
+    org_data: {
+        name: string;
+        size: string;
+        website: string;
+    };
+    user_data: {
+        full_name: string;
+        password: string;
+    };
+};
+
+type AcceptOrgInviteResponse = {
+    message: string;
+};
+
+type AcceptUserInviteRequest = {
+    full_name: string;
+    password: string;
+};
+
+type AcceptUserInviteResponse = {
+    message: string;
+};
+
+type CreateOrgInviteRequest = {
+    email: string;
+};
+
+type CreateOrgInviteResponse = {
+    message: string;
+};
+
+type CreateUserInviteRequest = {
+    email: string;
+    role_id: string;
+};
+
+type CreateUserInviteResponse = {
+    message: string;
+};
+
+type DeleteUserInviteResponse = {
+    message: string;
+};
+
+type GetOrgInviteByCodeResponse = {
+    invite: {
+        id: string;
+        email: string;
+        invite_token: string;
+        is_accepted: boolean;
+        created_at: string;
+        updated_at: string;
+    };
+};
+
+type GetUserInviteByTokenResponse = {
+    invite: {
+        id: string;
+        email: string;
+        invite_token: string;
+        role_id: string;
+        org_id: string;
+        is_accepted: boolean;
+        created_at: string;
+        updated_at: string;
+    };
+};
+
+type UpdateUserInviteRequest = {
+    role_id: string;
+};
+
+type UpdateUserInviteResponse = {
+    message: string;
+};
+
+declare class OnboardingService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Create Organization Invite
+     * Create an organization invite
+     * @param requestBody
+     * @returns CreateOrgInviteResponse Successful greeting response
+     * @throws ApiError
+     */
+    createOrgInvite(requestBody?: CreateOrgInviteRequest): CancelablePromise<CreateOrgInviteResponse>;
+    /**
+     * Get Organization Invite by Code
+     * Get organization invite by code
+     * @param inviteCode
+     * @returns GetOrgInviteByCodeResponse Organization invite retrieved successfully
+     * @throws ApiError
+     */
+    getOrgInviteByCode(inviteCode: string): CancelablePromise<GetOrgInviteByCodeResponse>;
+    /**
+     * Accept Organization Invite
+     * Accept organization invite
+     * @param inviteCode
+     * @param requestBody
+     * @returns AcceptOrgInviteResponse Organization invite accepted successfully
+     * @throws ApiError
+     */
+    acceptOrgInvite(inviteCode: string, requestBody?: AcceptOrgInviteRequest): CancelablePromise<AcceptOrgInviteResponse>;
+    /**
+     * Get User Invite by Code
+     * Get user invite by code
+     * @param inviteCode
+     * @returns GetUserInviteByTokenResponse User invite retrieved successfully
+     * @throws ApiError
+     */
+    getUserInviteByCode(inviteCode: string): CancelablePromise<GetUserInviteByTokenResponse>;
+    /**
+     * Update User Invite
+     * Update user invite
+     * @param inviteCode
+     * @param requestBody
+     * @returns UpdateUserInviteResponse User invite updated successfully
+     * @throws ApiError
+     */
+    updateUserInvite(inviteCode: string, requestBody?: UpdateUserInviteRequest): CancelablePromise<UpdateUserInviteResponse>;
+    /**
+     * Accept User Invite
+     * Accept user invite
+     * @param inviteCode
+     * @param requestBody
+     * @returns AcceptUserInviteResponse User invite accepted successfully
+     * @throws ApiError
+     */
+    acceptUserInvite(inviteCode: string, requestBody?: AcceptUserInviteRequest): CancelablePromise<AcceptUserInviteResponse>;
+    /**
+     * Create User Invite
+     * Create a user invite
+     * @param requestBody
+     * @returns CreateUserInviteResponse User invite created successfully
+     * @throws ApiError
+     */
+    createUserInvite(requestBody?: CreateUserInviteRequest): CancelablePromise<CreateUserInviteResponse>;
+    /**
+     * Delete User Invite
+     * Delete user invite
+     * @param inviteId
+     * @param requestBody
+     * @returns DeleteUserInviteResponse User invite deleted successfully
+     * @throws ApiError
+     */
+    deleteUserInvite(inviteId: string, requestBody?: DeleteUserInviteResponse): CancelablePromise<DeleteUserInviteResponse>;
+}
+
+type CheckSlugResponse = {
+    exists: boolean;
+};
+
+type OrgResponse = {
+    id: string;
+    name: string;
+    logo_url: string | null;
+    slug: string;
+    size: string | null;
+    website: string | null;
+    metadata: Record<string, any>;
+    created_at: string;
+    updated_at: string;
+};
+
+type UpdateOrgRequest = {
+    logo_url?: string;
+    website?: string;
+    name?: string;
+    slug?: string;
+};
+
+declare class OrganizationsService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Get Organization
+     * Retrieve the current organization's details
+     * @returns OrgResponse Organization retrieved successfully
+     * @throws ApiError
+     */
+    getOrg(): CancelablePromise<OrgResponse>;
+    /**
+     * Update Organization
+     * Update the current organization's details
+     * @param requestBody
+     * @returns OrgResponse Organization updated successfully
+     * @throws ApiError
+     */
+    updateOrg(requestBody?: UpdateOrgRequest): CancelablePromise<OrgResponse>;
+    /**
+     * Check Slug Availability
+     * Check if an organization slug is available
+     * @param slug
+     * @returns CheckSlugResponse Slug availability checked successfully
+     * @throws ApiError
+     */
+    checkIfSlugExists(slug: string): CancelablePromise<CheckSlugResponse>;
+}
+
+type UpdatePasswordRequest = {
+    password: string;
+};
+
+type UpdateRoleRequest = {
+    role_id: string;
+};
+
+type UpdateUserRequest = {
+    full_name?: string;
+    profile_picture_url?: string;
+    email?: string;
+};
+
+type UserResponse = {
+    id: string;
+    email: string;
+    full_name: string;
+    profile_picture_url: string | null;
+    org_id: string;
+    role_id: string;
+    auth0_id: string | null;
+    is_active: boolean;
+    created_at: string;
+    updated_at: string;
+};
+
+type UsersResponse = Array<UserResponse>;
+
+declare class UsersService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Get All Users
+     * Retrieve all users in the organization
+     * @returns UsersResponse Users retrieved successfully
+     * @throws ApiError
+     */
+    getUsers(): CancelablePromise<UsersResponse>;
+    /**
+     * Get User by ID
+     * Retrieve a specific user by their ID
+     * @param id
+     * @returns UserResponse User retrieved successfully
+     * @throws ApiError
+     */
+    getUserById(id: string): CancelablePromise<UserResponse>;
+    /**
+     * Update User
+     * Update a user's profile information
+     * @param id
+     * @param requestBody
+     * @returns UserResponse User updated successfully
+     * @throws ApiError
+     */
+    updateUser(id: string, requestBody?: UpdateUserRequest): CancelablePromise<UserResponse>;
+    /**
+     * Delete User
+     * Delete a user from the organization (Admin only)
+     * @param id
+     * @returns UserResponse User deleted successfully
+     * @throws ApiError
+     */
+    deleteUser(id: string): CancelablePromise<UserResponse>;
+    /**
+     * Update User Role
+     * Update a user's role (Admin only)
+     * @param id
+     * @param requestBody
+     * @returns UserResponse User role updated successfully
+     * @throws ApiError
+     */
+    updateRole(id: string, requestBody?: UpdateRoleRequest): CancelablePromise<UserResponse>;
+    /**
+     * Update User Password
+     * Update a user's password (Admin only)
+     * @param id
+     * @param requestBody
+     * @returns UserResponse Password update request sent successfully
+     * @throws ApiError
+     */
+    updatePassword(id: string, requestBody?: UpdatePasswordRequest): CancelablePromise<UserResponse>;
+}
+
+type HttpRequestConstructor = new (config: OpenAPIConfig) => BaseHttpRequest;
+declare class EnvSyncAPISDK {
+    readonly applications: ApplicationsService;
+    readonly auditLogs: AuditLogsService;
+    readonly authentication: AuthenticationService;
+    readonly environmentTypes: EnvironmentTypesService;
+    readonly environmentVariables: EnvironmentVariablesService;
+    readonly onboarding: OnboardingService;
+    readonly organizations: OrganizationsService;
+    readonly users: UsersService;
+    readonly request: BaseHttpRequest;
+    constructor(config?: Partial<OpenAPIConfig>, HttpRequest?: HttpRequestConstructor);
+}
+
+type ApiResult = {
+    readonly url: string;
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+};
+
+declare class ApiError extends Error {
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+    readonly request: ApiRequestOptions;
+    constructor(request: ApiRequestOptions, response: ApiResult, message: string);
+}
+
+type ErrorResponse = {
+    error: string;
+};
+
+export { type AcceptOrgInviteRequest, type AcceptOrgInviteResponse, type AcceptUserInviteRequest, type AcceptUserInviteResponse, ApiError, ApplicationsService, AuditLogsService, AuthenticationService, BaseHttpRequest, type BatchCreateEnvsRequest, CancelError, CancelablePromise, type CheckSlugResponse, type CreateAppRequest, type CreateAppResponse, type CreateEnvRequest, type CreateEnvTypeRequest, type CreateOrgInviteRequest, type CreateOrgInviteResponse, type CreateUserInviteRequest, type CreateUserInviteResponse, type DeleteAppResponse, type DeleteEnvRequest, type DeleteEnvTypeRequest, type DeleteUserInviteResponse, type EnvResponse, EnvSyncAPISDK, type EnvTypeResponse, type EnvTypesResponse, EnvironmentTypesService, EnvironmentVariablesService, type EnvsResponse, type ErrorResponse, type GetAppResponse, type GetAppsResponse, type GetAuditLogsResponse, type GetEnvRequest, type GetOrgInviteByCodeResponse, type GetUserInviteByTokenResponse, OnboardingService, OpenAPI, type OpenAPIConfig, type OrgResponse, OrganizationsService, type UpdateAppRequest, type UpdateAppResponse, type UpdateEnvRequest, type UpdateEnvTypeRequest, type UpdateOrgRequest, type UpdatePasswordRequest, type UpdateRoleRequest, type UpdateUserInviteRequest, type UpdateUserInviteResponse, type UpdateUserRequest, type UserResponse, type UsersResponse, UsersService, type WhoAmIResponse };