@ayasofyazilim/saas 0.0.9 → 0.0.11

package/IdentityService/IdentityServiceClient.ts

@@ -1,70 +1,77 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { BaseHttpRequest } from './core/BaseHttpRequest';
-import type { OpenAPIConfig } from './core/OpenAPI';
-import { FetchHttpRequest } from './core/FetchHttpRequest';
-import { AbpApiDefinitionService } from './services/AbpApiDefinitionService';
-import { AbpApplicationConfigurationService } from './services/AbpApplicationConfigurationService';
-import { AbpApplicationLocalizationService } from './services/AbpApplicationLocalizationService';
-import { AccountSettingsService } from './services/AccountSettingsService';
-import { ApplicationsService } from './services/ApplicationsService';
-import { ClaimTypeService } from './services/ClaimTypeService';
-import { ExternalLoginService } from './services/ExternalLoginService';
-import { OrganizationUnitService } from './services/OrganizationUnitService';
-import { RoleService } from './services/RoleService';
-import { ScopesService } from './services/ScopesService';
-import { SecurityLogService } from './services/SecurityLogService';
-import { SettingsService } from './services/SettingsService';
-import { UserService } from './services/UserService';
-import { UserIntegrationService } from './services/UserIntegrationService';
-import { UserLookupService } from './services/UserLookupService';
-type HttpRequestConstructor = new (config: OpenAPIConfig) => BaseHttpRequest;
-export class IdentityServiceClient {
-    public readonly abpApiDefinition: AbpApiDefinitionService;
-    public readonly abpApplicationConfiguration: AbpApplicationConfigurationService;
-    public readonly abpApplicationLocalization: AbpApplicationLocalizationService;
-    public readonly accountSettings: AccountSettingsService;
-    public readonly applications: ApplicationsService;
-    public readonly claimType: ClaimTypeService;
-    public readonly externalLogin: ExternalLoginService;
-    public readonly organizationUnit: OrganizationUnitService;
-    public readonly role: RoleService;
-    public readonly scopes: ScopesService;
-    public readonly securityLog: SecurityLogService;
-    public readonly settings: SettingsService;
-    public readonly user: UserService;
-    public readonly userIntegration: UserIntegrationService;
-    public readonly userLookup: UserLookupService;
-    public readonly request: BaseHttpRequest;
-    constructor(config?: Partial<OpenAPIConfig>, HttpRequest: HttpRequestConstructor = FetchHttpRequest) {
-        this.request = new HttpRequest({
-            BASE: config?.BASE ?? '',
-            VERSION: config?.VERSION ?? '1',
-            WITH_CREDENTIALS: config?.WITH_CREDENTIALS ?? false,
-            CREDENTIALS: config?.CREDENTIALS ?? 'include',
-            TOKEN: config?.TOKEN,
-            USERNAME: config?.USERNAME,
-            PASSWORD: config?.PASSWORD,
-            HEADERS: config?.HEADERS,
-            ENCODE_PATH: config?.ENCODE_PATH,
-        });
-        this.abpApiDefinition = new AbpApiDefinitionService(this.request);
-        this.abpApplicationConfiguration = new AbpApplicationConfigurationService(this.request);
-        this.abpApplicationLocalization = new AbpApplicationLocalizationService(this.request);
-        this.accountSettings = new AccountSettingsService(this.request);
-        this.applications = new ApplicationsService(this.request);
-        this.claimType = new ClaimTypeService(this.request);
-        this.externalLogin = new ExternalLoginService(this.request);
-        this.organizationUnit = new OrganizationUnitService(this.request);
-        this.role = new RoleService(this.request);
-        this.scopes = new ScopesService(this.request);
-        this.securityLog = new SecurityLogService(this.request);
-        this.settings = new SettingsService(this.request);
-        this.user = new UserService(this.request);
-        this.userIntegration = new UserIntegrationService(this.request);
-        this.userLookup = new UserLookupService(this.request);
-    }
-}
-
+import type { BaseHttpRequest } from './core/BaseHttpRequest';
+import type { OpenAPIConfig } from './core/OpenAPI';
+import { Interceptors } from './core/OpenAPI';
+import { FetchHttpRequest } from './core/FetchHttpRequest';
+
+import { AbpApiDefinitionService } from './services.gen';
+import { AbpApplicationConfigurationService } from './services.gen';
+import { AbpApplicationLocalizationService } from './services.gen';
+import { AccountSettingsService } from './services.gen';
+import { ApplicationsService } from './services.gen';
+import { ClaimTypeService } from './services.gen';
+import { ExternalLoginService } from './services.gen';
+import { OrganizationUnitService } from './services.gen';
+import { RoleService } from './services.gen';
+import { ScopesService } from './services.gen';
+import { SecurityLogService } from './services.gen';
+import { SettingsService } from './services.gen';
+import { UserService } from './services.gen';
+import { UserIntegrationService } from './services.gen';
+import { UserLookupService } from './services.gen';
+
+type HttpRequestConstructor = new (config: OpenAPIConfig) => BaseHttpRequest;
+
+export class IdentityServiceClient {
+
+	public readonly abpApiDefinition: AbpApiDefinitionService;
+	public readonly abpApplicationConfiguration: AbpApplicationConfigurationService;
+	public readonly abpApplicationLocalization: AbpApplicationLocalizationService;
+	public readonly accountSettings: AccountSettingsService;
+	public readonly applications: ApplicationsService;
+	public readonly claimType: ClaimTypeService;
+	public readonly externalLogin: ExternalLoginService;
+	public readonly organizationUnit: OrganizationUnitService;
+	public readonly role: RoleService;
+	public readonly scopes: ScopesService;
+	public readonly securityLog: SecurityLogService;
+	public readonly settings: SettingsService;
+	public readonly user: UserService;
+	public readonly userIntegration: UserIntegrationService;
+	public readonly userLookup: UserLookupService;
+
+	public readonly request: BaseHttpRequest;
+
+	constructor(config?: Partial<OpenAPIConfig>, HttpRequest: HttpRequestConstructor = FetchHttpRequest) {
+		this.request = new HttpRequest({
+			BASE: config?.BASE ?? '',
+			VERSION: config?.VERSION ?? '1',
+			WITH_CREDENTIALS: config?.WITH_CREDENTIALS ?? false,
+			CREDENTIALS: config?.CREDENTIALS ?? 'include',
+			TOKEN: config?.TOKEN,
+			USERNAME: config?.USERNAME,
+			PASSWORD: config?.PASSWORD,
+			HEADERS: config?.HEADERS,
+			ENCODE_PATH: config?.ENCODE_PATH,
+			interceptors: {
+				request: config?.interceptors?.request ?? new Interceptors(),
+				response: config?.interceptors?.response ?? new Interceptors(),
+      },
+		});
+
+		this.abpApiDefinition = new AbpApiDefinitionService(this.request);
+		this.abpApplicationConfiguration = new AbpApplicationConfigurationService(this.request);
+		this.abpApplicationLocalization = new AbpApplicationLocalizationService(this.request);
+		this.accountSettings = new AccountSettingsService(this.request);
+		this.applications = new ApplicationsService(this.request);
+		this.claimType = new ClaimTypeService(this.request);
+		this.externalLogin = new ExternalLoginService(this.request);
+		this.organizationUnit = new OrganizationUnitService(this.request);
+		this.role = new RoleService(this.request);
+		this.scopes = new ScopesService(this.request);
+		this.securityLog = new SecurityLogService(this.request);
+		this.settings = new SettingsService(this.request);
+		this.user = new UserService(this.request);
+		this.userIntegration = new UserIntegrationService(this.request);
+		this.userLookup = new UserLookupService(this.request);
+	}
+}

