@sirhc77/signalwire-rest-sdk/src/SignalWireRESTClientTypes.ts

An SDK for the SignalWire REST API

import {PagedResponse} from "./PagedResponse";
import {SWML} from "./SWMLTypes";

export interface CreateCallRequestParamsBase {
    from: string;
    to: string;
    callerId?: string;
    fallbackUrl?: string;
}

export interface CreateCallRequestBase {
    command: 'dial',
    params: CreateCallRequestParamsBase
}

export interface CreateCallRequestUrlParams extends CreateCallRequestParamsBase {
    url: string;
}

export interface CreateCallRequestSwmlParams extends CreateCallRequestParamsBase {
    swml: SWML;
}

export interface CreateCallRequestWithUrl extends CreateCallRequestBase {
    type: 'url';
    params: CreateCallRequestUrlParams;
}

export interface CreateCallRequestWithSwml extends CreateCallRequestBase {
    type: 'swml';
    params: CreateCallRequestSwmlParams;
}

export type CreateCallRequest = CreateCallRequestWithUrl | CreateCallRequestWithSwml;

export interface UpdateCallRequestParamsBase {
    id: string;
    fallbackUrl?: string;
    status?: 'cancelled' | 'completed';
}

export interface UpdateCallRequestBase {
    command: 'update',
    params: UpdateCallRequestParamsBase
}

export interface UpdateCallRequestUrlParams extends UpdateCallRequestParamsBase {
    url: string;
}

export interface UpdateCallRequestSwmlParams extends UpdateCallRequestParamsBase {
    swml: SWML;
}

export interface UpdateCallRequestWithUrl extends UpdateCallRequestBase {
    type: 'url';
    params: UpdateCallRequestUrlParams;
}

export interface UpdateCallRequestWithSwml extends UpdateCallRequestBase {
    type: 'swml';
    params: UpdateCallRequestSwmlParams;
}

export type UpdateCallRequest = UpdateCallRequestWithUrl | UpdateCallRequestWithSwml;

export interface CallRequestCharge {
    description: string;
    amount: number;
}

export interface LogCharge {
    description: string;
    charge: number;
}

export interface CallResponse {
    id: string;
    from: string;
    to: string;
    direction: string;
    status: string;
    duration: number;
    durationMS: number;
    billableDuration: number;
    source: string;
    type: string;
    chargeDetails: CallRequestCharge[];
}

export interface CallsNamespace {
    createCall(request: CreateCallRequest): Promise<CallResponse>;

    updateCall(request: UpdateCallRequest): Promise<CallResponse>;
}

export interface CallingNamespace {
    calls: CallsNamespace;
}

export type ChunkingStrategy = 'sentence' | 'paragraph' | 'page' | 'sliding';

export type DocumentStatus = 'submitted' | 'in_process' | 'completed' | 'failed';

export interface DatasphereDocument {
    id: string;
    filename: string;
    status: DocumentStatus;
    tags: string[];
    chunkingStrategy: ChunkingStrategy;
    maxSentencesPerChunk: number;
    splitNewlines: boolean;
    overlapSize: number;
    chunkSize: number;
    numberOfChunks: number;
    createdAt: string;
    updatedAt: string;
}

export interface CreateDocumentRequestBase {
    chunkingStrategy: ChunkingStrategy;
    url: string;
    tags?: string[];
}

export interface CreateSentenceStrategyDocumentRequest extends CreateDocumentRequestBase {
    chunkingStrategy: 'sentence';
    maxSentencesPerChunk?: number;
    splitNewlines?: boolean;
}

export interface CreateSlidingStrategyDocumentRequest extends CreateDocumentRequestBase {
    chunkingStrategy: 'sliding';
    overlapSize?: number;
    chunkSize?: number;
}

export interface CreatePageStrategyDocumentRequest extends CreateDocumentRequestBase {
    chunkingStrategy: 'page';
}

export interface CreateParagraphStrategyDocumentRequest extends CreateDocumentRequestBase {
    chunkingStrategy: 'paragraph';
}

export type CreateDocumentRequest = CreateSentenceStrategyDocumentRequest | CreateSlidingStrategyDocumentRequest |
    CreatePageStrategyDocumentRequest | CreateParagraphStrategyDocumentRequest;

export interface SearchDocumentRequest {
    tags?: string[];
    documentId?: string;
    queryString: string;
    distance?: number;
    count?: number;
    language?: string;
    posToExpand?: string[];
    maxSynonyms?: number;
}

export interface SearchDocumentResult {
    text: string;
    documentId: string;
}

export interface SearchDocumentsResponse {
    chunks: SearchDocumentResult[];
}

export interface UpdateDocumentRequest {
    tags?: string[];
}

export interface DocumentsNamespace {
    listDocuments(): AsyncIterableIterator<DatasphereDocument>;

    listDocumentsPage(url?: string): Promise<PagedResponse<DatasphereDocument>>;

    createDocument(request: CreateDocumentRequest): Promise<DatasphereDocument>;

    searchDocument(request: SearchDocumentRequest): Promise<SearchDocumentsResponse>;

    updateDocument(id: string, request: UpdateDocumentRequest): Promise<DatasphereDocument>;

    deleteDocument(id: string): Promise<void>;
}

export interface DatasphereDocumentChunk {
    id: string;
    datasphereDocumentId: string;
    projectId: string;
    status: string;
    tags: string[];
    content: string;
    createdAt: string;
    updatedAt: string;
}

export interface ChunksNamespace {
    listChunks(documentId: string): AsyncIterableIterator<DatasphereDocumentChunk>;

    listChunksPage(documentId: string, url?: string): Promise<PagedResponse<DatasphereDocumentChunk>>;

    retrieveChunk(documentId: string, chunkId: string): Promise<DatasphereDocumentChunk>;

    deleteChunk(documentId: string, chunkId: string): Promise<void>;
}

export interface DatasphereNamespace {
    documents: DocumentsNamespace;
    chunks: ChunksNamespace;
}

export interface MfaTokenViaTextRequest {
    to: string;
    from?: string;
    message?: string
    tokenLength?: number;
    maxAttempts?: number;
    allowAlphas?: boolean;
    validFor?: number;
}

export interface MfaTokenViaTextResponse {
    id: string;
    success: boolean;
    to: string;
    channel: 'sms' | 'call';
}

export interface MfaTokenViaPhoneCallRequest {
    to: string;
    from?: string;
    message?: string;
    tokenLength?: string;
    maxAttempts?: string;
    allowAlphas?: string;
    validFor?: string;
}

export interface MfaTokenViaPhoneCallResponse {
    id: string;
    success: boolean;
    to: string;
    channel: 'sms' | 'call';
}

export interface VerifyMfaTokenRequest {
    token: string;
}

export interface VerifyMfaTokenResponse {
    success: boolean;
}

