import { Client, AuthenticationType } from '@vonage/server-client';
import { ListAllTemplateFragmentsParams } from './types/params/listAllTemplateFragmentsParams.js';
import { ListAllTemplatesParams } from './types/params/listAllTemplateParams.js';
import { VerificationRequestParams } from './types/params/verifcationRequestParams.js';
import { Request } from './types/request.js';
import { Template } from './types/template.js';
import { TemplateFragment } from './types/templateFragment.js';
import { TemplatePage } from './types/templatePage.js';
import { TemplateFragmentPage } from './types/templateFragmentPage.js';
import './enums/verifyLocale.js';
import './types/workflows/index.js';
import './types/workflows/emailWorkflow.js';
import './enums/channels.js';
import './types/workflows/rcsWorkflow.js';
import './types/workflows/smsWorkflow.js';
import './types/workflows/silentAuthWorkflow.js';
import './types/workflows/voiceWorkflow.js';
import './types/workflows/whatsAppInteractiveWorkflow.js';
import './types/workflows/whatsAppWorkflow.js';
import './types/workflows/requestStatusCallbackWorkflow.js';
import './enums/requestWorkflowsStatus.js';

/**
 * A class for interacting with the Vonage Verify API (Version 2).
 */
declare class Verify2 extends Client {
    /**
     * The authentication type used for this client (JWT).
     */
    protected authType: AuthenticationType;
    /**
     * Creates a new verification request.
     *
     * @param {VerificationRequestParams} params - The parameters for the
     *  verification request.
     * @return {Request} A `Request` object containing the request ID.
     */
    newRequest(params: VerificationRequestParams): Promise<Request>;
    /**
     * Checks a verification code against a verification request.
     * @param {string} requestId - The ID of the verification request.
     * @param {string} code - The verification code to check.
     * @return {string} The status of the verification code check.
     */
    checkCode(requestId: string, code: string): Promise<string>;
    /**
     * Move the request to the next workflow step, if available.
     * @param {string} requestId - The ID of the verification request.
     * @return {boolean} `true` if the request was successful.
     */
    nextWorkflow(requestId: string): Promise<boolean>;
    /**
     * Cancels a verification request.
     * @param {string} requestId - The ID of the verification request to cancel.
     * @return {boolean} `true` if the cancellation was successful.
     */
    cancel(requestId: string): Promise<boolean>;
    /**
     * Generator function to list all templates across multiple pages.
     *
     * @remarks
     * This will continue calling the API to retrieve all templates until there are no more pages left.
     * The function yields each template in camelCase format.
     *
     * @param {ListAllTemplatesParams} [params={}] - Optional filter parameters, including pagination.
     * @yields {Template} - Yields each template object in camelCase format.
     *
     * @example
     * List all templates using pagination:
     * ```ts
     * for await (const template of templateClient.listAllTemplates({ pageSize: 5 })) {
     *   console.log(template.name);
     * }
     * ```
     *
     * @example
     * List all templates without pagination:
     * ```ts
     * for await (const template of templateClient.listAllTemplates()) {
     *   console.log(template.name);
     * }
     * ```
     */
    listAllTemplates(params?: ListAllTemplatesParams): AsyncGenerator<Template, void, undefined>;
    /**
     * Retrieves a single page of templates based on the provided pagination parameters.
     *
     * @param {ListAllTemplatesParams} params - The filter parameters for pagination (e.g., page number, page size).
     * @return {Promise<ListAllTemplatesResponse>} - A promise resolving to a page of templates.
     *
     * @example
     * Get a single page of templates:
     *
     * ```ts
     * const templatePage = await templateClient.getTemplatePage({
     *   page: 1,
     *   pageSize: 10
     * });
     *
     * templatePage.templates.forEach(template => {
     *   console.log(template.name);
     * });
     * ```
     */
    getTemplatePage(params?: ListAllTemplatesParams): Promise<TemplatePage>;
    /**
     * Creates a new template with the provided details.
     *
     * @param {Template} template - The template details to be created.
     * @return {Promise<Template>} - A promise resolving to the created template in camelCase format.
     *
     * @example
     * Create a new template:
     * ```ts
     * const newTemplate = await templateClient.createTemplate({
     *   name: 'My New Template',
     * });
     * console.log(newTemplate.name);
     * ```
     */
    createTemplate(template: Template): Promise<Template>;
    /**
     * Retrieves a single template by its unique identifier.
     *
     * @param {string} templateId - The unique identifier of the template to retrieve.
     * @return {Promise<Template>} - A promise resolving to the retrieved template in camelCase format.
     *
     * @example
     * Get a template by ID:
     * ```ts
     * const template = await templateClient.getTemplate('22f571c1-f41a-4db2-bba7-f23a069200c1');
     * console.log(template.name);
     * ```
     */
    getTemplate(templateId: string): Promise<Template>;
    /**
     * Deletes a template by its unique identifier.
     *
     * @param {string} templateId - The unique identifier of the template to delete.
     * @return {Promise<true>} - A promise that resolves when the template is successfully deleted.
     *
     * @example
     * Delete a template by ID:
     * ```ts
     * await templateClient.deleteTemplate('22f571c1-f41a-4db2-bba7-f23a069200c1');
     * console.log('Template deleted successfully');
     * ```
     */
    deleteTemplate(templateId: string): Promise<true>;
    /**
     * Updates an existing template with the provided details.
     *
     * @param {Template} template - The full template object with updated details. The template must include its ID.
     * @return {Promise<Template>} - A promise resolving to the updated template in camelCase format.
     *
     * @example
     * Update a template:
     * ```ts
     * const updatedTemplate = await templateClient.updateTemplate({
     *   templateId: '22f571c1-f41a-4db2-bba7-f23a069200c1',
     *   name: 'Updated Template Name',
     *   isDefault: false,
     * });
     * console.log(updatedTemplate.name);
     * ```
     */
    updateTemplate(template: Template): Promise<Template>;
    /**
     * Retrieves a page of template fragments based on the provided pagination and filter parameters.
     *
     * @param {ListAllTemplateFragmentsQueryParams} params - The filter parameters for pagination (e.g., page number, page size, template ID).
     * @return {Promise<ListAllTemplateFragmentsResponse>} - A promise resolving to a page of template fragments.
     *
     * @example
     * Get a page of template fragments:
     * ```ts
     * const fragmentPage = await templateClient.getTemplateFragmentPage({
     *   templateId: '22f571c1-f41a-4db2-bba7-f23a069200c1',
     *   page: 1,
     *   pageSize: 10,
     * });
     * fragmentPage._embedded.template_fragments.forEach(fragment => {
     *   console.log(fragment.text);
     * });
     * ```
     */
    getTemplateFragmentPage(params: ListAllTemplateFragmentsParams): Promise<TemplateFragmentPage>;
    /**
     * Generator function to list all templates across multiple pages.
     *
     * @remarks
     * This will continue calling the API to retrieve all templates until there are no more pages left.
     * The function yields each template in camelCase format.
     *
     * @param {ListAllTemplateFragmentsParams} [params={}] - Optional filter parameters, including pagination.
     * @yields {TemplateFragment} - Yields each template object in camelCase format.
     *
     * @example
     * List all templates using pagination:
     * ```ts
     * for await (const template of templateClient.listAllTemplateFragments({ pageSize: 5 })) {
     *   console.log(template.name);
     * }
     * ```
     *
     * @example
     * List all templates without pagination:
     * ```ts
     * for await (const template of templateClient.listAllTemplateFragments()) {
     *   console.log(template.name);
     * }
     * ```
     */
    listAllTemplateFragments(params: ListAllTemplateFragmentsParams): AsyncGenerator<TemplateFragment, void, undefined>;
    /**
     * Retrieves a single template fragment by its unique identifier.
     *
     * @param {string} templateId - The unique identifier of the template.
     * @param {string} fragmentId - The unique identifier of the template fragment.
     * @return {Promise<TemplateFragmentResponse>} - A promise resolving to the retrieved template fragment in snake_case format.
     *
     * @example
     * Get a template fragment by ID:
     * ```ts
     * const fragment = await templateClient.getTemplateFragment('22f571c1-f41a-4db2-bba7-f23a069200c1', 'c70f446e-997a-4313-a081-60a02a31dc19');
     * console.log(fragment.text);
     * ```
     */
    getTemplateFragment(templateId: string, fragmentId: string): Promise<TemplateFragment>;
    /**
     * Creates a new template fragment with the provided details.
     *
     * @param {string} templateId - The unique identifier of the template to which the fragment belongs.
     * @param {TemplateFragment} fragment - The details of the template fragment to be created.
     * @return {Promise<TemplateFragment>} - A promise resolving to the created template fragment in camelCase format.
     *
     * @example
     * Create a new template fragment:
     * ```ts
     * const newFragment = await templateClient.createTemplateFragment(
     *   '22f571c1-f41a-4db2-bba7-f23a069200c1',
     *   {
     *     channel: 'sms',
     *     locale: 'en-us',
     *     text: 'Your verification code is ${code}',
     *   },
     * );
     * console.log(newFragment.text);
     * ```
     */
    createTemplateFragment(templateId: string, fragment: TemplateFragment): Promise<TemplateFragment>;
    /**
     * Deletes a template fragment by its unique identifier.
     *
     * @param {string} templateId - The unique identifier of the template to delete.
     * @param {string} fragmentId - The unique identifier of the template to delete.
     * @return {Promise<true>} - A promise that resolves when the template is successfully deleted.
     *
     * @example
     * Delete a template by ID:
     * ```ts
     * await templateClient.deleteTemplateFragment(
     *   '22f571c1-f41a-4db2-bba7-f23a069200c1'
     *   'c70f446e-997a-4313-a081-60a02a31dc19',
     * );
     * console.log('Template Fragment deleted successfully');
     * ```
     */
    deleteTemplateFragment(templateId: string, fragmentId: string): Promise<true>;
    /**
     * Updates an existing template with the provided details.
     *
     * @param {String} templateId - The ID of the template this fragment belongs to.
     * @param {TemplateFragment} fragment - The full template fragment object with updated details.
     * @return {Promise<TemplateFragment>} - A promise resolving to the updated template fragment in camelCase format.
     *
     * @example
     * Update a template:
     * ```ts
     * const updatedTemplateFragment = await templateClient.updateTemplateFragment(
     *  '22f571c1-f41a-4db2-bba7-f23a069200c1',
     *   {
     *     templateId: '22f571c1-f41a-4db2-bba7-f23a069200c1',
     *     name: 'Updated Template Name',
     *     isDefault: false,
     *   }
     * );
     * console.log(updatedTemplateFragment.name);
     * ```
     */
    updateTemplateFragment(templateId: string, fragment: TemplateFragment): Promise<Template>;
}

export { Verify2 };