package/IdentityService/core/ApiError.ts

@@ -1,25 +1,21 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
 import type { ApiRequestOptions } from './ApiRequestOptions';
 import type { ApiResult } from './ApiResult';
 
 export class ApiError extends Error {
-    public readonly url: string;
-    public readonly status: number;
-    public readonly statusText: string;
-    public readonly body: any;
-    public readonly request: ApiRequestOptions;
+	public readonly url: string;
+	public readonly status: number;
+	public readonly statusText: string;
+	public readonly body: unknown;
+	public readonly request: ApiRequestOptions;
 
-    constructor(request: ApiRequestOptions, response: ApiResult, message: string) {
-        super(message);
+	constructor(request: ApiRequestOptions, response: ApiResult, message: string) {
+		super(message);
 
-        this.name = 'ApiError';
-        this.url = response.url;
-        this.status = response.status;
-        this.statusText = response.statusText;
-        this.body = response.body;
-        this.request = request;
-    }
-}
+		this.name = 'ApiError';
+		this.url = response.url;
+		this.status = response.status;
+		this.statusText = response.statusText;
+		this.body = response.body;
+		this.request = request;
+	}
+}

package/IdentityService/core/ApiRequestOptions.ts

@@ -1,17 +1,13 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
 export 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>;
-};
+	readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+	readonly url: string;
+	readonly path?: Record<string, unknown>;
+	readonly cookies?: Record<string, unknown>;
+	readonly headers?: Record<string, unknown>;
+	readonly query?: Record<string, unknown>;
+	readonly formData?: Record<string, unknown>;
+	readonly body?: any;
+	readonly mediaType?: string;
+	readonly responseHeader?: string;
+	readonly errors?: Record<number, string>;
+};