export interface MultiFactorAuthenticationNamespace {
    requestMfaTokenViaText(request: MfaTokenViaTextRequest): Promise<MfaTokenViaTextResponse>;

    requestMfaTokenViaPhoneCall(request: MfaTokenViaPhoneCallRequest): Promise<MfaTokenViaPhoneCallResponse>;

    verifyToken(mfaRequestId: string, request: VerifyMfaTokenRequest): Promise<VerifyMfaTokenResponse>;
}

export interface CreateVerifiedCallerIdRequest {
    name?: string;
    extension?: string;
    number: string;
}

export interface VerifiedCallerId {
    type: string;
    id: string;
    name: string;
    extension: string;
    number: string;
    verified: boolean;
    verifiedAt: string;
    status: 'Verified' | 'Awaiting Verification';
}

export interface ValidateVerificationCodeRequest {
    verificationCode: string;
}

export interface ListAllVerifiedCallerIdsOptions {
    filterName?: string,
    filterNumber?: string
}


export interface UpdateVerifiedCallerIdRequest {
    name: string;
}

export interface VerifiedCallerIdsNamespace {
    createVerifiedCallerId(request: CreateVerifiedCallerIdRequest): Promise<VerifiedCallerId>;

    validateVerificationCode(id: string, request: ValidateVerificationCodeRequest): Promise<VerifiedCallerId>;

    redialVerificationCall(id: string): Promise<VerifiedCallerId>;

    listAllVerifiedCallerIds(options?: ListAllVerifiedCallerIdsOptions): AsyncIterableIterator<VerifiedCallerId>;

    listAllVerifiedCallerIdsPage(options?: ListAllVerifiedCallerIdsOptions, url?: string): Promise<PagedResponse<VerifiedCallerId>>;

    retrieveVerifiedCallerId(id: string): Promise<VerifiedCallerId>;

    updateVerifiedCallerId(id: string, request: UpdateVerifiedCallerIdRequest): Promise<any>;

    deleteVerifiedCallerId(id: string): Promise<void>;
}

export type AddressType =
    'Apartment'
    | 'Basement'
    | 'Building'
    | 'Department'
    | 'Floor'
    | 'Office'
    | 'Penthouse'
    | 'Suite'
    | 'Trailer'
    | 'Unit';

export interface CreateAddressRequest {
    label: string;
    country: string;
    firstName: string;
    lastName: string;
    streetNumber: string;
    streetName: string;
    addressType?: AddressType;
    addressNumber?: string;
    city: string;
    state: string;
    postalCode: string;
}

export interface Address {
    id: string;
    label: string;
    country: string;
    firstName: string;
    lastName: string;
    streetNumber: string;
    streetName: string;
    addressType?: AddressType;
    addressNumber?: string;
    city: string;
    state: string;
    postalCode: string;
}

export interface AddressesNamespace {
    listAllAddresses(): AsyncIterableIterator<Address>;

    listAllAddressesPage(url?: string): Promise<PagedResponse<Address>>;

    retrieveAddress(addressId: string): Promise<Address>;

    deleteAddress(addressId: string): Promise<void>;

    createAddress(body: CreateAddressRequest): Promise<Address>;
}

export interface ListAllBrandsOptions {
    filterName?: string,
    filterState?: string
}

export type LegalEntityType = 'PRIVATE_PROFIT' | 'PUBLIC_PROFIT' | 'NON_PROFIT';

export type CompanyVertical =
    'REAL_ESTATE'
    | 'HEALTHCARE'
    | 'ENERGY'
    | 'ENTERTAINMENT'
    | 'RETAIL'
    | 'AGRICULTURE'
    | 'INSURANCE'
    | 'EDUCATION'
    | 'HOSPITALITY'
    | 'FINANCIAL'
    | 'GAMBLING'
    | 'CONSTRUCTION'
    | 'NGO'
    | 'MANUFACTURING'
    | 'GOVERNMENT'
    | 'TECHNOLOGY'
    | 'COMMUNICATION';

export interface CreateBrandRequest {
    name?: string;
    companyName: string;
    contactEmail?: string;
    contactPhone?: string;
    einIssuingCountry?: string;
    legalEntityType?: LegalEntityType;
    ein?: string;
    companyAddress?: string;
    companyVertical?: CompanyVertical
    companyWebsite?: string;
    cspBrandReference?: string;
    cspSelfRegistered?: boolean;
    statusCallbackUrl?: string;
}

export interface Brand {
    id: string;
    state: string;
    name: string;
    companyName: string;
    contactEmail: string;
    contactPhone: string;
    einIssuingCountry: string;
    legalEntityType: LegalEntityType;
    ein: string;
    companyAddress: string;
    companyVertical?: CompanyVertical
    companyWebsite: string;
    cspBrandReference?: string;
    cspSelfRegistered?: boolean;
    statusCallbackUrl?: string;
    createdAt: string;
    updatedAt: string;
}


export interface BrandsNamespace {
    listAllBrands(options?: ListAllBrandsOptions): AsyncIterableIterator<Brand>;

    listAllBrandsPage(options?: ListAllBrandsOptions, url?: string): Promise<PagedResponse<Brand>>;

    retrieveBrand(id: string): Promise<Brand>;

    createBrand(request: CreateBrandRequest): Promise<Brand>;
}

export interface UpdateCampaignRequest {
    name: string;
}

export type SMSUseCase =
    '2FA'
    | 'ACCOUNT_NOTIFICATION'
    | 'AGENTS_FRANCHISES'
    | 'CARRIER_EXEMPT'
    | 'CHARITY'
    | 'CUSTOMER_CARE'
    | 'DELIVERY_NOTIFICATION'
    | 'EMERGENCY'
    | 'FRAUD_ALERT'
    | 'HIGHER_EDUCATION'
    | 'K12_EDUCATION'
    | 'LOW_VOLUME_MIXED'
    | 'MARKETING'
    | 'MIXED'
    | 'POLITICAL'
    | 'POLITICAL_SECTION_527'
    | 'POLLING_VOTING'
    | 'PROXY'
    | 'PUBLIC_SERVICE_ANNOUNCEMENT'
    | 'SECURITY_ALERT'
    | 'SOCIAL'
    | 'SWEEPSTAKE'
    | 'TRIAL'
    | 'UCAAS_HIGH_VOLUME'
    | 'UCAAS_LOW_VOLUME'

export type SubUseCase =
    'CUSTOMER_CARE'
    | 'HIGHER_EDUCATION'
    | 'POLLING_VOTING'
    | 'PUBLIC_SERVICE_ANNOUNCEMENT'
    | 'MARKETING'
    | 'SECURITY_ALERT'
    | '2FA'
    | 'ACCOUNT_NOTIFICATION'
    | 'DELIVERY_NOTIFICATION'
    | 'FRAUD_ALERT'


