import * as HttpClient from "effect/unstable/http/HttpClient";
import * as S from "effect/Schema";
import * as stream from "effect/Stream";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import type { CommonErrors } from "../errors.ts";
import type { Region } from "../region.ts";
export type TaggableArn = string;
export type TagKey = string;
export type TagValue = string;
export type Catalog = string;
export type AssociatedResourceIdentifier = string;
export type ProgramManagementAccountIdentifier = string;
export type Note = string;
export type MinimumNoticeDays = string;
export type ClientToken = string;
export type ChannelHandshakeId = string;
export type Arn = string;
export type NextToken = string;
export type AccountId = string;
export type PartnerProfileDisplayName = string;
export type AssociatedResourceId = string;
export type ChannelHandshakeIdentifier = string;
export type ProgramManagementAccountDisplayName = string;
export type ProgramManagementAccountId = string;
export type Revision = string;
export type RelationshipDisplayName = string;
export type RelationshipId = string;
export type RelationshipIdentifier = string;
export interface ListTagsForResourceRequest {
    resourceArn: string;
}
export declare const ListTagsForResourceRequest: S.Schema<ListTagsForResourceRequest>;
export interface Tag {
    key: string;
    value: string;
}
export declare const Tag: S.Schema<Tag>;
export type TagList = Tag[];
export declare const TagList: S.$Array<S.Schema<Tag>>;
export interface ListTagsForResourceResponse {
    tags?: Tag[];
}
export declare const ListTagsForResourceResponse: S.Schema<ListTagsForResourceResponse>;
export type ValidationExceptionReason = "REQUEST_VALIDATION_FAILED" | "BUSINESS_VALIDATION_FAILED" | (string & {});
export declare const ValidationExceptionReason: S.String;
export interface ValidationExceptionField {
    name: string;
    code: string;
    message: string;
}
export declare const ValidationExceptionField: S.Schema<ValidationExceptionField>;
export type ValidationExceptionFieldList = ValidationExceptionField[];
export declare const ValidationExceptionFieldList: S.$Array<S.Schema<ValidationExceptionField>>;
export interface TagResourceRequest {
    resourceArn: string;
    tags: Tag[];
}
export declare const TagResourceRequest: S.Schema<TagResourceRequest>;
export interface TagResourceResponse {
}
export declare const TagResourceResponse: S.Schema<TagResourceResponse>;
export type TagKeyList = string[];
export declare const TagKeyList: S.$Array<S.String>;
export interface UntagResourceRequest {
    resourceArn: string;
    tagKeys: string[];
}
export declare const UntagResourceRequest: S.Schema<UntagResourceRequest>;
export interface UntagResourceResponse {
}
export declare const UntagResourceResponse: S.Schema<UntagResourceResponse>;
export type HandshakeType = "START_SERVICE_PERIOD" | "REVOKE_SERVICE_PERIOD" | "PROGRAM_MANAGEMENT_ACCOUNT" | (string & {});
export declare const HandshakeType: S.String;
export type ServicePeriodType = "MINIMUM_NOTICE_PERIOD" | "FIXED_COMMITMENT_PERIOD" | (string & {});
export declare const ServicePeriodType: S.String;
export interface StartServicePeriodPayload {
    programManagementAccountIdentifier: string;
    note?: string;
    servicePeriodType: ServicePeriodType;
    minimumNoticeDays?: string;
    endDate?: Date;
}
export declare const StartServicePeriodPayload: S.Schema<StartServicePeriodPayload>;
export interface RevokeServicePeriodPayload {
    programManagementAccountIdentifier: string;
    note?: string;
}
export declare const RevokeServicePeriodPayload: S.Schema<RevokeServicePeriodPayload>;
export type ChannelHandshakePayload = {
    startServicePeriodPayload: StartServicePeriodPayload;
    revokeServicePeriodPayload?: never;
} | {
    startServicePeriodPayload?: never;
    revokeServicePeriodPayload: RevokeServicePeriodPayload;
};
export declare const ChannelHandshakePayload: S.Union<readonly [S.Struct<{
    readonly startServicePeriodPayload: S.Schema<StartServicePeriodPayload>;
}>, S.Struct<{
    readonly revokeServicePeriodPayload: S.Schema<RevokeServicePeriodPayload>;
}>]>;
export interface CreateChannelHandshakeRequest {
    handshakeType: HandshakeType;
    catalog: string;
    associatedResourceIdentifier: string;
    payload?: ChannelHandshakePayload;
    clientToken?: string;
    tags?: Tag[];
}
export declare const CreateChannelHandshakeRequest: S.Schema<CreateChannelHandshakeRequest>;
export interface CreateChannelHandshakeDetail {
    id?: string;
    arn?: string;
}
export declare const CreateChannelHandshakeDetail: S.Schema<CreateChannelHandshakeDetail>;
export interface CreateChannelHandshakeResponse {
    channelHandshakeDetail?: CreateChannelHandshakeDetail;
}
export declare const CreateChannelHandshakeResponse: S.Schema<CreateChannelHandshakeResponse>;
export type ParticipantType = "SENDER" | "RECEIVER" | (string & {});
export declare const ParticipantType: S.String;
export type HandshakeStatus = "PENDING" | "ACCEPTED" | "REJECTED" | "CANCELED" | "EXPIRED" | (string & {});
export declare const HandshakeStatus: S.String;
export type HandshakeStatusList = HandshakeStatus[];
export declare const HandshakeStatusList: S.$Array<S.String>;
export type AssociatedResourceIdentifierList = string[];
export declare const AssociatedResourceIdentifierList: S.$Array<S.String>;
export type ServicePeriodTypeList = ServicePeriodType[];
export declare const ServicePeriodTypeList: S.$Array<S.String>;
export interface StartServicePeriodTypeFilters {
    servicePeriodTypes?: ServicePeriodType[];
}
export declare const StartServicePeriodTypeFilters: S.Schema<StartServicePeriodTypeFilters>;
export interface RevokeServicePeriodTypeFilters {
    servicePeriodTypes?: ServicePeriodType[];
}
export declare const RevokeServicePeriodTypeFilters: S.Schema<RevokeServicePeriodTypeFilters>;
export type Program = "SOLUTION_PROVIDER" | "DISTRIBUTION" | "DISTRIBUTION_SELLER" | (string & {});
export declare const Program: S.String;
export type ProgramList = Program[];
export declare const ProgramList: S.$Array<S.String>;
export interface ProgramManagementAccountTypeFilters {
    programs?: Program[];
}
export declare const ProgramManagementAccountTypeFilters: S.Schema<ProgramManagementAccountTypeFilters>;
export type ListChannelHandshakesTypeFilters = {
    startServicePeriodTypeFilters: StartServicePeriodTypeFilters;
    revokeServicePeriodTypeFilters?: never;
    programManagementAccountTypeFilters?: never;
} | {
    startServicePeriodTypeFilters?: never;
    revokeServicePeriodTypeFilters: RevokeServicePeriodTypeFilters;
    programManagementAccountTypeFilters?: never;
} | {
    startServicePeriodTypeFilters?: never;
    revokeServicePeriodTypeFilters?: never;
    programManagementAccountTypeFilters: ProgramManagementAccountTypeFilters;
};
export declare const ListChannelHandshakesTypeFilters: S.Union<readonly [S.Struct<{
    readonly startServicePeriodTypeFilters: S.Schema<StartServicePeriodTypeFilters>;
}>, S.Struct<{
    readonly revokeServicePeriodTypeFilters: S.Schema<RevokeServicePeriodTypeFilters>;
}>, S.Struct<{
    readonly programManagementAccountTypeFilters: S.Schema<ProgramManagementAccountTypeFilters>;
}>]>;
export type SortOrder = "Ascending" | "Descending" | (string & {});
export declare const SortOrder: S.String;
export type StartServicePeriodTypeSortName = "UpdatedAt" | (string & {});
export declare const StartServicePeriodTypeSortName: S.String;
export interface StartServicePeriodTypeSort {
    sortOrder: SortOrder;
    sortBy: StartServicePeriodTypeSortName;
}
export declare const StartServicePeriodTypeSort: S.Schema<StartServicePeriodTypeSort>;
export type RevokeServicePeriodTypeSortName = "UpdatedAt" | (string & {});
export declare const RevokeServicePeriodTypeSortName: S.String;
export interface RevokeServicePeriodTypeSort {
    sortOrder: SortOrder;
    sortBy: RevokeServicePeriodTypeSortName;
}
export declare const RevokeServicePeriodTypeSort: S.Schema<RevokeServicePeriodTypeSort>;
export type ProgramManagementAccountTypeSortName = "UpdatedAt" | (string & {});
export declare const ProgramManagementAccountTypeSortName: S.String;
export interface ProgramManagementAccountTypeSort {
    sortOrder: SortOrder;
    sortBy: ProgramManagementAccountTypeSortName;
}
export declare const ProgramManagementAccountTypeSort: S.Schema<ProgramManagementAccountTypeSort>;
export type ListChannelHandshakesTypeSort = {
    startServicePeriodTypeSort: StartServicePeriodTypeSort;
    revokeServicePeriodTypeSort?: never;
    programManagementAccountTypeSort?: never;
} | {
    startServicePeriodTypeSort?: never;
    revokeServicePeriodTypeSort: RevokeServicePeriodTypeSort;
    programManagementAccountTypeSort?: never;
} | {
    startServicePeriodTypeSort?: never;
    revokeServicePeriodTypeSort?: never;
    programManagementAccountTypeSort: ProgramManagementAccountTypeSort;
};
export declare const ListChannelHandshakesTypeSort: S.Union<readonly [S.Struct<{
    readonly startServicePeriodTypeSort: S.Schema<StartServicePeriodTypeSort>;
}>, S.Struct<{
    readonly revokeServicePeriodTypeSort: S.Schema<RevokeServicePeriodTypeSort>;
}>, S.Struct<{
    readonly programManagementAccountTypeSort: S.Schema<ProgramManagementAccountTypeSort>;
}>]>;
export interface ListChannelHandshakesRequest {
    handshakeType: HandshakeType;
    catalog: string;
    participantType: ParticipantType;
    maxResults?: number;
    statuses?: HandshakeStatus[];
    associatedResourceIdentifiers?: string[];
    handshakeTypeFilters?: ListChannelHandshakesTypeFilters;
    handshakeTypeSort?: ListChannelHandshakesTypeSort;
    nextToken?: string;
}
export declare const ListChannelHandshakesRequest: S.Schema<ListChannelHandshakesRequest>;
export interface StartServicePeriodHandshakeDetail {
    note?: string;
    servicePeriodType?: ServicePeriodType;
    minimumNoticeDays?: string;
    startDate?: Date;
    endDate?: Date;
}
export declare const StartServicePeriodHandshakeDetail: S.Schema<StartServicePeriodHandshakeDetail>;
export interface RevokeServicePeriodHandshakeDetail {
    note?: string;
    servicePeriodType?: ServicePeriodType;
    minimumNoticeDays?: string;
    startDate?: Date;
    endDate?: Date;
}
export declare const RevokeServicePeriodHandshakeDetail: S.Schema<RevokeServicePeriodHandshakeDetail>;
export interface ProgramManagementAccountHandshakeDetail {
    program?: Program;
}
export declare const ProgramManagementAccountHandshakeDetail: S.Schema<ProgramManagementAccountHandshakeDetail>;
export type HandshakeDetail = {
    startServicePeriodHandshakeDetail: StartServicePeriodHandshakeDetail;
    revokeServicePeriodHandshakeDetail?: never;
    programManagementAccountHandshakeDetail?: never;
} | {
    startServicePeriodHandshakeDetail?: never;
    revokeServicePeriodHandshakeDetail: RevokeServicePeriodHandshakeDetail;
    programManagementAccountHandshakeDetail?: never;
} | {
    startServicePeriodHandshakeDetail?: never;
    revokeServicePeriodHandshakeDetail?: never;
    programManagementAccountHandshakeDetail: ProgramManagementAccountHandshakeDetail;
};
export declare const HandshakeDetail: S.Union<readonly [S.Struct<{
    readonly startServicePeriodHandshakeDetail: S.Schema<StartServicePeriodHandshakeDetail>;
}>, S.Struct<{
    readonly revokeServicePeriodHandshakeDetail: S.Schema<RevokeServicePeriodHandshakeDetail>;
}>, S.Struct<{
    readonly programManagementAccountHandshakeDetail: S.Schema<ProgramManagementAccountHandshakeDetail>;
}>]>;
export interface ChannelHandshakeSummary {
    id?: string;
    arn?: string;
    catalog?: string;
    handshakeType?: HandshakeType;
    ownerAccountId?: string;
    senderAccountId?: string;
    senderDisplayName?: string;
    receiverAccountId?: string;
    associatedResourceId?: string;
    detail?: HandshakeDetail;
    createdAt?: Date;
    updatedAt?: Date;
    status?: HandshakeStatus;
}
export declare const ChannelHandshakeSummary: S.Schema<ChannelHandshakeSummary>;
export type ChannelHandshakeSummaries = ChannelHandshakeSummary[];
export declare const ChannelHandshakeSummaries: S.$Array<S.Schema<ChannelHandshakeSummary>>;
export interface ListChannelHandshakesResponse {
    items?: ChannelHandshakeSummary[];
    nextToken?: string;
}
export declare const ListChannelHandshakesResponse: S.Schema<ListChannelHandshakesResponse>;
export interface AcceptChannelHandshakeRequest {
    catalog: string;
    identifier: string;
}
export declare const AcceptChannelHandshakeRequest: S.Schema<AcceptChannelHandshakeRequest>;
export interface AcceptChannelHandshakeDetail {
    id?: string;
    arn?: string;
    status?: HandshakeStatus;
}
export declare const AcceptChannelHandshakeDetail: S.Schema<AcceptChannelHandshakeDetail>;
export interface AcceptChannelHandshakeResponse {
    channelHandshakeDetail?: AcceptChannelHandshakeDetail;
}
export declare const AcceptChannelHandshakeResponse: S.Schema<AcceptChannelHandshakeResponse>;
export interface CancelChannelHandshakeRequest {
    catalog: string;
    identifier: string;
}
export declare const CancelChannelHandshakeRequest: S.Schema<CancelChannelHandshakeRequest>;
export interface CancelChannelHandshakeDetail {
    id?: string;
    arn?: string;
    status?: HandshakeStatus;
}
export declare const CancelChannelHandshakeDetail: S.Schema<CancelChannelHandshakeDetail>;
export interface CancelChannelHandshakeResponse {
    channelHandshakeDetail?: CancelChannelHandshakeDetail;
}
export declare const CancelChannelHandshakeResponse: S.Schema<CancelChannelHandshakeResponse>;
export interface RejectChannelHandshakeRequest {
    catalog: string;
    identifier: string;
}
export declare const RejectChannelHandshakeRequest: S.Schema<RejectChannelHandshakeRequest>;
export interface RejectChannelHandshakeDetail {
    id?: string;
    arn?: string;
    status?: HandshakeStatus;
}
export declare const RejectChannelHandshakeDetail: S.Schema<RejectChannelHandshakeDetail>;
export interface RejectChannelHandshakeResponse {
    channelHandshakeDetail?: RejectChannelHandshakeDetail;
}
export declare const RejectChannelHandshakeResponse: S.Schema<RejectChannelHandshakeResponse>;
export interface CreateProgramManagementAccountRequest {
    catalog: string;
    program: Program;
    displayName: string;
    accountId: string;
    clientToken?: string;
    tags?: Tag[];
}
export declare const CreateProgramManagementAccountRequest: S.Schema<CreateProgramManagementAccountRequest>;
export interface CreateProgramManagementAccountDetail {
    id?: string;
    arn?: string;
}
export declare const CreateProgramManagementAccountDetail: S.Schema<CreateProgramManagementAccountDetail>;
export interface CreateProgramManagementAccountResponse {
    programManagementAccountDetail?: CreateProgramManagementAccountDetail;
}
export declare const CreateProgramManagementAccountResponse: S.Schema<CreateProgramManagementAccountResponse>;
export interface UpdateProgramManagementAccountRequest {
    catalog: string;
    identifier: string;
    revision?: string;
    displayName?: string;
}
export declare const UpdateProgramManagementAccountRequest: S.Schema<UpdateProgramManagementAccountRequest>;
export interface UpdateProgramManagementAccountDetail {
    id?: string;
    arn?: string;
    revision?: string;
    displayName?: string;
}
export declare const UpdateProgramManagementAccountDetail: S.Schema<UpdateProgramManagementAccountDetail>;
export interface UpdateProgramManagementAccountResponse {
    programManagementAccountDetail?: UpdateProgramManagementAccountDetail;
}
export declare const UpdateProgramManagementAccountResponse: S.Schema<UpdateProgramManagementAccountResponse>;
export interface DeleteProgramManagementAccountRequest {
    catalog: string;
    identifier: string;
    clientToken?: string;
}
export declare const DeleteProgramManagementAccountRequest: S.Schema<DeleteProgramManagementAccountRequest>;
export interface DeleteProgramManagementAccountResponse {
}
export declare const DeleteProgramManagementAccountResponse: S.Schema<DeleteProgramManagementAccountResponse>;
export type ProgramManagementAccountDisplayNameList = string[];
export declare const ProgramManagementAccountDisplayNameList: S.$Array<S.String>;
export type AccountIdList = string[];
export declare const AccountIdList: S.$Array<S.String>;
export type ProgramManagementAccountStatus = "PENDING" | "ACTIVE" | "INACTIVE" | (string & {});
export declare const ProgramManagementAccountStatus: S.String;
export type ProgramManagementAccountStatusList = ProgramManagementAccountStatus[];
export declare const ProgramManagementAccountStatusList: S.$Array<S.String>;
export type ListProgramManagementAccountsSortName = "UpdatedAt" | (string & {});
export declare const ListProgramManagementAccountsSortName: S.String;
export interface ListProgramManagementAccountsSortBase {
    sortOrder: SortOrder;
    sortBy: ListProgramManagementAccountsSortName;
}
export declare const ListProgramManagementAccountsSortBase: S.Schema<ListProgramManagementAccountsSortBase>;
export interface ListProgramManagementAccountsRequest {
    catalog: string;
    maxResults?: number;
    displayNames?: string[];
    programs?: Program[];
    accountIds?: string[];
    statuses?: ProgramManagementAccountStatus[];
    sort?: ListProgramManagementAccountsSortBase;
    nextToken?: string;
}
export declare const ListProgramManagementAccountsRequest: S.Schema<ListProgramManagementAccountsRequest>;
export interface ProgramManagementAccountSummary {
    id?: string;
    revision?: string;
    catalog?: string;
    program?: Program;
    displayName?: string;
    accountId?: string;
    arn?: string;
    createdAt?: Date;
    updatedAt?: Date;
    startDate?: Date;
    status?: ProgramManagementAccountStatus;
}
export declare const ProgramManagementAccountSummary: S.Schema<ProgramManagementAccountSummary>;
export type ProgramManagementAccountSummaries = ProgramManagementAccountSummary[];
export declare const ProgramManagementAccountSummaries: S.$Array<S.Schema<ProgramManagementAccountSummary>>;
export interface ListProgramManagementAccountsResponse {
    items?: ProgramManagementAccountSummary[];
    nextToken?: string;
}
export declare const ListProgramManagementAccountsResponse: S.Schema<ListProgramManagementAccountsResponse>;
export type AssociationType = "DOWNSTREAM_SELLER" | "END_CUSTOMER" | "INTERNAL" | (string & {});
export declare const AssociationType: S.String;
export type ResaleAccountModel = "DISTRIBUTOR" | "END_CUSTOMER" | "SOLUTION_PROVIDER" | (string & {});
export declare const ResaleAccountModel: S.String;
export type Sector = "COMMERCIAL" | "GOVERNMENT" | "GOVERNMENT_EXCEPTION" | (string & {});
export declare const Sector: S.String;
export type Coverage = "ENTIRE_ORGANIZATION" | "MANAGEMENT_ACCOUNT_ONLY" | (string & {});
export declare const Coverage: S.String;
export interface ResoldEnterprise {
    coverage: Coverage;
    tamLocation: string;
    chargeAccountId?: string;
}
export declare const ResoldEnterprise: S.Schema<ResoldEnterprise>;
export type Provider = "DISTRIBUTOR" | "DISTRIBUTION_SELLER" | (string & {});
export declare const Provider: S.String;
export interface PartnerLedSupport {
    coverage: Coverage;
    provider?: Provider;
    tamLocation: string;
}
export declare const PartnerLedSupport: S.Schema<PartnerLedSupport>;
export interface ResoldUnifiedOperations {
    coverage: Coverage;
    tamLocation: string;
    chargeAccountId?: string;
}
export declare const ResoldUnifiedOperations: S.Schema<ResoldUnifiedOperations>;
export type SupportPlan = {
    resoldEnterprise: ResoldEnterprise;
    partnerLedSupport?: never;
    resoldUnifiedOperations?: never;
} | {
    resoldEnterprise?: never;
    partnerLedSupport: PartnerLedSupport;
    resoldUnifiedOperations?: never;
} | {
    resoldEnterprise?: never;
    partnerLedSupport?: never;
    resoldUnifiedOperations: ResoldUnifiedOperations;
};
export declare const SupportPlan: S.Union<readonly [S.Struct<{
    readonly resoldEnterprise: S.Schema<ResoldEnterprise>;
}>, S.Struct<{
    readonly partnerLedSupport: S.Schema<PartnerLedSupport>;
}>, S.Struct<{
    readonly resoldUnifiedOperations: S.Schema<ResoldUnifiedOperations>;
}>]>;
export interface CreateRelationshipRequest {
    catalog: string;
    associationType: AssociationType;
    programManagementAccountIdentifier: string;
    associatedAccountId: string;
    displayName: string;
    resaleAccountModel?: ResaleAccountModel;
    sector: Sector;
    clientToken?: string;
    tags?: Tag[];
    requestedSupportPlan?: SupportPlan;
}
export declare const CreateRelationshipRequest: S.Schema<CreateRelationshipRequest>;
export interface CreateRelationshipDetail {
    arn?: string;
    id?: string;
}
export declare const CreateRelationshipDetail: S.Schema<CreateRelationshipDetail>;
export interface CreateRelationshipResponse {
    relationshipDetail?: CreateRelationshipDetail;
}
export declare const CreateRelationshipResponse: S.Schema<CreateRelationshipResponse>;
export interface GetRelationshipRequest {
    catalog: string;
    programManagementAccountIdentifier: string;
    identifier: string;
}
export declare const GetRelationshipRequest: S.Schema<GetRelationshipRequest>;
export interface RelationshipDetail {
    arn?: string;
    id?: string;
    revision?: string;
    catalog?: string;
    associationType?: AssociationType;
    programManagementAccountId?: string;
    associatedAccountId?: string;
    displayName?: string;
    resaleAccountModel?: ResaleAccountModel;
    sector?: Sector;
    createdAt?: Date;
    updatedAt?: Date;
    startDate?: Date;
}
export declare const RelationshipDetail: S.Schema<RelationshipDetail>;
export interface GetRelationshipResponse {
    relationshipDetail?: RelationshipDetail;
}
export declare const GetRelationshipResponse: S.Schema<GetRelationshipResponse>;
export interface UpdateRelationshipRequest {
    catalog: string;
    identifier: string;
    programManagementAccountIdentifier: string;
    revision?: string;
    displayName?: string;
    requestedSupportPlan?: SupportPlan;
}
export declare const UpdateRelationshipRequest: S.Schema<UpdateRelationshipRequest>;
export interface UpdateRelationshipDetail {
    arn?: string;
    id?: string;
    revision?: string;
    displayName?: string;
}
export declare const UpdateRelationshipDetail: S.Schema<UpdateRelationshipDetail>;
export interface UpdateRelationshipResponse {
    relationshipDetail?: UpdateRelationshipDetail;
}
export declare const UpdateRelationshipResponse: S.Schema<UpdateRelationshipResponse>;
export interface DeleteRelationshipRequest {
    catalog: string;
    identifier: string;
    programManagementAccountIdentifier: string;
    clientToken?: string;
}
export declare const DeleteRelationshipRequest: S.Schema<DeleteRelationshipRequest>;
export interface DeleteRelationshipResponse {
}
export declare const DeleteRelationshipResponse: S.Schema<DeleteRelationshipResponse>;
export type AssociationTypeList = AssociationType[];
export declare const AssociationTypeList: S.$Array<S.String>;
export type RelationshipDisplayNameList = string[];
export declare const RelationshipDisplayNameList: S.$Array<S.String>;
export type ProgramManagementAccountIdentifierList = string[];
export declare const ProgramManagementAccountIdentifierList: S.$Array<S.String>;
export type ListRelationshipsSortName = "UpdatedAt" | (string & {});
export declare const ListRelationshipsSortName: S.String;
export interface ListRelationshipsSortBase {
    sortOrder: SortOrder;
    sortBy: ListRelationshipsSortName;
}
export declare const ListRelationshipsSortBase: S.Schema<ListRelationshipsSortBase>;
export interface ListRelationshipsRequest {
    catalog: string;
    maxResults?: number;
    associatedAccountIds?: string[];
    associationTypes?: AssociationType[];
    displayNames?: string[];
    programManagementAccountIdentifiers?: string[];
    sort?: ListRelationshipsSortBase;
    nextToken?: string;
}
export declare const ListRelationshipsRequest: S.Schema<ListRelationshipsRequest>;
export interface RelationshipSummary {
    arn?: string;
    id?: string;
    revision?: string;
    catalog?: string;
    associationType?: AssociationType;
    programManagementAccountId?: string;
    associatedAccountId?: string;
    displayName?: string;
    sector?: Sector;
    createdAt?: Date;
    updatedAt?: Date;
    startDate?: Date;
}
export declare const RelationshipSummary: S.Schema<RelationshipSummary>;
export type RelationshipSummaries = RelationshipSummary[];
export declare const RelationshipSummaries: S.$Array<S.Schema<RelationshipSummary>>;
export interface ListRelationshipsResponse {
    items?: RelationshipSummary[];
    nextToken?: string;
}
export declare const ListRelationshipsResponse: S.Schema<ListRelationshipsResponse>;
declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
    readonly message: S.String;
    readonly reason: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class AccessDeniedException extends AccessDeniedException_base {
}
declare const InternalServerException_base: S.Class<InternalServerException, S.TaggedStruct<"InternalServerException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class InternalServerException extends InternalServerException_base {
}
declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
    readonly message: S.String;
    readonly resourceId: S.optional<S.String>;
    readonly resourceType: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
}
declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
    readonly message: S.String;
    readonly serviceCode: S.optional<S.String>;
    readonly quotaCode: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class ThrottlingException extends ThrottlingException_base {
}
declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
    readonly message: S.String;
    readonly reason: S.String;
    readonly fieldList: S.optional<S.$Array<S.Schema<ValidationExceptionField>>>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ValidationException extends ValidationException_base {
}
declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
    readonly message: S.String;
    readonly resourceId: S.String;
    readonly resourceType: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class ConflictException extends ConflictException_base {
}
declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
    readonly message: S.String;
    readonly resourceId: S.String;
    readonly resourceType: S.String;
    readonly quotaCode: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        QuotaError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
}
export type ListTagsForResourceError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists tags associated with a specific resource.
 */