package/IdentityService/core/ApiResult.ts

@@ -1,11 +1,7 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-export type ApiResult = {
-    readonly url: string;
-    readonly ok: boolean;
-    readonly status: number;
-    readonly statusText: string;
-    readonly body: any;
-};
+export type ApiResult<TData = any> = {
+	readonly body: TData;
+	readonly ok: boolean;
+	readonly status: number;
+	readonly statusText: string;
+	readonly url: string;
+};

package/IdentityService/core/BaseHttpRequest.ts

@@ -1,14 +1,10 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
 import type { ApiRequestOptions } from './ApiRequestOptions';
 import type { CancelablePromise } from './CancelablePromise';
 import type { OpenAPIConfig } from './OpenAPI';
 
 export abstract class BaseHttpRequest {
 
-    constructor(public readonly config: OpenAPIConfig) {}
+	constructor(public readonly config: OpenAPIConfig) {}
 
-    public abstract request<T>(options: ApiRequestOptions): CancelablePromise<T>;
-}
+	public abstract request<T>(options: ApiRequestOptions): CancelablePromise<T>;
+}

package/IdentityService/core/CancelablePromise.ts

@@ -1,131 +1,126 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
 export class CancelError extends Error {
-
-    constructor(message: string) {
-        super(message);
-        this.name = 'CancelError';
-    }
-
-    public get isCancelled(): boolean {
-        return true;
-    }
+	constructor(message: string) {
+		super(message);
+		this.name = 'CancelError';
+	}
+
+	public get isCancelled(): boolean {
+		return true;
+	}
 }
 
 export interface OnCancel {
-    readonly isResolved: boolean;
-    readonly isRejected: boolean;
-    readonly isCancelled: boolean;
+	readonly isResolved: boolean;
+	readonly isRejected: boolean;
+	readonly isCancelled: boolean;
 
-    (cancelHandler: () => void): void;
+	(cancelHandler: () => void): void;
 }
 
 export class CancelablePromise<T> implements Promise<T> {
-    #isResolved: boolean;
-    #isRejected: boolean;
-    #isCancelled: boolean;
-    readonly #cancelHandlers: (() => void)[];
-    readonly #promise: Promise<T>;
-    #resolve?: (value: T | PromiseLike<T>) => void;
-    #reject?: (reason?: any) => void;
-
-    constructor(
-        executor: (
-            resolve: (value: T | PromiseLike<T>) => void,
-            reject: (reason?: any) => void,
-            onCancel: OnCancel
-        ) => void
-    ) {
-        this.#isResolved = false;
-        this.#isRejected = false;
-        this.#isCancelled = false;
-        this.#cancelHandlers = [];
-        this.#promise = new Promise<T>((resolve, reject) => {
-            this.#resolve = resolve;
-            this.#reject = reject;
-
-            const onResolve = (value: T | PromiseLike<T>): void => {
-                if (this.#isResolved || this.#isRejected || this.#isCancelled) {
-                    return;
-                }
-                this.#isResolved = true;
-                if (this.#resolve) this.#resolve(value);
-            };
-
-            const onReject = (reason?: any): void => {
-                if (this.#isResolved || this.#isRejected || this.#isCancelled) {
-                    return;
-                }
-                this.#isRejected = true;
-                if (this.#reject) this.#reject(reason);
-            };
-
-            const onCancel = (cancelHandler: () => void): void => {
-                if (this.#isResolved || this.#isRejected || this.#isCancelled) {
-                    return;
-                }
-                this.#cancelHandlers.push(cancelHandler);
-            };
-
-            Object.defineProperty(onCancel, 'isResolved', {
-                get: (): boolean => this.#isResolved,
-            });
-
-            Object.defineProperty(onCancel, 'isRejected', {
-                get: (): boolean => this.#isRejected,
-            });
-
-            Object.defineProperty(onCancel, 'isCancelled', {
-                get: (): boolean => this.#isCancelled,
-            });
-
-            return executor(onResolve, onReject, onCancel as OnCancel);
-        });
-    }
-
-     get [Symbol.toStringTag]() {
-            return "Cancellable Promise";
-     }
-
-    public then<TResult1 = T, TResult2 = never>(
-        onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
-        onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null
-    ): Promise<TResult1 | TResult2> {
-        return this.#promise.then(onFulfilled, onRejected);
-    }
-
-    public catch<TResult = never>(
-        onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null
-    ): Promise<T | TResult> {
-        return this.#promise.catch(onRejected);
-    }
-
-    public finally(onFinally?: (() => void) | null): Promise<T> {
-        return this.#promise.finally(onFinally);
-    }
-
-    public cancel(): void {
-        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
-            return;
-        }
-        this.#isCancelled = true;
-        if (this.#cancelHandlers.length) {
-            try {
-                for (const cancelHandler of this.#cancelHandlers) {
-                    cancelHandler();
-                }
-            } catch (error) {
-                console.warn('Cancellation threw an error', error);
-                return;
-            }
-        }
-        this.#cancelHandlers.length = 0;
-        if (this.#reject) this.#reject(new CancelError('Request aborted'));
-    }
-
-    public get isCancelled(): boolean {
-        return this.#isCancelled;
-    }
-}
+	private _isResolved: boolean;
+	private _isRejected: boolean;
+	private _isCancelled: boolean;
+	readonly cancelHandlers: (() => void)[];
+	readonly promise: Promise<T>;
+	private _resolve?: (value: T | PromiseLike<T>) => void;
+	private _reject?: (reason?: unknown) => void;
+
+	constructor(
+		executor: (
+			resolve: (value: T | PromiseLike<T>) => void,
+			reject: (reason?: unknown) => void,
+			onCancel: OnCancel
+		) => void
+	) {
+		this._isResolved = false;
+		this._isRejected = false;
+		this._isCancelled = false;
+		this.cancelHandlers = [];
+		this.promise = new Promise<T>((resolve, reject) => {
+			this._resolve = resolve;
+			this._reject = reject;
+
+			const onResolve = (value: T | PromiseLike<T>): void => {
+				if (this._isResolved || this._isRejected || this._isCancelled) {
+					return;
+				}
+				this._isResolved = true;
+				if (this._resolve) this._resolve(value);
+			};
+
+			const onReject = (reason?: unknown): void => {
+				if (this._isResolved || this._isRejected || this._isCancelled) {
+					return;
+				}
+				this._isRejected = true;
+				if (this._reject) this._reject(reason);
+			};
+
+			const onCancel = (cancelHandler: () => void): void => {
+				if (this._isResolved || this._isRejected || this._isCancelled) {
+					return;
+				}
+				this.cancelHandlers.push(cancelHandler);
+			};
+
+			Object.defineProperty(onCancel, 'isResolved', {
+				get: (): boolean => this._isResolved,
+			});
+
+			Object.defineProperty(onCancel, 'isRejected', {
+				get: (): boolean => this._isRejected,
+			});
+
+			Object.defineProperty(onCancel, 'isCancelled', {
+				get: (): boolean => this._isCancelled,
+			});
+
+			return executor(onResolve, onReject, onCancel as OnCancel);
+		});
+	}
+
+	get [Symbol.toStringTag]() {
+		return "Cancellable Promise";
+	}
+
+	public then<TResult1 = T, TResult2 = never>(
+		onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
+		onRejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null
+	): Promise<TResult1 | TResult2> {
+		return this.promise.then(onFulfilled, onRejected);
+	}
+
+	public catch<TResult = never>(
+		onRejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null
+	): Promise<T | TResult> {
+		return this.promise.catch(onRejected);
+	}
+
+	public finally(onFinally?: (() => void) | null): Promise<T> {
+		return this.promise.finally(onFinally);
+	}
+
+	public cancel(): void {
+		if (this._isResolved || this._isRejected || this._isCancelled) {
+			return;
+		}
+		this._isCancelled = true;
+		if (this.cancelHandlers.length) {
+			try {
+				for (const cancelHandler of this.cancelHandlers) {
+					cancelHandler();
+				}
+			} catch (error) {
+				console.warn('Cancellation threw an error', error);
+				return;
+			}
+		}
+		this.cancelHandlers.length = 0;
+		if (this._reject) this._reject(new CancelError('Request aborted'));
+	}
+
+	public get isCancelled(): boolean {
+		return this._isCancelled;
+	}
+}