export interface CreateCampaignRequest {
    name: string;
    smsUseCase: SMSUseCase;
    subUseCases?: SubUseCase[];
    description: string;
    sample1: string;
    sample2: string;
    sample3?: string;
    sample4?: string;
    sample5?: string;
    dynamicTemplates?: string;
    messageFlow: string;
    optInMessage?: string;
    optOutMessage: string;
    helpMessage: string;
    numberPoolingRequired: boolean;
    numberPoolingPerCampaign?: string;
    directLending: boolean;
    embeddedLink: boolean;
    embeddedPhone: boolean;
    ageGatedContent: boolean;
    leadGeneration: boolean;
    termsAndConditions: boolean;
}

export interface Campaign {
    id: string;
    name: string;
    smsUseCase: SMSUseCase;
    subUseCases?: SubUseCase[];
    description: string;
    sample1: string;
    sample2: string;
    sample3?: string;
    sample4?: string;
    sample5?: string;
    dynamicTemplates?: string;
    messageFlow: string;
    optInMessage?: string;
    optOutMessage: string;
    helpMessage: string;
    numberPoolingRequired: boolean;
    numberPoolingPerCampaign?: string;
    directLending: boolean;
    embeddedLink: boolean;
    embeddedPhone: boolean;
    ageGatedContent: boolean;
    leadGeneration: boolean;
    termsAndConditions: boolean;
    createdAt: string;
    updatedAt: string;
}

export interface CampaignsNamespace {
    listAllCampaigns(brandId: string): AsyncIterableIterator<Campaign>;

    listAllCampaignsPage(brandId: string, url?: string): Promise<PagedResponse<Campaign>>;

    retrieveCampaign(campaignId: string): Promise<Campaign>;

    updateCampaign(campaignId: string, request: UpdateCampaignRequest): Promise<Campaign>;

    createCampaign(brandId: string, request: CreateCampaignRequest): Promise<Campaign>;
}

export interface ListAllCampaignPhoneNumberAssignmentsOptions {
    filterState?: string
}


export interface ListAllCampaignPhoneNumberAssignmentOrdersOptions {
    filterState?: string
}


export interface CreateCampaignPhoneNumberAssignmentOrderRequest {
    phoneNumbers: string[];
    statusCallbackUrl?: string;
}

export interface CampaignPhoneNumberAssignmentOrder {
    id: string;
    state: string;
    processedAt: string;
    createdAt: string;
    updatedAt: string;
    statusCallbackUrl?: string;
}

export interface CampaignNumberAssignmentsNamespace {
    listAllPhoneNumberAssignments(campaignId: string, options?: ListAllCampaignPhoneNumberAssignmentsOptions): AsyncIterableIterator<any>;

    listAllPhoneNumberAssignmentsPage(campaignId: string, options?: ListAllCampaignPhoneNumberAssignmentsOptions, url?: string): Promise<PagedResponse<any>>;

    listAllPhoneNumberAssignmentOrders(campaignId: string, options?: ListAllCampaignPhoneNumberAssignmentOrdersOptions): AsyncIterableIterator<CampaignPhoneNumberAssignmentOrder>;

    listAllPhoneNumberAssignmentOrdersPage(campaignId: string, options?: ListAllCampaignPhoneNumberAssignmentOrdersOptions, url?: string): Promise<PagedResponse<CampaignPhoneNumberAssignmentOrder>>;

    retrievePhoneNumberAssignmentOrder(assignmentOrderId: string): Promise<CampaignPhoneNumberAssignmentOrder>;

    createPhoneNumberAssignmentOrder(campaignId: string, request: CreateCampaignPhoneNumberAssignmentOrderRequest): Promise<CampaignPhoneNumberAssignmentOrder>;

    deletePhoneNumberAssignment(numberAssignmentId: string): Promise<void>;
}

export interface CampaignRegistryApiNamespace {
    brands: BrandsNamespace;
    campaigns: CampaignsNamespace;
    campaignNumberAssignments: CampaignNumberAssignmentsNamespace;
}

export interface ListAllDomainApplicationsOptions {
    filterDomain?: string,
    filterName?: string
}

export interface RelayTopicDomainApplicationCallHandler {
    type: 'relay_topic'
    callRelayTopic?: string;
    callRelayTopicStatusCallbackUrl?: string;
}

export interface RelayApplicationDomainApplicationCallHandler {
    type: 'relay_application'
    callRelayApplication?: string;
}

export interface LamlWebhooksDomainApplicationCallHandler {
    type: 'laml_webhooks'
    callRequestUrl?: string;
    callRequestMethod?: HTTPMethod;
    callFallbackUrl?: string;
    callFallbackMethod?: HTTPMethod;
    callStatusCallbackUrl?: string;
    callStatusCallbackMethod?: HTTPMethod;
}

export interface LamlApplicationDomainApplicationCallHandler {
    type: 'laml_application'
    callLamlApplicationId?: string;
}

export interface VideoRoomDomainApplicationCallHandler {
    type: 'video_room'
    callVideoRoomId?: string;
}

export interface RelayScriptDomainApplicationCallHandler {
    type: 'relay_script'
    callRelayScriptUrl?: string;
}

export interface DialogflowDomainApplicationCallHandler {
    type: 'dialogflow'
    callDialogflowAgentId?: string;
}

export interface AiAgentDomainApplicationCallHandler {
    type: 'ai_agent'
    callAiAgentId?: string;
}

export interface CallFlowDomainApplicationCallHandler {
    type: 'call_flow'
    callFlowId?: string;
    callFlowVersion?: 'working_copy' | 'current_deployed';
}

export interface RelayContextDomainApplicationCallHandler {
    type: 'relay_context'
    callRelayContext?: string;
    callRelayContextStatusCallbackUrl?: string;
}

export type DomainApplicationCallHandler =
    RelayTopicDomainApplicationCallHandler
    | RelayApplicationDomainApplicationCallHandler
    | LamlWebhooksDomainApplicationCallHandler
    | LamlApplicationDomainApplicationCallHandler
    | VideoRoomDomainApplicationCallHandler
    | RelayScriptDomainApplicationCallHandler
    | DialogflowDomainApplicationCallHandler
    | AiAgentDomainApplicationCallHandler
    | CallFlowDomainApplicationCallHandler
    | RelayContextDomainApplicationCallHandler;

export type HTTPMethod = 'GET' | 'POST';

export interface UpdateDomainApplicationRequest {
    name?: string;
    identifier?: string;
    user?: string;
    callHandler?: DomainApplicationCallHandler;
    ipAuthEnabled?: boolean;
    ipAuth?: string[];
    encryption?: Encryption;
    codecs?: Codec[];
    ciphers?: Cipher[];
}

export type Encryption = 'optional' | 'required';

export type Codec = 'OPUS' | 'G722' | 'PCMU' | 'PCMA' | 'VP8' | 'H264';

export type Cipher =
    'AEAD_AES_256_GCM_8'
    | 'AES_256_CM_HMAC_SHA1_80'
    | 'AES_CM_128_HMAC_SHA1_80'
    | 'AES_256_CM_HMAC_SHA1_32'
    | 'AES_CM_128_HMAC_SHA1_32';

