@oapiex/sdk-kit 0.1.1

package/dist/index.d.cts

@@ -0,0 +1,527 @@
+import { _ as CountryCodeRestricted, a as InitOptions, c as Response, d as UnifiedResponse, f as UserConfig, g as CountryCode, h as XGenericObject, i as ErrorResponse, l as ResponseStatus, m as ValidationErrorResponse, n as AuthResponse, o as NormalPagination, p as ValidationError, r as CursorPagination, s as PageInfoMeta, t as AuthErrorResponse, u as SuccessResponse, v as CurrencyCode } from "./index-BYtse_Mh.cjs";
+import * as axios0 from "axios";
+import { RawAxiosRequestHeaders } from "axios";
+
+//#region src/Exceptions/BadRequestException.d.ts
+declare class BadRequestException extends Error {
+  statusCode: number;
+  type: string;
+  code: string | number;
+  data: ValidationErrorResponse;
+  constructor(data?: ValidationErrorResponse);
+}
+//#endregion
+//#region src/types.d.ts
+interface RuntimeSdkParameterManifest {
+  name: string;
+  accessor: string;
+  in: 'query' | 'header' | 'path';
+  required: boolean;
+}
+interface RuntimeSdkOperationManifest {
+  path: string;
+  method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+  methodName: string;
+  summary?: string;
+  operationId?: string;
+  responseType: string;
+  inputType: string;
+  queryType: string;
+  headerType: string;
+  paramsType: string;
+  hasBody: boolean;
+  bodyRequired: boolean;
+  pathParams: RuntimeSdkParameterManifest[];
+  queryParams: RuntimeSdkParameterManifest[];
+  headerParams: RuntimeSdkParameterManifest[];
+}
+interface RuntimeSdkGroupManifest {
+  className: string;
+  propertyName: string;
+  operations: RuntimeSdkOperationManifest[];
+}
+interface RuntimeSdkManifest {
+  groups: RuntimeSdkGroupManifest[];
+}
+interface RuntimeSdkBundle<TApi$1 = unknown> {
+  document: unknown;
+  manifest: RuntimeSdkManifest;
+  __api?: TApi$1;
+}
+type RuntimeSdkMethodMap<TOperations$1> = TOperations$1 extends readonly unknown[] ? UnionToIntersection<RuntimeSdkMethodNamespace<TOperations$1[number]>> : Record<string, never>;
+type RuntimeSdkMethodNamespace<TOperation> = TOperation extends {
+  methodName: infer TMethodName extends string;
+} ? { [TKey in TMethodName]: (...args: any[]) => Promise<unknown> } : Record<string, never>;
+type RuntimeSdkGroupMap<TGroups$1> = TGroups$1 extends readonly unknown[] ? UnionToIntersection<RuntimeSdkGroupNamespace<TGroups$1[number]>> : Record<string, never>;
+type RuntimeSdkGroupNamespace<TGroup> = TGroup extends {
+  propertyName: infer TPropertyName extends string;
+  operations: infer TOperations;
+} ? { [TKey in TPropertyName]: RuntimeSdkMethodMap<TOperations> } : Record<string, never>;
+type InferRuntimeSdkApiFromManifest<TBundle> = TBundle extends {
+  manifest: {
+    groups: infer TGroups;
+  };
+} ? RuntimeSdkGroupMap<TGroups> : never;
+type UnionToIntersection<TValue> = (TValue extends unknown ? (value: TValue) => void : never) extends ((value: infer TIntersection) => void) ? TIntersection : never;
+type InferRuntimeSdkApi<TBundle> = '__api' extends keyof TBundle ? TBundle extends {
+  __api?: infer TApi;
+} ? TApi : InferRuntimeSdkApiFromManifest<TBundle> : InferRuntimeSdkApiFromManifest<TBundle>;
+//#endregion
+//#region src/Builder.d.ts
+declare class Builder {
+  private static baseUrls;
+  /**
+   * Flutterwave Environment
+   */
+  static environment?: 'sandbox' | 'live';
+  constructor();
+  /**
+   * Sets the environment for the builder
+   *
+   * @param env
+   */
+  static setEnvironment(env: 'sandbox' | 'live'): void;
+  /**
+   * Gets the base url based on environment
+   *
+   * @returns
+   */
+  static baseUrl(): string;
+  /**
+   * Builds a full url based on endpoint provided
+   *
+   * @param endpoint
+   * @returns
+   */
+  static buildUrl(...endpoint: string[]): string;
+  /**
+   * Builds parameters for query or path
+   *
+   * @param params
+   * @param type
+   * @returns
+   */
+  static buildParams(params: XGenericObject, type?: 'query' | 'path'): string;
+  /**
+   * Assigns parameters to url {placeholders} based on type
+   *
+   * @param url
+   * @param params
+   * @param type
+   *
+   * @returns
+   */
+  static assignParamsToUrl(url: string, params: XGenericObject, type?: 'query' | 'path'): string;
+  /**
+   * Builds the target url by assigning both path and query parameters
+   *
+   * @param path
+   * @param params
+   * @param queryParams
+   * @returns
+   */
+  static buildTargetUrl(path: string, params?: XGenericObject, queryParams?: XGenericObject): string;
+  /**
+   * Encrypts specified keys in the input object and returns a new object with
+   * encrypted values.
+   *
+   * @param input             The input object containing the data to be encrypted.
+   * @param keysToEncrypt     The keys in the input object that should be encrypted.
+   * @param outputMapping     A mapping of input keys to output keys for the encrypted values.
+   * @returns                 A new object with the specified keys encrypted.
+   */
+  static encryptDetails<X extends XGenericObject>(input: Partial<X>, keysToEncrypt?: (keyof X)[], outputMapping?: Partial<Record<keyof X, string>>): Promise<X>;
+  /**
+   * Encrypts data using AES-GCM encryption
+   * @param data
+   * @param token
+   * @param nonce
+   * @returns
+   */
+  static encryptAES(data: string, token: string, nonce: string): Promise<string>;
+}
+//#endregion
+//#region src/Core.d.ts
+declare class Core {
+  static apiClass: typeof BaseApi;
+  debugLevel: number;
+  /**
+   * Client ID
+   */
+  private clientId;
+  /**
+   * Client Secret
+   */
+  private clientSecret;
+  /**
+   * Flutterwave Environment
+   */
+  private environment;
+  private accessValidator?;
+  /**
+   * API Instance
+   */
+  api: BaseApi;
+  /**
+   * Builder Instance
+   */
+  builder: typeof Builder;
+  /**
+   * Creates an instance of Core.
+   *
+   * @param clientId
+   * @param clientSecret
+   * @param encryptionKey
+   */
+  constructor(clientId?: InitOptions);
+  constructor(clientId?: string, clientSecret?: string, encryptionKey?: string, env?: 'sandbox' | 'live');
+  protected createApi(): BaseApi;
+  /**
+   * Initializes the Core instance
+   *
+   * @param clientId
+   * @param clientSecret
+   * @param encryptionKey
+   * @param accessToken
+   * @returns
+   */
+  init(clientId?: InitOptions): this;
+  init(clientId?: string, clientSecret?: string, encryptionKey?: string, env?: 'sandbox' | 'live'): this;
+  /**
+   * Set the debug level
+   *
+   * @param level
+   * @returns
+   */
+  debug(level?: number): this;
+  /**
+   * Get the current environment
+   *
+   * @returns
+   */
+  getEnvironment(): "sandbox" | "live";
+  /**
+   * Set access validator function
+   *
+   * @param validator Function to validate access
+   */
+  setAccessValidator(validator: (...args: any[]) => Promise<boolean | string>): void;
+  /**
+   * Validates access using the provided access validator function
+   *
+   * @throws Error if validation fails
+   */
+  validateAccess(): Promise<void>;
+  /**
+   * Use a manifest bundle to create the API instance
+   *
+   * @param bundle
+   * @returns
+   */
+  useDocument<TBundle extends RuntimeSdkBundle>(bundle: TBundle): this & {
+    api: BaseApi & InferRuntimeSdkApi<TBundle>;
+  };
+  /**
+   * Use a manifest bundle to create the API instance (alias for useDocument).
+   *
+   * @param bundle
+   * @returns
+   */
+  useSdk<TBundle extends RuntimeSdkBundle>(bundle: TBundle): this & {
+    api: BaseApi & InferRuntimeSdkApi<TBundle>;
+  };
+}
+//#endregion
+//#region src/Exceptions/ForbiddenRequestException.d.ts
+declare class ForbiddenRequestException extends Error {
+  statusCode: number;
+  type: string;
+  code: string | number;
+  data: ErrorResponse;
+  constructor(data?: ErrorResponse);
+}
+//#endregion
+//#region src/Exceptions/UnauthorizedRequestException.d.ts
+declare class UnauthorizedRequestException extends Error {
+  statusCode: number;
+  type: string;
+  code: string | number;
+  data: ErrorResponse;
+  constructor(data?: ErrorResponse);
+}
+//#endregion
+//#region src/Exceptions/HttpException.d.ts
+declare class HttpException extends Error {
+  data: UnifiedResponse;
+  statusCode: number;
+  parent?: Error;
+  constructor(data: UnifiedResponse, statusCode?: number, parent?: Error);
+  /**
+   * Create an exception from status code
+   *
+   * @param code
+   * @param data
+   */
+  static fromCode(code: number, data: Required<UnifiedResponse>, parent?: Error): BadRequestException | UnauthorizedRequestException | HttpException | ForbiddenRequestException;
+}
+//#endregion
+//#region src/Apis/BaseApi.d.ts
+declare class BaseApi {
+  #private;
+  private lastException?;
+  /**
+   * Create a BaseApi instance
+   *
+   * @param coreInstance Core instance
+   */
+  constructor(coreInstance: Core);
+  /**
+   * Get the owning core instance for SDK-specific API bootstrapping.
+   */
+  protected get core(): Core;
+  /**
+   * Hook for SDK-specific API registration.
+   */
+  protected boot(): void;
+  /**
+   * Set access validator function
+   *
+   * @param validator
+   */
+  setAccessValidator(validator: (...args: any[]) => Promise<boolean | string>): void;
+  /**
+   * Get the last exception
+   *
+   * @returns
+   */
+  getLastException(): BadRequestException | ForbiddenRequestException | UnauthorizedRequestException | HttpException | undefined;
+  /**
+   * Set the last exception
+   *
+   * @param exception
+   */
+  setLastException(exception: BadRequestException | ForbiddenRequestException | UnauthorizedRequestException | HttpException): void;
+  /**
+   * Initialize BaseApi and its sub-APIs
+   *
+   * @param coreInstance Core instance
+   * @returns
+   */
+  static initialize<T extends BaseApi>(this: new (coreInstance: Core) => T, coreInstance: Core): T;
+}
+//#endregion
+//#region src/global.d.ts
+declare global {
+  interface String {
+    /**
+     * Convert a string to Kebab Case
+     *
+     * @returns
+     */
+    toKebabCase(): string;
+    /**
+     * Convert a string to camel Case
+     *
+     * @returns
+     */
+    toCamelCase(): string;
+    /**
+     * Convert a string to Pascal Case
+     *
+     * @returns
+     */
+    toPascalCase(): string;
+    /**
+     * Convert a string to Snake Case
+     *
+     * @returns
+     */
+    toSnakeCase(): string;
+    /**
+     * Convert a string to Title Case
+     *
+     * @returns
+     */
+    toTitleCase(): string;
+    /**
+     * Convert a string to Clean Case
+     * We will format a string by replacing underscores and hyphens with spaces,
+     * capitalizing the first letter of every word,
+     * converting camelCase to spaced words,
+     * and trimming any leading or trailing spaces.
+     * If a sentence is only two letters long we will make it uppercase.
+     *
+     * @returns
+     */
+    toCleanCase(): string;
+    /**
+     * Convert a string to Slug Case
+     *
+     * @returns
+     */
+    toSlug(separator?: string): string;
+    /**
+     * Truncate a string to n characters
+     *
+     * @param n
+     */
+    truncate(n: number): string;
+  }
+}
+//#endregion
+//#region src/Http.d.ts
+declare class Http {
+  private headers;
+  private body?;
+  /**
+   * Bearer token
+   */
+  private static bearerToken;
+  /**
+   * Debug level
+   */
+  private static debugLevel;
+  private static apiInstance;
+  /**
+   * Creates an instance of Http.
+   *
+   * @param method
+   * @param url
+   * @param headers
+   * @param body
+   */
+  constructor(headers?: RawAxiosRequestHeaders, body?: any | undefined);
+  /**
+   * Set the debug level
+   *
+   * @param debug
+   */
+  static setDebugLevel(level?: number): void;
+  /**
+   * Set the API instance
+   *
+   * @param api
+   */
+  static setApiInstance(api: BaseApi): void;
+  /**
+   * Set the bearer token
+   *
+   * @param token
+   */
+  static setBearerToken(token: string): void;
+  setDefaultHeaders(defaults: Record<string, string>): void;
+  getHeaders(): RawAxiosRequestHeaders;
+  getBody(): any;
+  axiosApi(): axios0.AxiosInstance;
+  /**
+   * Makes a GET request
+   *
+   * @param url
+   * @param headers
+   * @param params
+   * @returns
+   */
+  static get<R = any, M extends XGenericObject = XGenericObject>(url: string, params?: XGenericObject, headers?: RawAxiosRequestHeaders): Promise<UnifiedResponse<R, M>>;
+  /**
+   *
+   *
+   * @param url
+   * @param headers
+   * @param params
+   * @returns
+   */
+  static send<R = any, M extends XGenericObject = XGenericObject>(url: string, method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', body?: any, headers?: RawAxiosRequestHeaders, params?: XGenericObject): Promise<UnifiedResponse<R, M>>;
+  /**
+   * Create an HttpException from status and error
+   *
+   * @param status
+   * @param error
+   * @returns
+   */
+  private static exception;
+}
+//#endregion
+//#region src/RuntimeSdk.d.ts
+declare const createRuntimeApi: <TBundle extends {
+  manifest: RuntimeSdkManifest;
+}>(core: Core, bundle: TBundle) => BaseApi & InferRuntimeSdkApi<TBundle>;
+declare const createSdk: <TBundle extends RuntimeSdkBundle>(bundle: TBundle, options: InitOptions) => Core & {
+  api: BaseApi & InferRuntimeSdkApi<TBundle>;
+};
+//#endregion
+//#region src/utilities/helpers.d.ts
+/**
+ * Takes a value like the one prodvided in a destructuring assignment where for instance
+ * a single value might have been provided as opposed to an array of values and
+ * normalizes it.
+ *
+ * Examples:
+ * Definition:
+ * (...value: string[]) => normalizeValue(value)
+ *
+ * Usage:
+ * normalizeValue('singleValue') // returns ['singleValue']
+ * normalizeValue('value1', 'value2') // returns ['value1', 'value2']
+ * normalizeValue(['value1', 'value2']) // returns ['value1', 'value2']
+ *
+ * @param value
+ * @returns
+ */
+declare const normalizeValue: <T>(value: T | T[]) => T[];
+/**
+ * Builds a full url based on endpoint provided
+ *
+ * @param baseUrl
+ * @param endpoint
+ *
+ * @returns
+ */
+declare const buildUrl: (baseUrl: string, ...endpoint: string[]) => string;
+//#endregion
+//#region src/utilities/Manager.d.ts
+declare const defaultConfig: UserConfig;
+declare let globalConfig: UserConfig;
+declare const defineConfig: (config: Partial<UserConfig>) => UserConfig;
+//#endregion
+//#region src/utilities/WebhookValidator.d.ts
+declare class WebhookValidator<Options extends XGenericObject = XGenericObject> {
+  private secretHash?;
+  algorithm: 'sha256' | 'sha512' | 'sha1';
+  encoding: 'base64' | 'hex';
+  /**
+   * @param secretHash
+   * @param options
+   */
+  constructor(secretHash?: string | undefined, options?: Options);
+  /**
+   * Validate webhook signature
+   * @param rawBody - Raw request body as string
+   * @param signature - Signature from request header
+   * @returns {boolean} - True if signature is valid
+   */
+  validate(rawBody: string, signature: string): boolean;
+  /**
+   * Generate signature for testing/verification
+   * @param rawBody - Raw request body as string
+   * @returns {string} - Generated signature
+   */
+  generateSignature(rawBody: string): string;
+  /**
+   * Async version of validate (for large payloads)
+   *
+   * @param rawBody
+   * @param signature
+   * @returns {Promise<boolean>}
+   */
+  validateAsync(rawBody: string, signature: string): boolean;
+  /**
+   * Get current configuration
+   */
+  getConfig(): {
+    algorithm: "sha256" | "sha512" | "sha1";
+    encoding: "base64" | "hex";
+    secretHashLength: number | undefined;
+  };
+}
+//#endregion
+export { AuthErrorResponse, AuthResponse, BadRequestException, BaseApi, Builder, Core, CountryCode, CountryCodeRestricted, CurrencyCode, CursorPagination, ErrorResponse, ForbiddenRequestException, Http, HttpException, InferRuntimeSdkApi, InitOptions, NormalPagination, PageInfoMeta, Response, ResponseStatus, RuntimeSdkBundle, RuntimeSdkGroupManifest, RuntimeSdkManifest, RuntimeSdkOperationManifest, RuntimeSdkParameterManifest, SuccessResponse, UnauthorizedRequestException, UnifiedResponse, UserConfig, ValidationError, ValidationErrorResponse, WebhookValidator, XGenericObject, buildUrl, createRuntimeApi, createSdk, defaultConfig, defineConfig, globalConfig, normalizeValue };