package/IdentityService/core/FetchHttpRequest.ts

@@ -1,7 +1,3 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
 import type { ApiRequestOptions } from './ApiRequestOptions';
 import { BaseHttpRequest } from './BaseHttpRequest';
 import type { CancelablePromise } from './CancelablePromise';
@@ -10,17 +6,17 @@ import { request as __request } from './request';
 
 export class FetchHttpRequest extends BaseHttpRequest {
 
-    constructor(config: OpenAPIConfig) {
-        super(config);
-    }
+	constructor(config: OpenAPIConfig) {
+		super(config);
+	}
 
-    /**
-     * Request method
-     * @param options The request options from the service
-     * @returns CancelablePromise<T>
-     * @throws ApiError
-     */
-    public override request<T>(options: ApiRequestOptions): CancelablePromise<T> {
-        return __request(this.config, options);
-    }
-}
+	/**
+	 * Request method
+	 * @param options The request options from the service
+	 * @returns CancelablePromise<T>
+	 * @throws ApiError
+	 */
+	public override request<T>(options: ApiRequestOptions): CancelablePromise<T> {
+		return __request(this.config, options);
+	}
+}

package/IdentityService/core/OpenAPI.ts

@@ -1,32 +1,56 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
 import type { ApiRequestOptions } from './ApiRequestOptions';
 