export type CreateDomainApplicationRequest = {
    name: string;
    identifier: string;
    user?: string;
    callHandler: DomainApplicationCallHandler;
    ipAuthEnabled?: boolean;
    ipAuth?: string[];
    encryption?: Encryption;
    codecs?: Codec[];
    ciphers?: Cipher[];
}

export interface DomainApplication {
    id: string;
    callHandler: DomainApplicationCallHandler;
    type?: string;
    domain?: string;
    name: string;
    identifier: string;
    user?: string;
    ipAuthEnabled?: boolean;
    ipAuth?: string[];
    encryption?: Encryption;
    codecs?: Codec[];
    ciphers?: Cipher[];
}

export interface DomainApplicationsNamespace {
    listAllDomainApplications(options?: ListAllDomainApplicationsOptions): AsyncIterableIterator<DomainApplication>;

    listAllDomainApplicationsPage(options?: ListAllDomainApplicationsOptions, url?: string): Promise<PagedResponse<DomainApplication>>;

    retrieveDomainApplication(id: string): Promise<DomainApplication>;

    updateDomainApplication(id: string, request: UpdateDomainApplicationRequest): Promise<DomainApplication>;

    createDomainApplication(request: CreateDomainApplicationRequest): Promise<DomainApplication>;

    deleteDomainApplication(id: string): Promise<void>;
}

export interface UpdateNumberGroupRequest {
    name: string;
}

export interface CreateNumberGroupRequest {
    name: string;
    stickySender: boolean;
}

export interface NumberGroup {
    id: string;
    name: string;
    stickySender: boolean;
    phoneNumberCount: number;
}

export interface NumberGroupsNamespace {
    listAllNumberGroups(): AsyncIterableIterator<NumberGroup>;

    listAllNumberGroupsPage(url?: string): Promise<PagedResponse<NumberGroup>>;

    retrieveNumberGroup(id: string): Promise<NumberGroup>;

    updateNumberGroup(id: string, body: UpdateNumberGroupRequest): Promise<NumberGroup>;

    createNumberGroup(request: CreateNumberGroupRequest): Promise<NumberGroup>;

    deleteNumberGroup(id: string): Promise<void>;
}

export interface CreateNumberGroupMemberRequest {
    phoneNumberId: string;
}

export type NumberCapability = 'sms' | 'mms' | 'voice' | 'fax';

export interface NumberGroupMembership {
    id: string;
    numberGroupId: string;
    phoneNumber: {
        id: string;
        name: string;
        number: string;
        capabilities: NumberCapability[];
    }
}

export interface NumberGroupsMembershipsNamespace {
    listAllNumberGroupMembers(numberGroupId: string): AsyncIterableIterator<NumberGroupMembership>;

    listAllNumberGroupMembersPage(numberGroupId: string, url?: string): Promise<PagedResponse<NumberGroupMembership>>;

    retrieveNumberGroupMember(numberGroupMemberId: string): Promise<NumberGroupMembership>;

    createNumberGroupMember(numberGroupId: string, request: CreateNumberGroupMemberRequest): Promise<NumberGroupMembership>;

    deleteNumberGroupMember(numberGroupMemberId: string): Promise<void>;
}

export interface ListAllPhoneNumbersOptions {
    filterName?: string,
    filterNumber?: string
}

export type PhoneNumberListingType = 'local' | 'toll-free';

export type PhoneNumberType = 'longcode' | 'toll-free';

export type CallReceiveMode = 'voice' | 'fax';

export interface RelayScriptPhoneNumberCallHandler {
    type: 'relay_script';
    callRelayScriptUrl: string;
}

export interface LamlWebhooksPhoneNumberCallHandler {
    type: 'laml_webhooks';
    callRequestUrl: string;
    callRequestMethod?: HTTPMethod;
    callFallbackUrl: string;
    callFallbackMethod?: HTTPMethod;
    callStatusCallbackUrl: string;
    callStatusCallbackMethod?: HTTPMethod;
}

export interface LamlApplicationPhoneNumberCallHandler {
    type: 'laml_application';
    callLamlApplicationId: string;
}


export interface DialogflowPhoneNumberCallHandler {
    type: 'dialogflow';
    callDialogflowAgentId: string;
}

export interface RelayTopicPhoneNumberCallHandler {
    type: 'relay_topic';
    callRelayTopic: string;
    callRelayTopicStatusCallbackUrl: string;
}

export interface RelayContextPhoneNumberCallHandler {
    type: 'relay_context';
    callRelayContext: string;
    callRelayContextStatusCallbackUrl: string;
}

export interface RelayApplicationPhoneNumberCallHandler {
    type: 'relay_application';
    callRelayApplication: string;
}

export interface RelayConnectorPhoneNumberCallHandler {
    type: 'relay_connector';
    callRelayConnectorId: string;
}

export interface RelaySipEndpointPhoneNumberCallHandler {
    type: 'relay_sip_endpoint';
    callSipEndpointId: string;
}

export interface RelayVertoPhoneNumberCallHandler {
    type: 'relay_verto_endpoint';
    callVertoResource: string;
}

export interface VideoRoomPhoneNumberCallHandler {
    type: 'video_room';
    callVideoRoomId: string;
}

export type PhoneNumberCallHandler =
    RelayScriptPhoneNumberCallHandler
    | RelayConnectorPhoneNumberCallHandler
    | LamlWebhooksPhoneNumberCallHandler
    | LamlApplicationPhoneNumberCallHandler
    | DialogflowPhoneNumberCallHandler
    | RelayTopicPhoneNumberCallHandler
    | RelayContextPhoneNumberCallHandler
    | RelayApplicationPhoneNumberCallHandler
    | RelaySipEndpointPhoneNumberCallHandler
    | RelayVertoPhoneNumberCallHandler
    | VideoRoomPhoneNumberCallHandler;

export interface LamlWebhooksPhoneNumberMessageHandler {
    type: 'laml_webhooks';
    messageRequestUrl: string;
    messageRequestMethod?: HTTPMethod;
    messageFallbackUrl: string;
    messageFallbackMethod?: HTTPMethod;
    messageStatusCallbackUrl: string;
    messageStatusCallbackMethod?: HTTPMethod;
}

export interface LamlApplicationPhoneNumberMessageHandler {
    type: 'laml_application';
    messageLamlApplicationId: string;
}

export interface RelayApplicationPhoneNumberMessageHandler {
    type: 'relay_application';
    messageRelayApplicationId: string;
}

export interface RelayTopicPhoneNumberMessageHandler {
    type: 'relay_topic';
    messageRelayTopic: string;
}

export interface RelayContextPhoneNumberMessageHandler {
    type: 'relay_context';
    messageRelayContext: string;
}