export declare const listTagsForResource: API.OperationMethod<ListTagsForResourceRequest, ListTagsForResourceResponse, ListTagsForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type TagResourceError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Adds or updates tags for a specified resource.
 */
export declare const tagResource: API.OperationMethod<TagResourceRequest, TagResourceResponse, TagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UntagResourceError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Removes tags from a specified resource.
 */
export declare const untagResource: API.OperationMethod<UntagResourceRequest, UntagResourceResponse, UntagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type CreateChannelHandshakeError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates a new channel handshake request to establish a partnership with another AWS account.
 */
export declare const createChannelHandshake: API.OperationMethod<CreateChannelHandshakeRequest, CreateChannelHandshakeResponse, CreateChannelHandshakeError, Credentials | Region | HttpClient.HttpClient>;
export type ListChannelHandshakesError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists channel handshakes based on specified criteria.
 */
export declare const listChannelHandshakes: API.OperationMethod<ListChannelHandshakesRequest, ListChannelHandshakesResponse, ListChannelHandshakesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListChannelHandshakesRequest) => stream.Stream<ListChannelHandshakesResponse, ListChannelHandshakesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListChannelHandshakesRequest) => stream.Stream<ChannelHandshakeSummary, ListChannelHandshakesError, Credentials | Region | HttpClient.HttpClient>;
};
export type AcceptChannelHandshakeError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Accepts a pending channel handshake request from another AWS account.
 */