-type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
 type Headers = Record<string, string>;
+type Middleware<T> = (value: T) => T | Promise<T>;
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+
+export class Interceptors<T> {
+  _fns: Middleware<T>[];
+
+  constructor() {
+    this._fns = [];
+  }
+
+  eject(fn: Middleware<T>) {
+    const index = this._fns.indexOf(fn);
+    if (index !== -1) {
+      this._fns = [...this._fns.slice(0, index), ...this._fns.slice(index + 1)];
+    }
+  }
+
+  use(fn: Middleware<T>) {
+    this._fns = [...this._fns, fn];
+  }
+}
 
 export 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;
+	BASE: string;
+	CREDENTIALS: 'include' | 'omit' | 'same-origin';
+	ENCODE_PATH?: ((path: string) => string) | undefined;
+	HEADERS?: Headers | Resolver<Headers> | undefined;
+	PASSWORD?: string | Resolver<string> | undefined;
+	TOKEN?: string | Resolver<string> | undefined;
+	USERNAME?: string | Resolver<string> | undefined;
+	VERSION: string;
+	WITH_CREDENTIALS: boolean;
+	interceptors: {
+		request: Interceptors<RequestInit>;
+		response: Interceptors<Response>;
+	};
 };
 
 export const OpenAPI: OpenAPIConfig = {
-    BASE: '',
-    VERSION: '1',
-    WITH_CREDENTIALS: false,
-    CREDENTIALS: 'include',
-    TOKEN: undefined,
-    USERNAME: undefined,
-    PASSWORD: undefined,
-    HEADERS: undefined,
-    ENCODE_PATH: undefined,
-};
+	BASE: '',
+	CREDENTIALS: 'include',
+	ENCODE_PATH: undefined,
+	HEADERS: undefined,
+	PASSWORD: undefined,
+	TOKEN: undefined,
+	USERNAME: undefined,
+	VERSION: '1',
+	WITH_CREDENTIALS: false,
+	interceptors: {
+		request: new Interceptors(),
+		response: new Interceptors(),
+	},
+};