export type PhoneNumberMessageHandler =
    LamlWebhooksPhoneNumberMessageHandler
    | RelayApplicationPhoneNumberMessageHandler
    | RelayTopicPhoneNumberMessageHandler
    | RelayContextPhoneNumberMessageHandler
    | LamlApplicationPhoneNumberMessageHandler;

export interface UpdatePhoneNumberRequest {
    name: string;
    callReceiveMode?: CallReceiveMode;
    callHandler?: PhoneNumberCallHandler;
    messageHandler?: PhoneNumberMessageHandler;
}

export interface PhoneNumber {
    id: string;
    number: string;
    name: string;
    callHandler?: PhoneNumberCallHandler;
    messageHandler?: PhoneNumberMessageHandler;
    callReceiveMode: CallReceiveMode;
    capabilities: NumberCapability[];
    numberType: PhoneNumberType;
    e911AddressId?: string;
    createdAt: string;
    updatedAt: string;
    nextBilledAt: string;
    countryCode: string;
}

export interface PhoneNumberListing {
    e164: string;
    nationalNumberFormatted: string;
    internationalNumberFormatted: string;
    rateCenter: string;
    region: string;
    countryCode: string;
    capabilities: NumberCapability[];
}

export interface SearchForAvailablePhoneNumbersOptions {
    areacode?: string,
    numberType?: PhoneNumberListingType,
    startsWith?: string,
    contains?: string,
    endsWith?: string,
    maxResults?: string,
    region?: string,
    city?: string
}


export interface PurchasePhoneNumberRequest {
    number: string;
}

export interface PhoneNumbersNamespace {
    listAllPhoneNumbers(options?: ListAllPhoneNumbersOptions): AsyncIterableIterator<PhoneNumber>;

    listAllPhoneNumbersPage(options?: ListAllPhoneNumbersOptions, url?: string): Promise<PagedResponse<PhoneNumber>>;

    retrievePhoneNumber(id: string): Promise<PhoneNumber>;

    updatePhoneNumber(id: string, request: UpdatePhoneNumberRequest): Promise<PhoneNumber>;

    searchForAvailablePhoneNumbers(options?: SearchForAvailablePhoneNumbersOptions): AsyncIterableIterator<PhoneNumberListing>;

    searchForAvailablePhoneNumbersPage(options?: SearchForAvailablePhoneNumbersOptions, url?: string): Promise<PagedResponse<PhoneNumberListing>>;

    purchasePhoneNumber(request: PurchasePhoneNumberRequest): Promise<PhoneNumber>;

    releasePhoneNumber(id: string): Promise<void>;
}

export type LookupNumberInclude = 'carrier' | 'cnam';

export interface LookupNumberOptions {
    include?: LookupNumberInclude[];
}

export interface LookupNumberResponse {
    countryCodeNumber: number;
    nationalNumber: string;
    possibleNumber: boolean;
    validNumber: boolean;
    nationalNumberFormatted: string;
    internationalNumberFormatted: string;
    e164: string;
    location: string;
    countryCode: string;
    timeZones: string[];
    numberType: string;
    carrier?: {
        lrn: string;
        spid: string;
        ocn: string;
        lata: string;
        city: string;
        state: string;
        jurisdiction: string;
        lec: string;
        lineType: string;
    }
    cnam?: {
        callerId: string;
    }
}


export interface PhoneNumberLookupNamespace {
    lookupNumber(phoneNumber: string, options?: LookupNumberOptions): Promise<LookupNumberResponse>;
}

export interface ListAllSipEndpointsOptions {
    filterUsername?: string,
    filterCallerId?: string
}

export interface SipEndpointDefaultCallHandler {
    type: 'default';
}

export interface SipEndpointPassthroughCallHandler {
    type: 'passthrough';
}

export interface SipEndpointBlockPSTNCallHandler {
    type: 'block-pstn';
}

export interface SipEndpointAiAgentCallHandler {
    type: 'ai_agent';
    callAiAgentId: string;
}

export interface SipEndpointRelayContextCallHandler {
    type: 'relay_context';
    callRelayContext: string;
    callRelayContextStatusCallbackUrl: string;
}

export interface SipEndpointRelayScriptCallHandler {
    type: 'relay_script';
    callRelayScriptUrl: string;
}

export interface SipEndpointLamlWebhooksCallHandler {
    type: 'laml_webhooks';
    callRequestUrl: string;
    callRequestMethod?: HTTPMethod;
    callFallbackUrl: string;
    callFallbackMethod?: HTTPMethod;
    callStatusCallbackUrl: string;
    callStatusCallbackMethod?: HTTPMethod;
}

export interface SipEndpointLamlApplicationCallHandler {
    type: 'laml_application';
    callLamlApplicationId: string;
}

export interface SipEndpointDialogflowCallHandler {
    type: 'dialogflow';
    callDialogflowAgentId: string;
}

export interface SipEndpointVideoRoomCallHandler {
    type: 'video_room';
    callVideoRoomId: string;
}

export type SipEndpointCallHandler =
    SipEndpointDefaultCallHandler
    | SipEndpointPassthroughCallHandler
    | SipEndpointBlockPSTNCallHandler
    | SipEndpointAiAgentCallHandler
    | SipEndpointRelayContextCallHandler
    | SipEndpointRelayScriptCallHandler
    | SipEndpointLamlWebhooksCallHandler
    | SipEndpointLamlApplicationCallHandler
    | SipEndpointDialogflowCallHandler
    | SipEndpointVideoRoomCallHandler;

export type SipEndpointEncryption = 'default' | 'optional' | 'required';

export interface UpdateSipEndpointRequest {
    username?: string;
    password?: string;
    callerId?: string;
    sendAs?: string;
    ciphers?: Cipher[];
    codecs?: Codec[];
    encryption?: SipEndpointEncryption;
    callHandler?: SipEndpointCallHandler;
}

export interface CreateSipEndpointRequest {
    username: string;
    password: string;
    callerId?: string;
    sendAs?: string;
    ciphers?: Cipher[];
    codecs?: Codec[];
    encryption?: SipEndpointEncryption;
    callHandler?: SipEndpointCallHandler;
}

export interface SipEndpoint {
    id: string;
    username: string;
    callerId: string;
    sendAs: string;
    ciphers: Cipher[];
    codecs: Codec[];
    encryption: SipEndpointEncryption;
    callHandler: SipEndpointCallHandler;
}

export interface SipEndpointsNamespace {
    listAllSipEndpoints(options?: ListAllSipEndpointsOptions): AsyncIterableIterator<SipEndpoint>;

    listAllSipEndpointsPage(options?: ListAllSipEndpointsOptions, url?: string): Promise<PagedResponse<SipEndpoint>>;

    retrieveSipEndpoint(id: string): Promise<SipEndpoint>;

    updateSipEndpoint(id: string, request: UpdateSipEndpointRequest): Promise<SipEndpoint>;