export declare const acceptChannelHandshake: API.OperationMethod<AcceptChannelHandshakeRequest, AcceptChannelHandshakeResponse, AcceptChannelHandshakeError, Credentials | Region | HttpClient.HttpClient>;
export type CancelChannelHandshakeError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Cancels a pending channel handshake request.
 */
export declare const cancelChannelHandshake: API.OperationMethod<CancelChannelHandshakeRequest, CancelChannelHandshakeResponse, CancelChannelHandshakeError, Credentials | Region | HttpClient.HttpClient>;
export type RejectChannelHandshakeError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Rejects a pending channel handshake request.
 */
export declare const rejectChannelHandshake: API.OperationMethod<RejectChannelHandshakeRequest, RejectChannelHandshakeResponse, RejectChannelHandshakeError, Credentials | Region | HttpClient.HttpClient>;
export type CreateProgramManagementAccountError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates a new program management account for managing partner relationships.
 */
export declare const createProgramManagementAccount: API.OperationMethod<CreateProgramManagementAccountRequest, CreateProgramManagementAccountResponse, CreateProgramManagementAccountError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateProgramManagementAccountError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Updates the properties of a program management account.
 */
export declare const updateProgramManagementAccount: API.OperationMethod<UpdateProgramManagementAccountRequest, UpdateProgramManagementAccountResponse, UpdateProgramManagementAccountError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteProgramManagementAccountError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deletes a program management account.
 */
