@harnessio/react-integration-service-client 0.0.0-stage → 0.0.1

package/README.md

@@ -1,3 +1,39 @@
-# Temporary Holding Version
+# React Integration Service Client
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**OpenAPI -> OA**
+
+**TypeScript -> TS**
+
+**OpenAPI + TypeScript -> OATS**
+
+This React API client will store a collection of Harness Integration Service APIs and Interfaces contracts generated from Open API Spec using `OATS CLI` internally.
+APIs are using hooks from `@tanstack/react-query`
+
+## Steps To Generate API Client build as dist folder
+
+```
+yarn build
+```
+
+## For NextGen UI adoption : IntegrationServiceAPIClient should be initialized
+
+Before using API Client, it must be initialized with required `ClientCallbacks`.
+
+Example:
+
+```
+ new IntegrationServiceAPIClient({
+    getHeaders: () => {
+        return { token: SessionToken.getToken(), 'Harness-Account': accountId }
+    }}
+```
+
+## Versioning
+
+![@harnessio/react-integration-service-client](https://img.shields.io/npm/v/@harnessio/react-integration-service-client.svg?style=flat-square)
+
+Once development phase is completed, this repo will have changes and versioning driven by API spec only.
+
+## License
+
+[MIT](./LICENSE.md). Copyright(c) [Harness Inc](https://harness.io)

package/dist/fetcher/index.d.ts

@@ -0,0 +1,17 @@
+import type { IStringifyOptions } from 'qs';
+export interface FetcherOptions<TQueryParams = never, TBody = never, THeaderParams = HeadersInit> extends Omit<RequestInit, 'body' | 'headers'> {
+    url: string;
+    queryParams?: TQueryParams extends never ? undefined : TQueryParams;
+    body?: TBody extends never ? undefined : TBody;
+    stringifyQueryParamsOptions?: IStringifyOptions;
+    headers?: THeaderParams;
+}
+export interface ClientCallbacks {
+    responseInterceptor?: (response: Response) => Response;
+    requestInterceptor?: (request: Request) => Request;
+    urlInterceptor?: (url: string) => string;
+    getRequestHeaders?: () => Record<string, any>;
+}
+export declare function setupClient(callbacks: ClientCallbacks): void;
+export declare const updateClientHeaders: (headers: Record<string, any>) => void;
+export declare function fetcher<TResponse = unknown, TQueryParams = never, TBody = never, THeaderParams = HeadersInit>(options: FetcherOptions<TQueryParams, TBody, THeaderParams>): Promise<TResponse>;

package/dist/fetcher/index.js

@@ -0,0 +1,65 @@
+import { __awaiter, __rest } from "tslib";
+import { stringify } from 'qs';
+const JSON_CONTENT_TYPES = ['application/json'];
+let APIClientInitialized = false;
+let fetcherCallbacks;
+let customHeaders = {
+    'Content-Type': JSON_CONTENT_TYPES[0],
+};
+export function setupClient(callbacks) {
+    fetcherCallbacks = callbacks;
+    customHeaders = Object.assign(Object.assign({}, customHeaders), ((fetcherCallbacks === null || fetcherCallbacks === void 0 ? void 0 : fetcherCallbacks.getRequestHeaders) ? fetcherCallbacks === null || fetcherCallbacks === void 0 ? void 0 : fetcherCallbacks.getRequestHeaders() : {}));
+    APIClientInitialized = true;
+}
+export const updateClientHeaders = (headers) => {
+    customHeaders = Object.assign(Object.assign({}, customHeaders), headers);
+};
+export function fetcher(options) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        // If not initialized throw error even without making request
+        if (!APIClientInitialized) {
+            throw { reason: 'HarnessReactAPIClient has not been initialized' };
+        }
+        const { stringifyQueryParamsOptions, headers, body, url, queryParams = { account: customHeaders['Harness-Account'] } } = options, rest = __rest(options, ["stringifyQueryParamsOptions", "headers", "body", "url", "queryParams"]);
+        const token = customHeaders.token;
+        let finalUrl = url;
+        if (queryParams) {
+            finalUrl += stringify(queryParams, Object.assign(Object.assign({}, stringifyQueryParamsOptions), { addQueryPrefix: true }));
+        }
+        if (fetcherCallbacks === null || fetcherCallbacks === void 0 ? void 0 : fetcherCallbacks.urlInterceptor) {
+            finalUrl = (_a = fetcherCallbacks === null || fetcherCallbacks === void 0 ? void 0 : fetcherCallbacks.urlInterceptor) === null || _a === void 0 ? void 0 : _a.call(fetcherCallbacks, finalUrl);
+        }
+        let request = new Request(finalUrl, Object.assign({ headers: Object.assign(Object.assign(Object.assign({}, (token ? { Authorization: `Bearer ${token}` } : {})), headers), customHeaders), body: body ? JSON.stringify(body) : undefined }, rest));
+        if (fetcherCallbacks === null || fetcherCallbacks === void 0 ? void 0 : fetcherCallbacks.requestInterceptor) {
+            request = fetcherCallbacks.requestInterceptor(request.clone());
+        }
+        let response = yield fetch(request);
+        if (fetcherCallbacks === null || fetcherCallbacks === void 0 ? void 0 : fetcherCallbacks.responseInterceptor) {
+            response = (_b = fetcherCallbacks === null || fetcherCallbacks === void 0 ? void 0 : fetcherCallbacks.responseInterceptor) === null || _b === void 0 ? void 0 : _b.call(fetcherCallbacks, response.clone());
+        }
+        const contentType = response.headers.get('Content-Type');
+        let total, pageSize, pageNumber, pageCount, pagination;
+        try {
+            total = response.headers.get('x-total-elements');
+            pageSize = response.headers.get('x-page-size');
+            pageNumber = response.headers.get('x-page-number');
+            pagination = total || pageSize || pageNumber;
+            if (pagination) {
+                total = Number(total);
+                pageSize = Number(pageSize);
+                pageCount = Math.ceil(total / pageSize);
+                pageNumber = Number(pageNumber);
+            }
+        }
+        catch (e) {
+            throw new Error('HarnessReactAPIClient: An error occurred while parsing pagination headers. ' + e);
+        }
+        const asJson = contentType && JSON_CONTENT_TYPES.some((h) => contentType.startsWith(h));
+        const data = yield (asJson ? response.json() : response.text());
+        if (response.ok) {
+            return Object.assign({ content: data }, (pagination ? { pagination: { total, pageCount, pageSize, pageNumber } } : {}));
+        }
+        throw data;
+    });
+}