    createSipEndpoint(request: CreateSipEndpointRequest): Promise<SipEndpoint>;

    deleteSipEndpoint(id: string): Promise<void>;
}

export interface UpdateSipProfileRequest {
    domainIdentifier?: string;
    defaultCodecs?: Codec[];
    defaultCiphers?: Cipher[];
    defaultEncryption?: Encryption;
    defaultSendAs?: string;
}

export interface SipProfile {
    domain: string;
    domainIdentifier: string;
    defaultCodecs: Codec[];
    defaultCiphers: Cipher[];
    defaultEncryption: Encryption;
    defaultSendAs: string;
}

export interface SipProfileNamespace {
    retrieveSipProfile(): Promise<SipProfile>;

    updateSipProfile(body: UpdateSipProfileRequest): Promise<SipProfile>;
}

export interface BaseRecording {
    id: string;
    projectId: string;
    createdAt: string;
    updatedAt: string;
    durationInSeconds: number;
    errorCode: string;
    price: number;
    priceUnit: string;
    status: string;
    url: string;
    stereo: boolean;
    byteSize: number;
    track: string;
}

export interface PSTNRecording extends BaseRecording {
    relayPSTNLegId: string;
}

export interface SIPRecording extends BaseRecording {
    relaySIPLegId: string;
}

export interface WebRTCRecording extends BaseRecording {
    relayWebRTCLegId: string;
}

export type Recording = PSTNRecording | SIPRecording | WebRTCRecording;

export interface RelayRecordingsNamespace {
    listRelayRecordings(): AsyncIterableIterator<Recording>;

    listRelayRecordingsPage(url?: string): Promise<PagedResponse<Recording>>;

    getRelayRecording(id: string): Promise<Recording>;

    deleteRelayRecording(id: string): Promise<void>;
}

export interface SpaceManagementNamespace {
    multiFactorAuthentication: MultiFactorAuthenticationNamespace;
    verifiedCallerIds: VerifiedCallerIdsNamespace;
    addresses: AddressesNamespace;
    campaignRegistryApi: CampaignRegistryApiNamespace;
    domainApplications: DomainApplicationsNamespace;
    numberGroups: NumberGroupsNamespace;
    numberGroupsMemberships: NumberGroupsMembershipsNamespace;
    phoneNumbers: PhoneNumbersNamespace;
    phoneNumberLookup: PhoneNumberLookupNamespace;
    sipEndpoints: SipEndpointsNamespace;
    sipProfile: SipProfileNamespace;
    relayRecordings: RelayRecordingsNamespace;
}

export type VideoRoomResolution = '720p' | '1080p';

export interface CreateVideoRoomRequest {
    name: string;
    displayName: string;
    description?: string;
    maxMembers?: number;
    quality?: VideoRoomResolution;
    joinFrom?: string;
    joinUntil?: string;
    removeAt?: string;
    removeAfterSecondsElapsed?: number;
    layout?: string;
    recordOnStart?: boolean;
    enableRoomPreviews?: boolean;
    audioVideoSync?: boolean;
}

export interface UpdateVideoRoomRequest {
    name?: string;
    displayName?: string;
    description?: string;
    maxMembers?: number;
    quality?: VideoRoomResolution;
    joinFrom?: string;
    joinUntil?: string;
    removeAt?: string;
    removeAfterSecondsElapsed?: number;
    layout?: string;
    recordOnStart?: boolean;
    enableRoomPreviews?: boolean;
    audioVideoSync?: boolean;
}

export interface VideoRoom {
    id: string;
    name: string;
    displayName: string;
    description: string;
    maxMembers: number;
    quality: VideoRoomResolution;
    joinFrom: string;
    joinUntil: string;
    removeAt: string;
    removeAfterSecondsElapsed: number;
    layout: string;
    recordOnStart: boolean;
    enableRoomPreviews: boolean;
    audioVideoSync: boolean;
    fps: number;
    activeSession?: VideoRoomSession;
    createdAt: string;
    updatedAt: string;
}

export interface VideoRoomSession {
    id: string;
    roomId: string;
    name: string;
    displayName: string;
    joinFrom: string;
    joinUntil: string;
    removeAt: string;
    removeAfterSecondsElapsed: number;
    layout: string;
    maxMembers: number;
    fps: number;
    quality: VideoRoomResolution;
    startTime: string;
    endTime: string;
    duration: number;
    status: string;
    recordOnStart: boolean;
    enableRoomPreviews: boolean;
    previewUrl: string;
    audioVideoSync: boolean;
}

export interface GetVideoRoomOptions {
    includeActiveSession?: string
}

export interface VideoRoomsNamespace {
    listRooms(options?: GetVideoRoomOptions): AsyncIterableIterator<VideoRoom>;

    listRoomsPage(options?: GetVideoRoomOptions, url?: string): Promise<PagedResponse<VideoRoom>>;

    retrieveRoomById(id: string): Promise<VideoRoom>;

    retrieveRoomByUniqueName(videoRoomName: string, options?: GetVideoRoomOptions): Promise<VideoRoom>;

    createRoom(request: CreateVideoRoomRequest): Promise<VideoRoom>;

    updateRoom(id: string, request: UpdateVideoRoomRequest): Promise<VideoRoom>;

    deleteRoom(id: string): Promise<void>;
}

export interface ListRoomSessionsRecordingsOptions {
    mediaTtl?: string
}

export interface ListRoomSessionsOptions {
    roomId?: string,
    roomName?: string,
    status?: string
}

export interface VideoRoomRecording {
    id: string;
    roomSessionId: string;
    status: string;
    startedAt: string;
    finishedAt: string;
    duration: number;
    sizeInBytes: number;
    format: string;
    uri: string;
    createdAt: string;
    updatedAt: string;
}

export interface VideoRoomSessionMember {
    id: string;
    name: string;
    roomSessionId: string;
    joinTime: string;
    leaveTime: string;
    duration: number;
}


export interface VideoRoomSessionsNamespace {
    listRoomSessions(options?: ListRoomSessionsOptions): AsyncIterableIterator<VideoRoomSession>;

    listRoomSessionsPage(options?: ListRoomSessionsOptions, url?: string): Promise<PagedResponse<VideoRoomSession>>;

    findRoomSessionById(sessionId: string): Promise<VideoRoomSession>;

    listRoomSessionsRecordings(sessionId: string, options?: ListRoomSessionsRecordingsOptions):
        AsyncIterableIterator<VideoRoomRecording>;

    listRoomSessionsRecordingsPage(sessionId: string, options?: ListRoomSessionsRecordingsOptions, url?: string):
        Promise<PagedResponse<VideoRoomRecording>>;

    listRoomSessionsMembers(sessionId: string): AsyncIterableIterator<VideoRoomSessionMember>;

    listRoomSessionsMembersPage(sessionId: string, url?: string): Promise<PagedResponse<VideoRoomSessionMember>>;
}