export declare const deleteProgramManagementAccount: API.OperationMethod<DeleteProgramManagementAccountRequest, DeleteProgramManagementAccountResponse, DeleteProgramManagementAccountError, Credentials | Region | HttpClient.HttpClient>;
export type ListProgramManagementAccountsError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists program management accounts based on specified criteria.
 */
export declare const listProgramManagementAccounts: API.OperationMethod<ListProgramManagementAccountsRequest, ListProgramManagementAccountsResponse, ListProgramManagementAccountsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListProgramManagementAccountsRequest) => stream.Stream<ListProgramManagementAccountsResponse, ListProgramManagementAccountsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListProgramManagementAccountsRequest) => stream.Stream<ProgramManagementAccountSummary, ListProgramManagementAccountsError, Credentials | Region | HttpClient.HttpClient>;
};
export type CreateRelationshipError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates a new partner relationship between accounts.
 */
export declare const createRelationship: API.OperationMethod<CreateRelationshipRequest, CreateRelationshipResponse, CreateRelationshipError, Credentials | Region | HttpClient.HttpClient>;
export type GetRelationshipError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Retrieves details of a specific partner relationship.
 */
export declare const getRelationship: API.OperationMethod<GetRelationshipRequest, GetRelationshipResponse, GetRelationshipError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateRelationshipError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Updates the properties of a partner relationship.
 */
export declare const updateRelationship: API.OperationMethod<UpdateRelationshipRequest, UpdateRelationshipResponse, UpdateRelationshipError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteRelationshipError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deletes a partner relationship.
 */
export declare const deleteRelationship: API.OperationMethod<DeleteRelationshipRequest, DeleteRelationshipResponse, DeleteRelationshipError, Credentials | Region | HttpClient.HttpClient>;
export type ListRelationshipsError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists partner relationships based on specified criteria.
 */
export declare const listRelationships: API.OperationMethod<ListRelationshipsRequest, ListRelationshipsResponse, ListRelationshipsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListRelationshipsRequest) => stream.Stream<ListRelationshipsResponse, ListRelationshipsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListRelationshipsRequest) => stream.Stream<RelationshipSummary, ListRelationshipsError, Credentials | Region | HttpClient.HttpClient>;
};
export {};
//# sourceMappingURL=partnercentral-channel.d.ts.map