@harnessio/react-template-service-client 0.1.0

package/README.md

@@ -0,0 +1,39 @@
+# React Template Service Client(WIP)
+
+**OpenAPI -> OA**
+
+**TypeScript -> TS**
+
+**OpenAPI + TypeScript -> OATS**
+
+This React API client will store a collection of Harness Template 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 : HarnessReactAPIClient should be initialized
+
+Before using API Client, it must be initilaized with required `ClientCallbacks`.
+
+Example:
+
+```
+ new TemplateServiceAPIClient({
+    getHeaders: () => {
+        return { token: SessionToken.getToken(), 'Harness-Account': accountId }
+    }}
+```
+
+## Versioning
+
+![@harnessio/react-template-service-client](https://img.shields.io/npm/v/@harnessio/react-template-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({ 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/template-service/src/index.d.ts

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

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

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

package/dist/template-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/template-service/src/services/helpers.js

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

package/dist/template-service/src/services/hooks/useCreateTemplatesAccMutation.d.ts

@@ -0,0 +1,19 @@
+import { UseMutationOptions } from '@tanstack/react-query';
+import type { TemplateResponseResponse } from '../responses/TemplateResponseResponse';
+import type { TemplateCreateBodyRequestBody } from '../requestBodies/TemplateCreateBodyRequestBody';
+import type { ResponseWithPagination } from '../helpers';
+import { FetcherOptions } from '../../../../fetcher/index.js';
+export interface CreateTemplatesAccMutationHeaderParams {
+    'Harness-Account'?: string;
+}
+export type CreateTemplatesAccRequestBody = TemplateCreateBodyRequestBody;
+export type CreateTemplatesAccOkResponse = ResponseWithPagination<TemplateResponseResponse>;
+export type CreateTemplatesAccErrorResponse = unknown;
+export interface CreateTemplatesAccProps extends Omit<FetcherOptions<unknown, CreateTemplatesAccRequestBody, CreateTemplatesAccMutationHeaderParams>, 'url'> {
+    body: CreateTemplatesAccRequestBody;
+}
+export declare function createTemplatesAcc(props: CreateTemplatesAccProps): Promise<CreateTemplatesAccOkResponse>;
+/**
+ * Creates a Template in the Account scope.
+ */
+export declare function useCreateTemplatesAccMutation(options?: Omit<UseMutationOptions<CreateTemplatesAccOkResponse, CreateTemplatesAccErrorResponse, CreateTemplatesAccProps>, 'mutationKey' | 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<CreateTemplatesAccOkResponse, unknown, CreateTemplatesAccProps, unknown>;

package/dist/template-service/src/services/hooks/useCreateTemplatesAccMutation.js

@@ -0,0 +1,14 @@
+/* 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 createTemplatesAcc(props) {
+    return fetcher(Object.assign({ url: `/v1/templates`, method: 'POST' }, props));
+}
+/**
+ * Creates a Template in the Account scope.
+ */
+export function useCreateTemplatesAccMutation(options) {
+    return useMutation((mutateProps) => createTemplatesAcc(mutateProps), options);
+}

package/dist/template-service/src/services/hooks/useCreateTemplatesOrgMutation.d.ts

@@ -0,0 +1,22 @@
+import { UseMutationOptions } from '@tanstack/react-query';
+import type { TemplateResponseResponse } from '../responses/TemplateResponseResponse';
+import type { TemplateCreateBodyRequestBody } from '../requestBodies/TemplateCreateBodyRequestBody';
+import type { ResponseWithPagination } from '../helpers';
+import { FetcherOptions } from '../../../../fetcher/index.js';
+export interface CreateTemplatesOrgMutationPathParams {
+    org: string;
+}
+export interface CreateTemplatesOrgMutationHeaderParams {
+    'Harness-Account'?: string;
+}
+export type CreateTemplatesOrgRequestBody = TemplateCreateBodyRequestBody;
+export type CreateTemplatesOrgOkResponse = ResponseWithPagination<TemplateResponseResponse>;
+export type CreateTemplatesOrgErrorResponse = unknown;
+export interface CreateTemplatesOrgProps extends CreateTemplatesOrgMutationPathParams, Omit<FetcherOptions<unknown, CreateTemplatesOrgRequestBody, CreateTemplatesOrgMutationHeaderParams>, 'url'> {
+    body: CreateTemplatesOrgRequestBody;
+}
+export declare function createTemplatesOrg(props: CreateTemplatesOrgProps): Promise<CreateTemplatesOrgOkResponse>;
+/**
+ * Creates a Template in the Organization scope.
+ */
+export declare function useCreateTemplatesOrgMutation(options?: Omit<UseMutationOptions<CreateTemplatesOrgOkResponse, CreateTemplatesOrgErrorResponse, CreateTemplatesOrgProps>, 'mutationKey' | 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<CreateTemplatesOrgOkResponse, unknown, CreateTemplatesOrgProps, unknown>;

package/dist/template-service/src/services/hooks/useCreateTemplatesOrgMutation.js

@@ -0,0 +1,14 @@
+/* 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 createTemplatesOrg(props) {
+    return fetcher(Object.assign({ url: `/v1/orgs/${props.org}/templates`, method: 'POST' }, props));
+}
+/**
+ * Creates a Template in the Organization scope.
+ */
+export function useCreateTemplatesOrgMutation(options) {
+    return useMutation((mutateProps) => createTemplatesOrg(mutateProps), options);
+}

package/dist/template-service/src/services/hooks/useCreateTemplatesProjectMutation.d.ts

@@ -0,0 +1,23 @@
+import { UseMutationOptions } from '@tanstack/react-query';
+import type { TemplateResponseResponse } from '../responses/TemplateResponseResponse';
+import type { TemplateCreateBodyRequestBody } from '../requestBodies/TemplateCreateBodyRequestBody';
+import type { ResponseWithPagination } from '../helpers';
+import { FetcherOptions } from '../../../../fetcher/index.js';
+export interface CreateTemplatesProjectMutationPathParams {
+    org: string;
+    project: string;
+}
+export interface CreateTemplatesProjectMutationHeaderParams {
+    'Harness-Account'?: string;
+}
+export type CreateTemplatesProjectRequestBody = TemplateCreateBodyRequestBody;
+export type CreateTemplatesProjectOkResponse = ResponseWithPagination<TemplateResponseResponse>;
+export type CreateTemplatesProjectErrorResponse = unknown;
+export interface CreateTemplatesProjectProps extends CreateTemplatesProjectMutationPathParams, Omit<FetcherOptions<unknown, CreateTemplatesProjectRequestBody, CreateTemplatesProjectMutationHeaderParams>, 'url'> {
+    body: CreateTemplatesProjectRequestBody;
+}
+export declare function createTemplatesProject(props: CreateTemplatesProjectProps): Promise<CreateTemplatesProjectOkResponse>;
+/**
+ * Creates a Template in the Project scope.
+ */
+export declare function useCreateTemplatesProjectMutation(options?: Omit<UseMutationOptions<CreateTemplatesProjectOkResponse, CreateTemplatesProjectErrorResponse, CreateTemplatesProjectProps>, 'mutationKey' | 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<CreateTemplatesProjectOkResponse, unknown, CreateTemplatesProjectProps, unknown>;

package/dist/template-service/src/services/hooks/useCreateTemplatesProjectMutation.js

@@ -0,0 +1,14 @@
+/* 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 createTemplatesProject(props) {
+    return fetcher(Object.assign({ url: `/v1/orgs/${props.org}/projects/${props.project}/templates`, method: 'POST' }, props));
+}
+/**
+ * Creates a Template in the Project scope.
+ */
+export function useCreateTemplatesProjectMutation(options) {
+    return useMutation((mutateProps) => createTemplatesProject(mutateProps), options);
+}

package/dist/template-service/src/services/hooks/useDeleteTemplateAccMutation.d.ts

@@ -0,0 +1,24 @@
+import { UseMutationOptions } from '@tanstack/react-query';
+import type { ResponseWithPagination } from '../helpers';
+import { FetcherOptions } from '../../../../fetcher/index.js';
+export interface DeleteTemplateAccMutationPathParams {
+    template: string;
+    version: string;
+}
+export interface DeleteTemplateAccMutationQueryParams {
+    comments?: string;
+    forceDelete?: boolean;
+}
+export interface DeleteTemplateAccMutationHeaderParams {
+    'Harness-Account'?: string;
+}
+export type DeleteTemplateAccOkResponse = ResponseWithPagination<unknown>;
+export type DeleteTemplateAccErrorResponse = {};
+export interface DeleteTemplateAccProps extends DeleteTemplateAccMutationPathParams, Omit<FetcherOptions<DeleteTemplateAccMutationQueryParams, unknown, DeleteTemplateAccMutationHeaderParams>, 'url'> {
+    queryParams: DeleteTemplateAccMutationQueryParams;
+}
+export declare function deleteTemplateAcc(props: DeleteTemplateAccProps): Promise<DeleteTemplateAccOkResponse>;
+/**
+ * Deletes particular version of Template at Account scope.
+ */
+export declare function useDeleteTemplateAccMutation(options?: Omit<UseMutationOptions<DeleteTemplateAccOkResponse, DeleteTemplateAccErrorResponse, DeleteTemplateAccProps>, 'mutationKey' | 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<DeleteTemplateAccOkResponse, DeleteTemplateAccErrorResponse, DeleteTemplateAccProps, unknown>;

package/dist/template-service/src/services/hooks/useDeleteTemplateAccMutation.js

@@ -0,0 +1,14 @@
+/* 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 deleteTemplateAcc(props) {
+    return fetcher(Object.assign({ url: `/v1/templates/${props.template}/versions/${props.version}`, method: 'DELETE' }, props));
+}
+/**
+ * Deletes particular version of Template at Account scope.
+ */
+export function useDeleteTemplateAccMutation(options) {
+    return useMutation((mutateProps) => deleteTemplateAcc(mutateProps), options);
+}

package/dist/template-service/src/services/hooks/useDeleteTemplateOrgMutation.d.ts

@@ -0,0 +1,25 @@
+import { UseMutationOptions } from '@tanstack/react-query';
+import type { ResponseWithPagination } from '../helpers';
+import { FetcherOptions } from '../../../../fetcher/index.js';
+export interface DeleteTemplateOrgMutationPathParams {
+    template: string;
+    org: string;
+    version: string;
+}
+export interface DeleteTemplateOrgMutationQueryParams {
+    comments?: string;
+    forceDelete?: boolean;
+}
+export interface DeleteTemplateOrgMutationHeaderParams {
+    'Harness-Account'?: string;
+}
+export type DeleteTemplateOrgOkResponse = ResponseWithPagination<unknown>;
+export type DeleteTemplateOrgErrorResponse = {};
+export interface DeleteTemplateOrgProps extends DeleteTemplateOrgMutationPathParams, Omit<FetcherOptions<DeleteTemplateOrgMutationQueryParams, unknown, DeleteTemplateOrgMutationHeaderParams>, 'url'> {
+    queryParams: DeleteTemplateOrgMutationQueryParams;
+}
+export declare function deleteTemplateOrg(props: DeleteTemplateOrgProps): Promise<DeleteTemplateOrgOkResponse>;
+/**
+ * Deletes particular version of Template at Organization scope.
+ */
+export declare function useDeleteTemplateOrgMutation(options?: Omit<UseMutationOptions<DeleteTemplateOrgOkResponse, DeleteTemplateOrgErrorResponse, DeleteTemplateOrgProps>, 'mutationKey' | 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<DeleteTemplateOrgOkResponse, DeleteTemplateOrgErrorResponse, DeleteTemplateOrgProps, unknown>;

package/dist/template-service/src/services/hooks/useDeleteTemplateOrgMutation.js

@@ -0,0 +1,14 @@
+/* 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 deleteTemplateOrg(props) {
+    return fetcher(Object.assign({ url: `/v1/orgs/${props.org}/templates/${props.template}/versions/${props.version}`, method: 'DELETE' }, props));
+}
+/**
+ * Deletes particular version of Template at Organization scope.
+ */
+export function useDeleteTemplateOrgMutation(options) {
+    return useMutation((mutateProps) => deleteTemplateOrg(mutateProps), options);
+}

package/dist/template-service/src/services/hooks/useDeleteTemplateProjectMutation.d.ts

@@ -0,0 +1,26 @@
+import { UseMutationOptions } from '@tanstack/react-query';
+import type { ResponseWithPagination } from '../helpers';
+import { FetcherOptions } from '../../../../fetcher/index.js';
+export interface DeleteTemplateProjectMutationPathParams {
+    project: string;
+    template: string;
+    org: string;
+    version: string;
+}
+export interface DeleteTemplateProjectMutationQueryParams {
+    comments?: string;
+    forceDelete?: boolean;
+}
+export interface DeleteTemplateProjectMutationHeaderParams {
+    'Harness-Account'?: string;
+}
+export type DeleteTemplateProjectOkResponse = ResponseWithPagination<unknown>;
+export type DeleteTemplateProjectErrorResponse = {};
+export interface DeleteTemplateProjectProps extends DeleteTemplateProjectMutationPathParams, Omit<FetcherOptions<DeleteTemplateProjectMutationQueryParams, unknown, DeleteTemplateProjectMutationHeaderParams>, 'url'> {
+    queryParams: DeleteTemplateProjectMutationQueryParams;
+}
+export declare function deleteTemplateProject(props: DeleteTemplateProjectProps): Promise<DeleteTemplateProjectOkResponse>;
+/**
+ * Deletes particular version of Template at Project scope.
+ */
+export declare function useDeleteTemplateProjectMutation(options?: Omit<UseMutationOptions<DeleteTemplateProjectOkResponse, DeleteTemplateProjectErrorResponse, DeleteTemplateProjectProps>, 'mutationKey' | 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<DeleteTemplateProjectOkResponse, DeleteTemplateProjectErrorResponse, DeleteTemplateProjectProps, unknown>;

package/dist/template-service/src/services/hooks/useDeleteTemplateProjectMutation.js

@@ -0,0 +1,14 @@
+/* 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 deleteTemplateProject(props) {
+    return fetcher(Object.assign({ url: `/v1/orgs/${props.org}/projects/${props.project}/templates/${props.template}/versions/${props.version}`, method: 'DELETE' }, props));
+}
+/**
+ * Deletes particular version of Template at Project scope.
+ */
+export function useDeleteTemplateProjectMutation(options) {
+    return useMutation((mutateProps) => deleteTemplateProject(mutateProps), options);
+}

package/dist/template-service/src/services/hooks/useGetTemplateAccQuery.d.ts

@@ -0,0 +1,30 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import type { TemplateWithInputsResponseResponse } from '../responses/TemplateWithInputsResponseResponse';
+import type { ResponseWithPagination } from '../helpers';
+import { FetcherOptions } from '../../../../fetcher/index.js';
+export interface GetTemplateAccQueryPathParams {
+    template: string;
+    version: string;
+}
+export interface GetTemplateAccQueryQueryParams {
+    include_yaml?: boolean;
+    branch_name?: string;
+    parent_entity_connector_ref?: string;
+    parent_entity_repo_name?: string;
+    parent_entity_account_id?: string;
+    parent_entity_org_id?: string;
+    parent_entity_project_id?: string;
+}
+export interface GetTemplateAccQueryHeaderParams {
+    'Harness-Account'?: string;
+}
+export type GetTemplateAccOkResponse = ResponseWithPagination<TemplateWithInputsResponseResponse>;
+export type GetTemplateAccErrorResponse = unknown;
+export interface GetTemplateAccProps extends GetTemplateAccQueryPathParams, Omit<FetcherOptions<GetTemplateAccQueryQueryParams, unknown, GetTemplateAccQueryHeaderParams>, 'url'> {
+    queryParams: GetTemplateAccQueryQueryParams;
+}
+export declare function getTemplateAcc(props: GetTemplateAccProps): Promise<GetTemplateAccOkResponse>;
+/**
+ * Retrieves particular version of Template at Account scope.
+ */
+export declare function useGetTemplateAccQuery(props: GetTemplateAccProps, options?: Omit<UseQueryOptions<GetTemplateAccOkResponse, GetTemplateAccErrorResponse>, 'queryKey' | 'queryFn'>): import("@tanstack/react-query").UseQueryResult<GetTemplateAccOkResponse, unknown>;

package/dist/template-service/src/services/hooks/useGetTemplateAccQuery.js

@@ -0,0 +1,14 @@
+/* eslint-disable */
+// This code is autogenerated using @harnessio/oats-cli.
+// Please do not modify this code directly.
+import { useQuery } from '@tanstack/react-query';
+import { fetcher } from '../../../../fetcher/index.js';
+export function getTemplateAcc(props) {
+    return fetcher(Object.assign({ url: `/v1/templates/${props.template}/versions/${props.version}`, method: 'GET' }, props));
+}
+/**
+ * Retrieves particular version of Template at Account scope.
+ */
+export function useGetTemplateAccQuery(props, options) {
+    return useQuery(['get-template-acc', props.template, props.version, props.queryParams], ({ signal }) => getTemplateAcc(Object.assign(Object.assign({}, props), { signal })), options);
+}

package/dist/template-service/src/services/hooks/useGetTemplateOrgQuery.d.ts

@@ -0,0 +1,31 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import type { TemplateWithInputsResponseResponse } from '../responses/TemplateWithInputsResponseResponse';
+import type { ResponseWithPagination } from '../helpers';
+import { FetcherOptions } from '../../../../fetcher/index.js';
+export interface GetTemplateOrgQueryPathParams {
+    template: string;
+    org: string;
+    version: string;
+}
+export interface GetTemplateOrgQueryQueryParams {
+    include_yaml?: boolean;
+    branch_name?: string;
+    parent_entity_connector_ref?: string;
+    parent_entity_repo_name?: string;
+    parent_entity_account_id?: string;
+    parent_entity_org_id?: string;
+    parent_entity_project_id?: string;
+}
+export interface GetTemplateOrgQueryHeaderParams {
+    'Harness-Account'?: string;
+}
+export type GetTemplateOrgOkResponse = ResponseWithPagination<TemplateWithInputsResponseResponse>;
+export type GetTemplateOrgErrorResponse = unknown;
+export interface GetTemplateOrgProps extends GetTemplateOrgQueryPathParams, Omit<FetcherOptions<GetTemplateOrgQueryQueryParams, unknown, GetTemplateOrgQueryHeaderParams>, 'url'> {
+    queryParams: GetTemplateOrgQueryQueryParams;
+}
+export declare function getTemplateOrg(props: GetTemplateOrgProps): Promise<GetTemplateOrgOkResponse>;
+/**
+ * Retrieves particular version of Template at Organization scope.
+ */
+export declare function useGetTemplateOrgQuery(props: GetTemplateOrgProps, options?: Omit<UseQueryOptions<GetTemplateOrgOkResponse, GetTemplateOrgErrorResponse>, 'queryKey' | 'queryFn'>): import("@tanstack/react-query").UseQueryResult<GetTemplateOrgOkResponse, unknown>;

package/dist/template-service/src/services/hooks/useGetTemplateOrgQuery.js

@@ -0,0 +1,14 @@
+/* eslint-disable */
+// This code is autogenerated using @harnessio/oats-cli.
+// Please do not modify this code directly.
+import { useQuery } from '@tanstack/react-query';
+import { fetcher } from '../../../../fetcher/index.js';
+export function getTemplateOrg(props) {
+    return fetcher(Object.assign({ url: `/v1/orgs/${props.org}/templates/${props.template}/versions/${props.version}`, method: 'GET' }, props));
+}
+/**
+ * Retrieves particular version of Template at Organization scope.
+ */
+export function useGetTemplateOrgQuery(props, options) {
+    return useQuery(['get-template-org', props.template, props.org, props.version, props.queryParams], ({ signal }) => getTemplateOrg(Object.assign(Object.assign({}, props), { signal })), options);
+}

package/dist/template-service/src/services/hooks/useGetTemplateProjectQuery.d.ts

@@ -0,0 +1,32 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import type { TemplateWithInputsResponseResponse } from '../responses/TemplateWithInputsResponseResponse';
+import type { ResponseWithPagination } from '../helpers';
+import { FetcherOptions } from '../../../../fetcher/index.js';
+export interface GetTemplateProjectQueryPathParams {
+    project: string;
+    template: string;
+    org: string;
+    version: string;
+}
+export interface GetTemplateProjectQueryQueryParams {
+    include_yaml?: boolean;
+    branch_name?: string;
+    parent_entity_connector_ref?: string;
+    parent_entity_repo_name?: string;
+    parent_entity_account_id?: string;
+    parent_entity_org_id?: string;
+    parent_entity_project_id?: string;
+}
+export interface GetTemplateProjectQueryHeaderParams {
+    'Harness-Account'?: string;
+}
+export type GetTemplateProjectOkResponse = ResponseWithPagination<TemplateWithInputsResponseResponse>;
+export type GetTemplateProjectErrorResponse = unknown;
+export interface GetTemplateProjectProps extends GetTemplateProjectQueryPathParams, Omit<FetcherOptions<GetTemplateProjectQueryQueryParams, unknown, GetTemplateProjectQueryHeaderParams>, 'url'> {
+    queryParams: GetTemplateProjectQueryQueryParams;
+}
+export declare function getTemplateProject(props: GetTemplateProjectProps): Promise<GetTemplateProjectOkResponse>;
+/**
+ * Retrieves particular version of Template at Project scope.
+ */
+export declare function useGetTemplateProjectQuery(props: GetTemplateProjectProps, options?: Omit<UseQueryOptions<GetTemplateProjectOkResponse, GetTemplateProjectErrorResponse>, 'queryKey' | 'queryFn'>): import("@tanstack/react-query").UseQueryResult<GetTemplateProjectOkResponse, unknown>;

package/dist/template-service/src/services/hooks/useGetTemplateProjectQuery.js

@@ -0,0 +1,21 @@
+/* eslint-disable */
+// This code is autogenerated using @harnessio/oats-cli.
+// Please do not modify this code directly.
+import { useQuery } from '@tanstack/react-query';
+import { fetcher } from '../../../../fetcher/index.js';
+export function getTemplateProject(props) {
+    return fetcher(Object.assign({ url: `/v1/orgs/${props.org}/projects/${props.project}/templates/${props.template}/versions/${props.version}`, method: 'GET' }, props));
+}
+/**
+ * Retrieves particular version of Template at Project scope.
+ */
+export function useGetTemplateProjectQuery(props, options) {
+    return useQuery([
+        'get-template-project',
+        props.project,
+        props.template,
+        props.org,
+        props.version,
+        props.queryParams,
+    ], ({ signal }) => getTemplateProject(Object.assign(Object.assign({}, props), { signal })), options);
+}

package/dist/template-service/src/services/hooks/useGetTemplateSchemaQuery.d.ts

@@ -0,0 +1,25 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import type { TemplateSchemaResponseResponse } from '../responses/TemplateSchemaResponseResponse';
+import type { ResponseWithPagination } from '../helpers';
+import { FetcherOptions } from '../../../../fetcher/index.js';
+export interface GetTemplateSchemaQueryQueryParams {
+    node_group?: 'artifactsourcetemplate' | 'customdeployment' | 'monitoredservice' | 'pipeline' | 'secretmanager' | 'stage' | 'step' | 'stepgroup' | 'template';
+    node_type?: string;
+    /**
+     * @default "v0"
+     */
+    version?: 'v0' | 'v1';
+}
+export interface GetTemplateSchemaQueryHeaderParams {
+    'Harness-Account'?: string;
+}
+export type GetTemplateSchemaOkResponse = ResponseWithPagination<TemplateSchemaResponseResponse>;
+export type GetTemplateSchemaErrorResponse = unknown;
+export interface GetTemplateSchemaProps extends Omit<FetcherOptions<GetTemplateSchemaQueryQueryParams, unknown, GetTemplateSchemaQueryHeaderParams>, 'url'> {
+    queryParams: GetTemplateSchemaQueryQueryParams;
+}
+export declare function getTemplateSchema(props: GetTemplateSchemaProps): Promise<GetTemplateSchemaOkResponse>;
+/**
+ * Gets Templates Schema
+ */
+export declare function useGetTemplateSchemaQuery(props: GetTemplateSchemaProps, options?: Omit<UseQueryOptions<GetTemplateSchemaOkResponse, GetTemplateSchemaErrorResponse>, 'queryKey' | 'queryFn'>): import("@tanstack/react-query").UseQueryResult<GetTemplateSchemaOkResponse, unknown>;

package/dist/template-service/src/services/hooks/useGetTemplateSchemaQuery.js

@@ -0,0 +1,14 @@
+/* eslint-disable */
+// This code is autogenerated using @harnessio/oats-cli.
+// Please do not modify this code directly.
+import { useQuery } from '@tanstack/react-query';
+import { fetcher } from '../../../../fetcher/index.js';
+export function getTemplateSchema(props) {
+    return fetcher(Object.assign({ url: `/v1/template-schema/individual-schema`, method: 'GET' }, props));
+}
+/**
+ * Gets Templates Schema
+ */
+export function useGetTemplateSchemaQuery(props, options) {
+    return useQuery(['get-template-schema', props.queryParams], ({ signal }) => getTemplateSchema(Object.assign(Object.assign({}, props), { signal })), options);
+}

package/dist/template-service/src/services/hooks/useGetTemplateStableAccQuery.d.ts

@@ -0,0 +1,29 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import type { TemplateWithInputsResponseResponse } from '../responses/TemplateWithInputsResponseResponse';
+import type { ResponseWithPagination } from '../helpers';
+import { FetcherOptions } from '../../../../fetcher/index.js';
+export interface GetTemplateStableAccQueryPathParams {
+    template: string;
+}
+export interface GetTemplateStableAccQueryQueryParams {
+    include_yaml?: boolean;
+    branch_name?: string;
+    parent_entity_connector_ref?: string;
+    parent_entity_repo_name?: string;
+    parent_entity_account_id?: string;
+    parent_entity_org_id?: string;
+    parent_entity_project_id?: string;
+}
+export interface GetTemplateStableAccQueryHeaderParams {
+    'Harness-Account'?: string;
+}
+export type GetTemplateStableAccOkResponse = ResponseWithPagination<TemplateWithInputsResponseResponse>;
+export type GetTemplateStableAccErrorResponse = unknown;
+export interface GetTemplateStableAccProps extends GetTemplateStableAccQueryPathParams, Omit<FetcherOptions<GetTemplateStableAccQueryQueryParams, unknown, GetTemplateStableAccQueryHeaderParams>, 'url'> {
+    queryParams: GetTemplateStableAccQueryQueryParams;
+}
+export declare function getTemplateStableAcc(props: GetTemplateStableAccProps): Promise<GetTemplateStableAccOkResponse>;
+/**
+ * Retrieves stable version of Template at Account scope.
+ */
+export declare function useGetTemplateStableAccQuery(props: GetTemplateStableAccProps, options?: Omit<UseQueryOptions<GetTemplateStableAccOkResponse, GetTemplateStableAccErrorResponse>, 'queryKey' | 'queryFn'>): import("@tanstack/react-query").UseQueryResult<GetTemplateStableAccOkResponse, unknown>;