export interface VideoRoomTokenRequest {
    roomName: string;
    userName?: string;
    permissions?: string[];
    joinFrom?: string;
    joinUntil?: string;
    removeAt?: string;
    removeAfterSecondsElapsed?: number;
    joinAudioMuted?: boolean;
    joinVideoMuted?: boolean;
    autoCreateRoom?: boolean;
    enableRoomPreviews?: boolean;
    roomDisplayName?: string;
    endRoomSessionOnLeave?: boolean;
    joinAs?: 'audience' | 'member';
    mediaAllowed?: 'all' | 'video-only' | 'audio-only';
    roomMeta?: object;
    meta?: object;
    audioVideoSync?: boolean;
}

export interface VideoRoomToken {
    token: string;
}

export interface VideoRoomTokensNamespace {
    generateNewVideoRoomToken(request: VideoRoomTokenRequest): Promise<any>;
}

export interface ListRecordingsForVideoRoomOptions {
    mediaTtl?: string
}


export interface RetrieveVideoRoomRecordingOptions {
    mediaTtl?: string
}


export interface VideoRoomRecordingsNamespace {
    listRecordingsForRoom(options?: ListRecordingsForVideoRoomOptions): AsyncIterableIterator<VideoRoomRecording>;

    listRecordingsForRoomPage(options?: ListRecordingsForVideoRoomOptions, url?: string): Promise<PagedResponse<VideoRoomRecording>>;

    retrieveRecording(recordingId: string, options?: RetrieveVideoRoomRecordingOptions): Promise<any>;

    deleteRoomRecording(recordingId: string): Promise<any>;
}

export interface VideoRoomStream {
    id: string;
    url: string;
    streamType: string;
    width: number;
    height: number;
    fps: number;
    createdAt: string;
    updatedAt: string;
}

export interface CreateStreamRequest {
    url: string;
}

export interface UpdateStreamRequest {
    url?: string;
}

export interface VideoStreamsNamespace {
    listStreamsByRoomId(roomId: string): AsyncIterableIterator<VideoRoomStream>;

    listStreamsByRoomIdPage(roomId: string, url?: string): Promise<PagedResponse<VideoRoomStream>>;

    listStreamsByConferenceId(conferenceId: string): AsyncIterableIterator<VideoRoomStream>;

    listStreamsByConferenceIdPage(conferenceId: string, url?: string): Promise<PagedResponse<VideoRoomStream>>;

    createStreamForRoom(roomId: string, request: CreateStreamRequest): Promise<VideoRoomStream>;

    createStreamForConference(conferenceId: string, request: CreateStreamRequest): Promise<VideoRoomStream>;

    retrieveStream(streamId: string): Promise<VideoRoomStream>;

    updateStream(streamId: string, request: UpdateStreamRequest): Promise<VideoRoomStream>;

    deleteStream(streamId: string): Promise<void>;
}

export interface ListVideoConferencesOptions {
    includeActiveSession?: string
}


export interface RetrieveVideoConferenceOptions {
    includeActiveSession?: string
}

export type VideoConferenceSize = 'small' | 'medium' | 'large';

export interface CreateVideoConferenceRequest {
    name: string;
    displayName?: string;
    description?: string;
    joinFrom?: string;
    joinUntil?: string;
    quality?: VideoRoomResolution;
    layout?: string;
    size?: VideoConferenceSize;
    recordOnStart?: boolean;
    enableRoomPreviews?: boolean;
    enableChat?: boolean;
    darkPrimary?: string;
    darkBackground?: string;
    darkForeground?: string;
    darkSuccess?: string;
    darkNegative?: string;
    lightPrimary?: string;
    lightBackground?: string;
    lightForeground?: string;
    lightSuccess?: string;
    lightNegative?: string;
}

export interface UpdateVideoConferenceRequest {
    name?: string;
    displayName?: string;
    description?: string;
    joinFrom?: string;
    joinUntil?: string
    quality?: VideoRoomResolution;
    layout?: string;
    size?: VideoConferenceSize;
    recordOnStart?: boolean;
    enableRoomPreviews?: boolean;
    enableChat?: boolean;
    darkPrimary?: string;
    darkBackground?: string;
    darkForeground?: string;
    darkSuccess?: string;
    darkNegative?: string;
    lightPrimary?: string;
    lightBackground?: string;
    lightForeground?: string;
    lightSuccess?: string;
    lightNegative?: string;
}

export interface VideoConference {
    id: string;
    name: string;
    displayName: string;
    description: string;
    joinFrom: string;
    joinUntil: string;
    quality: VideoRoomResolution;
    layout: string;
    size: VideoConferenceSize;
    recordOnStart: boolean;
    enableRoomPreviews: boolean;
    enableChat: boolean;
    darkPrimary: string;
    darkBackground: string;
    darkForeground: string;
    darkSuccess: string;
    darkNegative: string;
    lightPrimary: string;
    lightBackground: string;
    lightForeground: string;
    lightSuccess: string;
    lightNegative: string;
    createdAt: string;
    updatedAt: string;
    activeSession?: VideoRoomSession;
}

export interface VideoConferencesNamespace {
    listVideoConferences(options?: ListVideoConferencesOptions): AsyncIterableIterator<VideoConference>;

    listVideoConferencesPage(options?: ListVideoConferencesOptions, url?: string): Promise<PagedResponse<VideoConference>>;

    retrieveVideoConference(conferenceId: string, options?: RetrieveVideoConferenceOptions): Promise<VideoConference>;

    createVideoConference(request: CreateVideoConferenceRequest): Promise<VideoConference>;

    updateVideoConference(conferenceId: string, request: UpdateVideoConferenceRequest): Promise<VideoConference>;

    deleteVideoConference(conferenceId: string): Promise<void>;
}

export interface VideoConferenceToken {
    id: string;
    name: string;
    token: string;
    scopes: string[];
}

export interface VideoConferenceTokensNamespace {
    listConferenceTokens(conferenceId: string): AsyncIterableIterator<VideoConferenceToken>;

    listConferenceTokensPage(conferenceId: string, url?: string): Promise<PagedResponse<VideoConferenceToken>>;

    retrieveConferenceToken(conferenceTokenId: string): Promise<VideoConferenceToken>;

    resetConferenceToken(conferenceTokenId: string): Promise<VideoConferenceToken>;
}

export interface ListVideoLogsOptions {
    includeDeleted?: string,
    createdBefore?: string,
    createdOn?: string,
    createdAfter?: string,
    pageSize?: string
}

export interface VideoLog {
    id: string;
    source: string;
    type: string;
    url: string;
    roomName: string;
    status: string;
    startTime: string;
    endTime: string;
    charge: number;
    chargeDetails: LogCharge[];
    createdAt: string;
    updatedAt: string;
}


export interface VideoLogsNamespace {
    listLogs(options?: ListVideoLogsOptions): AsyncIterableIterator<VideoLog>;