package/dist/integration-service/src/index.d.ts

@@ -0,0 +1,6 @@
+import { ClientCallbacks } from '../../fetcher';
+export * from './services/index';
+export declare class IntegrationServiceAPIClient {
+    updateHeaders: (headers: Record<string, any>) => void;
+    constructor(callbacks: ClientCallbacks);
+}

package/dist/integration-service/src/index.js

@@ -0,0 +1,10 @@
+import { setupClient, updateClientHeaders } from '../../fetcher';
+export * from './services/index';
+export class IntegrationServiceAPIClient {
+    constructor(callbacks) {
+        setupClient(callbacks);
+        this.updateHeaders = (headers) => {
+            updateClientHeaders(headers);
+        };
+    }
+}

package/dist/integration-service/src/services/helpers.d.ts

@@ -0,0 +1,14 @@
+export type GetPathParamsType<T> = T extends {
+    pathParams: infer R;
+} ? R : never;
+export interface ResponseWithPagination<T> {
+    content: T;
+    pagination?: {
+        total?: number;
+        pageSize?: number;
+        pageCount?: number;
+        pageNumber?: number;
+    };
+}
+export type WithOptional<TInput, Tkeys extends keyof TInput> = Omit<TInput, Tkeys> & Partial<Pick<TInput, Tkeys>>;
+export type PickPartial<TInput, Tkeys extends keyof TInput> = Pick<Partial<TInput>, Tkeys>;

package/dist/integration-service/src/services/helpers.js

@@ -0,0 +1 @@
+export {};

package/dist/integration-service/src/services/hooks/useCancelIngestionRunMutation.d.ts

@@ -0,0 +1,16 @@
+import { UseMutationOptions } from '@tanstack/react-query';
+import type { Run } from '../schemas/Run';
+import type { ResponseWithPagination } from '../helpers';
+import { FetcherOptions } from '../../../../fetcher/index.js';
+export interface CancelIngestionRunMutationPathParams {
+    id: string;
+}
+export interface CancelIngestionRunMutationHeaderParams {
+    'Harness-Account': string;
+}
+export type CancelIngestionRunOkResponse = ResponseWithPagination<Run>;
+export type CancelIngestionRunErrorResponse = unknown;
+export interface CancelIngestionRunProps extends CancelIngestionRunMutationPathParams, Omit<FetcherOptions<unknown, unknown, CancelIngestionRunMutationHeaderParams>, 'url'> {
+}
+export declare function cancelIngestionRun(props: CancelIngestionRunProps): Promise<CancelIngestionRunOkResponse>;
+export declare function useCancelIngestionRunMutation(options?: Omit<UseMutationOptions<CancelIngestionRunOkResponse, CancelIngestionRunErrorResponse, CancelIngestionRunProps>, 'mutationKey' | 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<CancelIngestionRunOkResponse, unknown, CancelIngestionRunProps, unknown>;

package/dist/integration-service/src/services/hooks/useCancelIngestionRunMutation.js

@@ -0,0 +1,11 @@
+/* eslint-disable */
+// This code is autogenerated using @harnessio/oats-cli.
+// Please do not modify this code directly.
+import { useMutation } from '@tanstack/react-query';
+import { fetcher } from '../../../../fetcher/index.js';
+export function cancelIngestionRun(props) {
+    return fetcher(Object.assign({ url: `/v1/ingestion/runs/${props.id}/cancel`, method: 'POST' }, props));
+}
+export function useCancelIngestionRunMutation(options) {
+    return useMutation((mutateProps) => cancelIngestionRun(mutateProps), options);
+}

package/dist/integration-service/src/services/hooks/useCheckIntegrationRefMutation.d.ts

@@ -0,0 +1,42 @@
+import { UseMutationOptions } from '@tanstack/react-query';
+import type { Result } from '../schemas/Result';
+import type { JsonNode } from '../schemas/JsonNode';
+import type { GetPathParamsType, ResponseWithPagination } from '../helpers';
+import { FetcherOptions } from '../../../../fetcher/index.js';
+export interface CheckIntegrationRefAccountPathParams {
+    integration: string;
+}
+export interface CheckIntegrationRefAccountHeaderParams {
+    'Harness-Account': string;
+}
+export type CheckIntegrationRefAccountRequestBody = JsonNode;
+export type CheckIntegrationRefAccountOKResponse = Result;
+export type CheckIntegrationRefAccountErrorResponse = unknown;
+export interface CheckIntegrationRefOrgPathParams {
+    org: string;
+    integration: string;
+}
+export interface CheckIntegrationRefOrgHeaderParams {
+    'Harness-Account': string;
+}
+export type CheckIntegrationRefOrgRequestBody = JsonNode;
+export type CheckIntegrationRefOrgOKResponse = Result;
+export type CheckIntegrationRefOrgErrorResponse = unknown;
+export interface CheckIntegrationRefProjectPathParams {
+    org: string;
+    project: string;
+    integration: string;
+}
+export interface CheckIntegrationRefProjectHeaderParams {
+    'Harness-Account': string;
+}
+export type CheckIntegrationRefProjectRequestBody = JsonNode;
+export type CheckIntegrationRefProjectOKResponse = Result;
+export type CheckIntegrationRefProjectErrorResponse = unknown;
+export type CheckIntegrationRefOKResponse<T> = T extends CheckIntegrationRefProjectPathParams ? ResponseWithPagination<CheckIntegrationRefProjectOKResponse> : T extends CheckIntegrationRefOrgPathParams ? ResponseWithPagination<CheckIntegrationRefOrgOKResponse> : ResponseWithPagination<CheckIntegrationRefAccountOKResponse>;
+export type CheckIntegrationRefErrorResponse<T> = T extends CheckIntegrationRefProjectPathParams ? CheckIntegrationRefProjectErrorResponse : T extends CheckIntegrationRefOrgPathParams ? CheckIntegrationRefOrgErrorResponse : CheckIntegrationRefAccountErrorResponse;
+export interface CheckIntegrationRefProps extends Omit<FetcherOptions<unknown, unknown>, 'url'> {
+    pathParams: CheckIntegrationRefAccountPathParams | CheckIntegrationRefOrgPathParams | CheckIntegrationRefProjectPathParams;
+}
+export declare function checkIntegrationRef<T extends CheckIntegrationRefProps = CheckIntegrationRefProps>(props: T): Promise<CheckIntegrationRefOKResponse<GetPathParamsType<T>>>;
+export declare function useCheckIntegrationRefMutation(options?: Omit<UseMutationOptions<CheckIntegrationRefOKResponse<unknown>, CheckIntegrationRefErrorResponse<unknown>, CheckIntegrationRefProps>, 'mutationKey' | 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<ResponseWithPagination<Result>, unknown, CheckIntegrationRefProps, unknown>;

package/dist/integration-service/src/services/hooks/useCheckIntegrationRefMutation.js

@@ -0,0 +1,30 @@
+/* eslint-disable */
+// This code is autogenerated using @harnessio/oats-cli.
+// Please do not modify this code directly.
+import { useMutation } from '@tanstack/react-query';
+import { fetcher } from '../../../../fetcher/index.js';
+function isProjectPathParams(pathParams) {
+    return !!(pathParams.org &&
+        pathParams.project);
+}
+function isOrgPathParams(pathParams) {
+    return !!(pathParams.org &&
+        !pathParams.project);
+}
+export function checkIntegrationRef(props) {
+    let url = `/v1/integrations/${props.pathParams.integration}/check`;
+    let method = 'POST';
+    if (isProjectPathParams(props.pathParams)) {
+        url = `/v1/orgs/${props.pathParams.org}/projects/${props.pathParams.project}/integrations/${props.pathParams.integration}/check`;
+        method = 'POST';
+    }
+    else if (isOrgPathParams(props.pathParams)) {
+        url = `/v1/orgs/${props.pathParams.org}/integrations/${props.pathParams.integration}/check`;
+        method = 'POST';
+    }
+    return fetcher(Object.assign({ url,
+        method }, props));
+}
+export function useCheckIntegrationRefMutation(options) {
+    return useMutation((mutateProps) => checkIntegrationRef(mutateProps), options);
+}

package/dist/integration-service/src/services/hooks/useClearDefaultIntegrationJobRefMutation.d.ts

@@ -0,0 +1,41 @@
+import { UseMutationOptions } from '@tanstack/react-query';
+import type { JobView } from '../schemas/JobView';
+import type { GetPathParamsType, ResponseWithPagination } from '../helpers';
+import { FetcherOptions } from '../../../../fetcher/index.js';
+export interface ClearDefaultIntegrationJobRefAccountPathParams {
+    integration: string;
+    job: string;
+}
+export interface ClearDefaultIntegrationJobRefAccountHeaderParams {
+    'Harness-Account': string;
+}
+export type ClearDefaultIntegrationJobRefAccountOKResponse = JobView;
+export type ClearDefaultIntegrationJobRefAccountErrorResponse = unknown;
+export interface ClearDefaultIntegrationJobRefOrgPathParams {
+    org: string;
+    integration: string;
+    job: string;
+}
+export interface ClearDefaultIntegrationJobRefOrgHeaderParams {
+    'Harness-Account': string;
+}
+export type ClearDefaultIntegrationJobRefOrgOKResponse = JobView;
+export type ClearDefaultIntegrationJobRefOrgErrorResponse = unknown;
+export interface ClearDefaultIntegrationJobRefProjectPathParams {
+    org: string;
+    project: string;
+    integration: string;
+    job: string;
+}
+export interface ClearDefaultIntegrationJobRefProjectHeaderParams {
+    'Harness-Account': string;
+}
+export type ClearDefaultIntegrationJobRefProjectOKResponse = JobView;
+export type ClearDefaultIntegrationJobRefProjectErrorResponse = unknown;
+export type ClearDefaultIntegrationJobRefOKResponse<T> = T extends ClearDefaultIntegrationJobRefProjectPathParams ? ResponseWithPagination<ClearDefaultIntegrationJobRefProjectOKResponse> : T extends ClearDefaultIntegrationJobRefOrgPathParams ? ResponseWithPagination<ClearDefaultIntegrationJobRefOrgOKResponse> : ResponseWithPagination<ClearDefaultIntegrationJobRefAccountOKResponse>;
+export type ClearDefaultIntegrationJobRefErrorResponse<T> = T extends ClearDefaultIntegrationJobRefProjectPathParams ? ClearDefaultIntegrationJobRefProjectErrorResponse : T extends ClearDefaultIntegrationJobRefOrgPathParams ? ClearDefaultIntegrationJobRefOrgErrorResponse : ClearDefaultIntegrationJobRefAccountErrorResponse;
+export interface ClearDefaultIntegrationJobRefProps extends Omit<FetcherOptions<unknown, unknown>, 'url'> {
+    pathParams: ClearDefaultIntegrationJobRefAccountPathParams | ClearDefaultIntegrationJobRefOrgPathParams | ClearDefaultIntegrationJobRefProjectPathParams;
+}
+export declare function clearDefaultIntegrationJobRef<T extends ClearDefaultIntegrationJobRefProps = ClearDefaultIntegrationJobRefProps>(props: T): Promise<ClearDefaultIntegrationJobRefOKResponse<GetPathParamsType<T>>>;
+export declare function useClearDefaultIntegrationJobRefMutation(options?: Omit<UseMutationOptions<ClearDefaultIntegrationJobRefOKResponse<unknown>, ClearDefaultIntegrationJobRefErrorResponse<unknown>, ClearDefaultIntegrationJobRefProps>, 'mutationKey' | 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<ResponseWithPagination<JobView>, unknown, ClearDefaultIntegrationJobRefProps, unknown>;

package/dist/integration-service/src/services/hooks/useClearDefaultIntegrationJobRefMutation.js

@@ -0,0 +1,30 @@
+/* eslint-disable */
+// This code is autogenerated using @harnessio/oats-cli.
+// Please do not modify this code directly.
+import { useMutation } from '@tanstack/react-query';
+import { fetcher } from '../../../../fetcher/index.js';
+function isProjectPathParams(pathParams) {
+    return !!(pathParams.org &&
+        pathParams.project);
+}
+function isOrgPathParams(pathParams) {
+    return !!(pathParams.org &&
+        !pathParams.project);
+}
+export function clearDefaultIntegrationJobRef(props) {
+    let url = `/v1/integrations/${props.pathParams.integration}/jobs/${props.pathParams.job}/default`;
+    let method = 'DELETE';
+    if (isProjectPathParams(props.pathParams)) {
+        url = `/v1/orgs/${props.pathParams.org}/projects/${props.pathParams.project}/integrations/${props.pathParams.integration}/jobs/${props.pathParams.job}/default`;
+        method = 'DELETE';
+    }
+    else if (isOrgPathParams(props.pathParams)) {
+        url = `/v1/orgs/${props.pathParams.org}/integrations/${props.pathParams.integration}/jobs/${props.pathParams.job}/default`;
+        method = 'DELETE';
+    }
+    return fetcher(Object.assign({ url,
+        method }, props));
+}
+export function useClearDefaultIntegrationJobRefMutation(options) {
+    return useMutation((mutateProps) => clearDefaultIntegrationJobRef(mutateProps), options);
+}

package/dist/integration-service/src/services/hooks/useCreateIntegrationJobRefMutation.d.ts

@@ -0,0 +1,42 @@
+import { UseMutationOptions } from '@tanstack/react-query';
+import type { JobView } from '../schemas/JobView';
+import type { JsonNode } from '../schemas/JsonNode';
+import type { GetPathParamsType, ResponseWithPagination } from '../helpers';
+import { FetcherOptions } from '../../../../fetcher/index.js';
+export interface CreateIntegrationJobRefAccountPathParams {
+    integration: string;
+}
+export interface CreateIntegrationJobRefAccountHeaderParams {
+    'Harness-Account': string;
+}
+export type CreateIntegrationJobRefAccountRequestBody = JsonNode;
+export type CreateIntegrationJobRefAccountOKResponse = JobView;
+export type CreateIntegrationJobRefAccountErrorResponse = unknown;
+export interface CreateIntegrationJobRefOrgPathParams {
+    org: string;
+    integration: string;
+}
+export interface CreateIntegrationJobRefOrgHeaderParams {
+    'Harness-Account': string;
+}
+export type CreateIntegrationJobRefOrgRequestBody = JsonNode;
+export type CreateIntegrationJobRefOrgOKResponse = JobView;
+export type CreateIntegrationJobRefOrgErrorResponse = unknown;
+export interface CreateIntegrationJobRefProjectPathParams {
+    org: string;
+    project: string;
+    integration: string;
+}
+export interface CreateIntegrationJobRefProjectHeaderParams {
+    'Harness-Account': string;
+}
+export type CreateIntegrationJobRefProjectRequestBody = JsonNode;
+export type CreateIntegrationJobRefProjectOKResponse = JobView;
+export type CreateIntegrationJobRefProjectErrorResponse = unknown;
+export type CreateIntegrationJobRefOKResponse<T> = T extends CreateIntegrationJobRefProjectPathParams ? ResponseWithPagination<CreateIntegrationJobRefProjectOKResponse> : T extends CreateIntegrationJobRefOrgPathParams ? ResponseWithPagination<CreateIntegrationJobRefOrgOKResponse> : ResponseWithPagination<CreateIntegrationJobRefAccountOKResponse>;
+export type CreateIntegrationJobRefErrorResponse<T> = T extends CreateIntegrationJobRefProjectPathParams ? CreateIntegrationJobRefProjectErrorResponse : T extends CreateIntegrationJobRefOrgPathParams ? CreateIntegrationJobRefOrgErrorResponse : CreateIntegrationJobRefAccountErrorResponse;
+export interface CreateIntegrationJobRefProps extends Omit<FetcherOptions<unknown, unknown>, 'url'> {
+    pathParams: CreateIntegrationJobRefAccountPathParams | CreateIntegrationJobRefOrgPathParams | CreateIntegrationJobRefProjectPathParams;
+}
+export declare function createIntegrationJobRef<T extends CreateIntegrationJobRefProps = CreateIntegrationJobRefProps>(props: T): Promise<CreateIntegrationJobRefOKResponse<GetPathParamsType<T>>>;
+export declare function useCreateIntegrationJobRefMutation(options?: Omit<UseMutationOptions<CreateIntegrationJobRefOKResponse<unknown>, CreateIntegrationJobRefErrorResponse<unknown>, CreateIntegrationJobRefProps>, 'mutationKey' | 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<ResponseWithPagination<JobView>, unknown, CreateIntegrationJobRefProps, unknown>;

package/dist/integration-service/src/services/hooks/useCreateIntegrationJobRefMutation.js

@@ -0,0 +1,30 @@
+/* eslint-disable */
+// This code is autogenerated using @harnessio/oats-cli.
+// Please do not modify this code directly.
+import { useMutation } from '@tanstack/react-query';
+import { fetcher } from '../../../../fetcher/index.js';
+function isProjectPathParams(pathParams) {
+    return !!(pathParams.org &&
+        pathParams.project);
+}
+function isOrgPathParams(pathParams) {
+    return !!(pathParams.org &&
+        !pathParams.project);
+}
+export function createIntegrationJobRef(props) {
+    let url = `/v1/integrations/${props.pathParams.integration}/jobs`;
+    let method = 'POST';
+    if (isProjectPathParams(props.pathParams)) {
+        url = `/v1/orgs/${props.pathParams.org}/projects/${props.pathParams.project}/integrations/${props.pathParams.integration}/jobs`;
+        method = 'POST';
+    }
+    else if (isOrgPathParams(props.pathParams)) {
+        url = `/v1/orgs/${props.pathParams.org}/integrations/${props.pathParams.integration}/jobs`;
+        method = 'POST';
+    }
+    return fetcher(Object.assign({ url,
+        method }, props));
+}
+export function useCreateIntegrationJobRefMutation(options) {
+    return useMutation((mutateProps) => createIntegrationJobRef(mutateProps), options);
+}

package/dist/integration-service/src/services/hooks/useCreateIntegrationRefMutation.d.ts

@@ -0,0 +1,39 @@
+import { UseMutationOptions } from '@tanstack/react-query';
+import type { IntegrationResponse } from '../schemas/IntegrationResponse';
+import type { IntegrationRequest } from '../schemas/IntegrationRequest';
+import type { GetPathParamsType, ResponseWithPagination } from '../helpers';
+import { FetcherOptions } from '../../../../fetcher/index.js';
+export interface CreateIntegrationRefAccountPathParams {
+}
+export interface CreateIntegrationRefAccountHeaderParams {
+    'Harness-Account': string;
+}
+export type CreateIntegrationRefAccountRequestBody = IntegrationRequest;
+export type CreateIntegrationRefAccountOKResponse = IntegrationResponse;
+export type CreateIntegrationRefAccountErrorResponse = unknown;
+export interface CreateIntegrationRefOrgPathParams {
+    org: string;
+}
+export interface CreateIntegrationRefOrgHeaderParams {
+    'Harness-Account': string;
+}
+export type CreateIntegrationRefOrgRequestBody = IntegrationRequest;
+export type CreateIntegrationRefOrgOKResponse = IntegrationResponse;
+export type CreateIntegrationRefOrgErrorResponse = unknown;
+export interface CreateIntegrationRefProjectPathParams {
+    org: string;
+    project: string;
+}
+export interface CreateIntegrationRefProjectHeaderParams {
+    'Harness-Account': string;
+}
+export type CreateIntegrationRefProjectRequestBody = IntegrationRequest;
+export type CreateIntegrationRefProjectOKResponse = IntegrationResponse;
+export type CreateIntegrationRefProjectErrorResponse = unknown;
+export type CreateIntegrationRefOKResponse<T> = T extends CreateIntegrationRefProjectPathParams ? ResponseWithPagination<CreateIntegrationRefProjectOKResponse> : T extends CreateIntegrationRefOrgPathParams ? ResponseWithPagination<CreateIntegrationRefOrgOKResponse> : ResponseWithPagination<CreateIntegrationRefAccountOKResponse>;
+export type CreateIntegrationRefErrorResponse<T> = T extends CreateIntegrationRefProjectPathParams ? CreateIntegrationRefProjectErrorResponse : T extends CreateIntegrationRefOrgPathParams ? CreateIntegrationRefOrgErrorResponse : CreateIntegrationRefAccountErrorResponse;
+export interface CreateIntegrationRefProps extends Omit<FetcherOptions<unknown, unknown>, 'url'> {
+    pathParams: CreateIntegrationRefAccountPathParams | CreateIntegrationRefOrgPathParams | CreateIntegrationRefProjectPathParams;
+}
+export declare function createIntegrationRef<T extends CreateIntegrationRefProps = CreateIntegrationRefProps>(props: T): Promise<CreateIntegrationRefOKResponse<GetPathParamsType<T>>>;
+export declare function useCreateIntegrationRefMutation(options?: Omit<UseMutationOptions<CreateIntegrationRefOKResponse<unknown>, CreateIntegrationRefErrorResponse<unknown>, CreateIntegrationRefProps>, 'mutationKey' | 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<ResponseWithPagination<IntegrationResponse>, unknown, CreateIntegrationRefProps, unknown>;

package/dist/integration-service/src/services/hooks/useCreateIntegrationRefMutation.js

@@ -0,0 +1,30 @@
+/* eslint-disable */
+// This code is autogenerated using @harnessio/oats-cli.
+// Please do not modify this code directly.
+import { useMutation } from '@tanstack/react-query';
+import { fetcher } from '../../../../fetcher/index.js';
+function isProjectPathParams(pathParams) {
+    return !!(pathParams.org &&
+        pathParams.project);
+}
+function isOrgPathParams(pathParams) {
+    return !!(pathParams.org &&
+        !pathParams.project);
+}
+export function createIntegrationRef(props) {
+    let url = `/v1/integrations`;
+    let method = 'POST';
+    if (isProjectPathParams(props.pathParams)) {
+        url = `/v1/orgs/${props.pathParams.org}/projects/${props.pathParams.project}/integrations`;
+        method = 'POST';
+    }
+    else if (isOrgPathParams(props.pathParams)) {
+        url = `/v1/orgs/${props.pathParams.org}/integrations`;
+        method = 'POST';
+    }
+    return fetcher(Object.assign({ url,
+        method }, props));
+}
+export function useCreateIntegrationRefMutation(options) {
+    return useMutation((mutateProps) => createIntegrationRef(mutateProps), options);
+}

package/dist/integration-service/src/services/hooks/useDeleteIngestionJobSinkMutation.d.ts

@@ -0,0 +1,12 @@
+import { UseMutationOptions } from '@tanstack/react-query';
+import type { ResponseWithPagination } from '../helpers';
+import { FetcherOptions } from '../../../../fetcher/index.js';
+export interface DeleteIngestionJobSinkMutationPathParams {
+    jobId: string;
+}
+export type DeleteIngestionJobSinkOkResponse = ResponseWithPagination<unknown>;
+export type DeleteIngestionJobSinkErrorResponse = unknown;
+export interface DeleteIngestionJobSinkProps extends DeleteIngestionJobSinkMutationPathParams, Omit<FetcherOptions<unknown, unknown>, 'url'> {
+}
+export declare function deleteIngestionJobSink(props: DeleteIngestionJobSinkProps): Promise<DeleteIngestionJobSinkOkResponse>;
+export declare function useDeleteIngestionJobSinkMutation(options?: Omit<UseMutationOptions<DeleteIngestionJobSinkOkResponse, DeleteIngestionJobSinkErrorResponse, DeleteIngestionJobSinkProps>, 'mutationKey' | 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<DeleteIngestionJobSinkOkResponse, unknown, DeleteIngestionJobSinkProps, unknown>;

package/dist/integration-service/src/services/hooks/useDeleteIngestionJobSinkMutation.js

@@ -0,0 +1,11 @@
+/* eslint-disable */
+// This code is autogenerated using @harnessio/oats-cli.
+// Please do not modify this code directly.
+import { useMutation } from '@tanstack/react-query';
+import { fetcher } from '../../../../fetcher/index.js';
+export function deleteIngestionJobSink(props) {
+    return fetcher(Object.assign({ url: `/v1/ingestion/admin/jobs/${props.jobId}/sink`, method: 'DELETE' }, props));
+}
+export function useDeleteIngestionJobSinkMutation(options) {
+    return useMutation((mutateProps) => deleteIngestionJobSink(mutateProps), options);
+}

package/dist/integration-service/src/services/hooks/useDeleteIngestionLimitMutation.d.ts

@@ -0,0 +1,13 @@
+import { UseMutationOptions } from '@tanstack/react-query';
+import type { ResponseWithPagination } from '../helpers';
+import { FetcherOptions } from '../../../../fetcher/index.js';
+export interface DeleteIngestionLimitMutationPathParams {
+    scope: string;
+    id: string;
+}
+export type DeleteIngestionLimitOkResponse = ResponseWithPagination<unknown>;
+export type DeleteIngestionLimitErrorResponse = unknown;
+export interface DeleteIngestionLimitProps extends DeleteIngestionLimitMutationPathParams, Omit<FetcherOptions<unknown, unknown>, 'url'> {
+}
+export declare function deleteIngestionLimit(props: DeleteIngestionLimitProps): Promise<DeleteIngestionLimitOkResponse>;
+export declare function useDeleteIngestionLimitMutation(options?: Omit<UseMutationOptions<DeleteIngestionLimitOkResponse, DeleteIngestionLimitErrorResponse, DeleteIngestionLimitProps>, 'mutationKey' | 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<DeleteIngestionLimitOkResponse, unknown, DeleteIngestionLimitProps, unknown>;

package/dist/integration-service/src/services/hooks/useDeleteIngestionLimitMutation.js

@@ -0,0 +1,11 @@
+/* eslint-disable */
+// This code is autogenerated using @harnessio/oats-cli.
+// Please do not modify this code directly.
+import { useMutation } from '@tanstack/react-query';
+import { fetcher } from '../../../../fetcher/index.js';
+export function deleteIngestionLimit(props) {
+    return fetcher(Object.assign({ url: `/v1/ingestion/admin/limits/${props.scope}/${props.id}`, method: 'DELETE' }, props));
+}
+export function useDeleteIngestionLimitMutation(options) {
+    return useMutation((mutateProps) => deleteIngestionLimit(mutateProps), options);
+}

package/dist/integration-service/src/services/hooks/useDeleteIntegrationJobRefMutation.d.ts

@@ -0,0 +1,40 @@
+import { UseMutationOptions } from '@tanstack/react-query';
+import type { GetPathParamsType, ResponseWithPagination } from '../helpers';
+import { FetcherOptions } from '../../../../fetcher/index.js';
+export interface DeleteIntegrationJobRefAccountPathParams {
+    integration: string;
+    job: string;
+}
+export interface DeleteIntegrationJobRefAccountHeaderParams {
+    'Harness-Account': string;
+}
+export type DeleteIntegrationJobRefAccountOKResponse = unknown;
+export type DeleteIntegrationJobRefAccountErrorResponse = unknown;
+export interface DeleteIntegrationJobRefOrgPathParams {
+    org: string;
+    integration: string;
+    job: string;
+}
+export interface DeleteIntegrationJobRefOrgHeaderParams {
+    'Harness-Account': string;
+}
+export type DeleteIntegrationJobRefOrgOKResponse = unknown;
+export type DeleteIntegrationJobRefOrgErrorResponse = unknown;
+export interface DeleteIntegrationJobRefProjectPathParams {
+    org: string;
+    project: string;
+    integration: string;
+    job: string;
+}
+export interface DeleteIntegrationJobRefProjectHeaderParams {
+    'Harness-Account': string;
+}
+export type DeleteIntegrationJobRefProjectOKResponse = unknown;
+export type DeleteIntegrationJobRefProjectErrorResponse = unknown;
+export type DeleteIntegrationJobRefOKResponse<T> = T extends DeleteIntegrationJobRefProjectPathParams ? ResponseWithPagination<DeleteIntegrationJobRefProjectOKResponse> : T extends DeleteIntegrationJobRefOrgPathParams ? ResponseWithPagination<DeleteIntegrationJobRefOrgOKResponse> : ResponseWithPagination<DeleteIntegrationJobRefAccountOKResponse>;
+export type DeleteIntegrationJobRefErrorResponse<T> = T extends DeleteIntegrationJobRefProjectPathParams ? DeleteIntegrationJobRefProjectErrorResponse : T extends DeleteIntegrationJobRefOrgPathParams ? DeleteIntegrationJobRefOrgErrorResponse : DeleteIntegrationJobRefAccountErrorResponse;
+export interface DeleteIntegrationJobRefProps extends Omit<FetcherOptions<unknown, unknown>, 'url'> {
+    pathParams: DeleteIntegrationJobRefAccountPathParams | DeleteIntegrationJobRefOrgPathParams | DeleteIntegrationJobRefProjectPathParams;
+}
+export declare function deleteIntegrationJobRef<T extends DeleteIntegrationJobRefProps = DeleteIntegrationJobRefProps>(props: T): Promise<DeleteIntegrationJobRefOKResponse<GetPathParamsType<T>>>;
+export declare function useDeleteIntegrationJobRefMutation(options?: Omit<UseMutationOptions<DeleteIntegrationJobRefOKResponse<unknown>, DeleteIntegrationJobRefErrorResponse<unknown>, DeleteIntegrationJobRefProps>, 'mutationKey' | 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<ResponseWithPagination<unknown>, unknown, DeleteIntegrationJobRefProps, unknown>;

package/dist/integration-service/src/services/hooks/useDeleteIntegrationJobRefMutation.js

@@ -0,0 +1,30 @@
+/* eslint-disable */
+// This code is autogenerated using @harnessio/oats-cli.
+// Please do not modify this code directly.
+import { useMutation } from '@tanstack/react-query';
+import { fetcher } from '../../../../fetcher/index.js';
+function isProjectPathParams(pathParams) {
+    return !!(pathParams.org &&
+        pathParams.project);
+}
+function isOrgPathParams(pathParams) {
+    return !!(pathParams.org &&
+        !pathParams.project);
+}
+export function deleteIntegrationJobRef(props) {
+    let url = `/v1/integrations/${props.pathParams.integration}/jobs/${props.pathParams.job}`;
+    let method = 'DELETE';
+    if (isProjectPathParams(props.pathParams)) {
+        url = `/v1/orgs/${props.pathParams.org}/projects/${props.pathParams.project}/integrations/${props.pathParams.integration}/jobs/${props.pathParams.job}`;
+        method = 'DELETE';
+    }
+    else if (isOrgPathParams(props.pathParams)) {
+        url = `/v1/orgs/${props.pathParams.org}/integrations/${props.pathParams.integration}/jobs/${props.pathParams.job}`;
+        method = 'DELETE';
+    }
+    return fetcher(Object.assign({ url,
+        method }, props));
+}
+export function useDeleteIntegrationJobRefMutation(options) {
+    return useMutation((mutateProps) => deleteIntegrationJobRef(mutateProps), options);
+}