    listLogsPage(options?: ListVideoLogsOptions, url?: string): Promise<PagedResponse<VideoLog>>;

    retrieveLog(id: string): Promise<VideoLog>;
}

export interface VideoNamespace {
    rooms: VideoRoomsNamespace;
    roomSessions: VideoRoomSessionsNamespace;
    roomTokens: VideoRoomTokensNamespace;
    roomRecordings: VideoRoomRecordingsNamespace;
    streams: VideoStreamsNamespace;
    conferences: VideoConferencesNamespace;
    conferenceTokens: VideoConferenceTokensNamespace;
    logs: VideoLogsNamespace;
}

export interface ListMessageLogsOptions {
    includeDeleted?: string,
    createdBefore?: string,
    createdOn?: string,
    createdAfter?: string,
    pageSize?: string
}

export interface MessageLog {
    id: string;
    from: string;
    to: string;
    status: string;
    direction: string;
    kind: string;
    source: string;
    type: string;
    url: string;
    numberOfSegments: number;
    charge: number;
    chargeDetails: LogCharge[];
    createdAt: string;
}


export interface MessageLogsNamespace {
    listLogs(options?: ListMessageLogsOptions): AsyncIterableIterator<MessageLog>;

    listLogsPage(options?: ListMessageLogsOptions, url?: string): Promise<PagedResponse<MessageLog>>;

    retrieveLog(id: string): Promise<MessageLog>;
}

export interface MessageNamespace {
    logs: MessageLogsNamespace;
}

export interface VoiceLogsListLogsOptions {
    includeDeleted?: string,
    createdBefore?: string,
    createdOn?: string,
    createdAfter?: string,
    pageSize?: number
}

export interface VoiceLog {
    id: string;
    from: string;
    to: string;
    direction: string;
    status: string;
    duration: number;
    durationMS: number;
    billingMS: number;
    source: string;
    type: string;
    url: string;
    charge: number;
    chargeDetails: LogCharge[];
    createdAt: string;
}

export interface VoiceLogsNamespace {
    listLogs(options?: VoiceLogsListLogsOptions): AsyncIterableIterator<VoiceLog>;

    listLogsPage(options?: VoiceLogsListLogsOptions, url?: string): Promise<PagedResponse<VoiceLog>>;

    retrieveLog(voiceLogId: string): Promise<any>;
}

export interface VoiceNamespace {
    logs: VoiceLogsNamespace;
}

export interface ListFaxLogsOptions {
    includeDeleted?: string,
    createdBefore?: string,
    createdOn?: string,
    createdAfter?: string,
    pageSize?: string
}

export interface FaxLog {
    id: string;
    from: string;
    to: string;
    status: string;
    direction: string;
    source: string;
    type: string;
    url: string;
    remoteStation: string;
    charge: number;
    numberOfPages: number;
    quality: string;
    chargeDetails: LogCharge[];
    createdAt: string;
    updatedAt: string;
    errorCode: string;
    errorMessage: string;
}


export interface FaxLogsNamespace {
    listLogs(options?: ListFaxLogsOptions): AsyncIterableIterator<FaxLog>;

    listLogsPage(options?: ListFaxLogsOptions, url?: string): Promise<PagedResponse<FaxLog>>;

    retrieveFaxLog(id: string): Promise<FaxLog>;
}

export interface FaxNamespace {
    logs: FaxLogsNamespace;
}

export type Permission = 'calling' | 'chat' | 'fax' | 'management' | 'messaging' | 'numbers' | 'pubsub' | 'storage'
    | 'tasking' | 'video' | 'datasphere';

export interface CreateApiTokenRequest {
    name: string;
    permissions: Permission[];
    subProjectId?: string;
}

export interface UpdateApiTokenRequest {
    name?: string;
    permissions?: Permission[];
}

export interface ApiToken {
    id: string;
    name: string;
    permissions: Permission[];
    token: string;
}

export interface ProjectApiTokensNamespace {
    createApiToken(request: CreateApiTokenRequest): Promise<ApiToken>;

    updateApiToken(id: string, request: UpdateApiTokenRequest): Promise<ApiToken>;

    deleteApiToken(id: string): Promise<void>;
}

export interface ProjectNamespace {
    apiTokens: ProjectApiTokensNamespace;
}

export interface GeneratePubSubTokenRequest {
    ttl: number;
    channels: {
        [name: string]: {
            read: boolean;
            write: boolean;
        }
    }
    memberId?: string;
    state?: object;
}

export interface GeneratePubSubTokenResponse {
    token: string;
}

export interface PubSubTokenNamespace {
    generateToken(request: GeneratePubSubTokenRequest): Promise<GeneratePubSubTokenResponse>;
}

export interface PubSubNamespace {
    tokens: PubSubTokenNamespace;
}

export interface GenerateChatTokenRequest {
    ttl: number;
    channels: {
        [name: string]: {
            read: boolean;
            write: boolean;
        }
    };
    memberId?: string;
    state?: any;
}

export interface ChatToken {
    token: string;
}

export interface ChatNamespace {
    generateChatToken(request: GenerateChatTokenRequest): Promise<ChatToken>;
}

export interface ListFabricResourcesOptions {
    type?: string
}


export interface AssignResourceAsPhoneRouteHandlerRequest {
    phoneRouteId: string;
    handler: string;
}

export interface AssignResourceAsSipEndpointHandlerRequest {
    sipEndpointId: string;
}

export interface AssignResourceAsDomainApplicationHandlerRequest {
    domainApplicationId: string;
}

export interface FabricResourceBase {
    id: string;
    projectId: string;
    displayName: string;
    createdAt: string;
    updatedAt: string;
}

export interface FabricResourceAddress {
    id: string;
    resourceId: string;
    name: string;
    displayName: string;
    coverUrl: string;
    previewUrl: string;
    locked: boolean;
    channels: {
        video: string;
        audio: string;
        messaging: string;
    }

}

export interface UpdateFabricSubscriberRequest {
    password?: string;
    email: string;
    firstName?: string;
    lastName?: string;
    displayName?: string;
    jobTitle?: string;
    timezone?: string
    country?: string;
    region?: string;
    companyName?: string;
}

export interface CreateFabricSubscriberRequest {
    password?: string;
    email: string;
    firstName?: string;
    lastName?: string;
    displayName?: string;
    jobTitle?: string;
    timezone?: string;
    country?: string;
    region?: string;
    companyName?: string;
}

export interface FabricSubscriber {
    id: string;
    email: string;
    firstName: string;
    lastName: string;
    displayName: string;
    jobTitle: string;
    timezone: string;
    country: string;
    region: string;
    companyName: string;
}

export interface FabricSubscriberResponse extends FabricResourceBase {
    type: 'subscriber';
    subscriber: FabricSubscriber;
}

export interface CreateFabricSubscriberTokenRequest {
    reference: string;
    expireAt?: number;
    applicationId?: string;
    password?: stri