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 * as T from "../traits.ts";
import type { Credentials } from "../credentials.ts";
import type { CommonErrors } from "../errors.ts";
import type { Region } from "../region.ts";
export type NsLcmOpOccId = string;
export type TagKey = string;
export type TagValue = string;
export type VnfPkgId = string;
export type VnfPkgArn = string;
export type NsdInfoId = string;
export type NsInstanceId = string;
export type NsInstanceArn = string;
export type NsdInfoArn = string;
export type VnfInstanceId = string;
export type VnfInstanceArn = string;
export type VnfdId = string;
export type NsdId = string;
export type NsLcmOpOccArn = string;
export type ErrorCause = string;
export type ErrorDetails = string;
export type PaginationToken = string;
export type TNBResourceArn = string;
export interface CancelSolNetworkOperationInput {
    nsLcmOpOccId: string;
}
export declare const CancelSolNetworkOperationInput: S.Schema<CancelSolNetworkOperationInput>;
export interface CancelSolNetworkOperationResponse {
}
export declare const CancelSolNetworkOperationResponse: S.Schema<CancelSolNetworkOperationResponse>;
export type TagMap = {
    [key: string]: string | undefined;
};
export declare const TagMap: S.$Record<S.String, S.optional<S.String>>;
export interface CreateSolFunctionPackageInput {
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateSolFunctionPackageInput: S.Schema<CreateSolFunctionPackageInput>;
export type OnboardingState = "CREATED" | "ONBOARDED" | "ERROR" | (string & {});
export declare const OnboardingState: S.String;
export type OperationalState = "ENABLED" | "DISABLED" | (string & {});
export declare const OperationalState: S.String;
export type UsageState = "IN_USE" | "NOT_IN_USE" | (string & {});
export declare const UsageState: S.String;
export interface CreateSolFunctionPackageOutput {
    id: string;
    arn: string;
    onboardingState: OnboardingState;
    operationalState: OperationalState;
    usageState: UsageState;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateSolFunctionPackageOutput: S.Schema<CreateSolFunctionPackageOutput>;
export interface CreateSolNetworkInstanceInput {
    nsdInfoId: string;
    nsName: string;
    nsDescription?: string;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateSolNetworkInstanceInput: S.Schema<CreateSolNetworkInstanceInput>;
export interface CreateSolNetworkInstanceOutput {
    id: string;
    arn: string;
    nsdInfoId: string;
    nsInstanceName: string;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateSolNetworkInstanceOutput: S.Schema<CreateSolNetworkInstanceOutput>;
export interface CreateSolNetworkPackageInput {
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateSolNetworkPackageInput: S.Schema<CreateSolNetworkPackageInput>;
export type NsdOnboardingState = "CREATED" | "ONBOARDED" | "ERROR" | (string & {});
export declare const NsdOnboardingState: S.String;
export type NsdOperationalState = "ENABLED" | "DISABLED" | (string & {});
export declare const NsdOperationalState: S.String;
export type NsdUsageState = "IN_USE" | "NOT_IN_USE" | (string & {});
export declare const NsdUsageState: S.String;
export interface CreateSolNetworkPackageOutput {
    id: string;
    arn: string;
    nsdOnboardingState: NsdOnboardingState;
    nsdOperationalState: NsdOperationalState;
    nsdUsageState: NsdUsageState;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateSolNetworkPackageOutput: S.Schema<CreateSolNetworkPackageOutput>;
export interface DeleteSolFunctionPackageInput {
    vnfPkgId: string;
}
export declare const DeleteSolFunctionPackageInput: S.Schema<DeleteSolFunctionPackageInput>;
export interface DeleteSolFunctionPackageResponse {
}
export declare const DeleteSolFunctionPackageResponse: S.Schema<DeleteSolFunctionPackageResponse>;
export interface DeleteSolNetworkInstanceInput {
    nsInstanceId: string;
}
export declare const DeleteSolNetworkInstanceInput: S.Schema<DeleteSolNetworkInstanceInput>;
export interface DeleteSolNetworkInstanceResponse {
}
export declare const DeleteSolNetworkInstanceResponse: S.Schema<DeleteSolNetworkInstanceResponse>;
export interface DeleteSolNetworkPackageInput {
    nsdInfoId: string;
}
export declare const DeleteSolNetworkPackageInput: S.Schema<DeleteSolNetworkPackageInput>;
export interface DeleteSolNetworkPackageResponse {
}
export declare const DeleteSolNetworkPackageResponse: S.Schema<DeleteSolNetworkPackageResponse>;
export interface GetSolFunctionInstanceInput {
    vnfInstanceId: string;
}
export declare const GetSolFunctionInstanceInput: S.Schema<GetSolFunctionInstanceInput>;
export type VnfInstantiationState = "INSTANTIATED" | "NOT_INSTANTIATED" | (string & {});
export declare const VnfInstantiationState: S.String;
export type VnfOperationalState = "STARTED" | "STOPPED" | (string & {});
export declare const VnfOperationalState: S.String;
export interface GetSolVnfcResourceInfoMetadata {
    nodeGroup?: string;
    cluster?: string;
    helmChart?: string;
}
export declare const GetSolVnfcResourceInfoMetadata: S.Schema<GetSolVnfcResourceInfoMetadata>;
export interface GetSolVnfcResourceInfo {
    metadata?: GetSolVnfcResourceInfoMetadata;
}
export declare const GetSolVnfcResourceInfo: S.Schema<GetSolVnfcResourceInfo>;
export type GetSolVnfcResourceInfoList = GetSolVnfcResourceInfo[];
export declare const GetSolVnfcResourceInfoList: S.$Array<S.Schema<GetSolVnfcResourceInfo>>;
export interface GetSolVnfInfo {
    vnfState?: VnfOperationalState;
    vnfcResourceInfo?: GetSolVnfcResourceInfo[];
}
export declare const GetSolVnfInfo: S.Schema<GetSolVnfInfo>;
export interface GetSolFunctionInstanceMetadata {
    createdAt: Date;
    lastModified: Date;
}
export declare const GetSolFunctionInstanceMetadata: S.Schema<GetSolFunctionInstanceMetadata>;
export interface GetSolFunctionInstanceOutput {
    id: string;
    arn: string;
    nsInstanceId: string;
    vnfPkgId: string;
    vnfdId: string;
    vnfProvider?: string;
    vnfProductName?: string;
    vnfdVersion?: string;
    instantiationState: VnfInstantiationState;
    instantiatedVnfInfo?: GetSolVnfInfo;
    metadata: GetSolFunctionInstanceMetadata;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const GetSolFunctionInstanceOutput: S.Schema<GetSolFunctionInstanceOutput>;
export interface GetSolFunctionPackageInput {
    vnfPkgId: string;
}
export declare const GetSolFunctionPackageInput: S.Schema<GetSolFunctionPackageInput>;
export interface ToscaOverride {
    name?: string;
    defaultValue?: string;
}
export declare const ToscaOverride: S.Schema<ToscaOverride>;
export type OverrideList = ToscaOverride[];
export declare const OverrideList: S.$Array<S.Schema<ToscaOverride>>;
export interface FunctionArtifactMeta {
    overrides?: ToscaOverride[];
}
export declare const FunctionArtifactMeta: S.Schema<FunctionArtifactMeta>;
export interface GetSolFunctionPackageMetadata {
    vnfd?: FunctionArtifactMeta;
    createdAt: Date;
    lastModified: Date;
}
export declare const GetSolFunctionPackageMetadata: S.Schema<GetSolFunctionPackageMetadata>;
export interface GetSolFunctionPackageOutput {
    id: string;
    arn: string;
    onboardingState: OnboardingState;
    operationalState: OperationalState;
    usageState: UsageState;
    vnfdId?: string;
    vnfProvider?: string;
    vnfProductName?: string;
    vnfdVersion?: string;
    metadata?: GetSolFunctionPackageMetadata;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const GetSolFunctionPackageOutput: S.Schema<GetSolFunctionPackageOutput>;
export type PackageContentType = "application/zip" | (string & {});
export declare const PackageContentType: S.String;
export interface GetSolFunctionPackageContentInput {
    vnfPkgId: string;
    accept: PackageContentType;
}
export declare const GetSolFunctionPackageContentInput: S.Schema<GetSolFunctionPackageContentInput>;
export interface GetSolFunctionPackageContentOutput {
    contentType?: PackageContentType;
    packageContent?: Uint8Array;
}
export declare const GetSolFunctionPackageContentOutput: S.Schema<GetSolFunctionPackageContentOutput>;
export type DescriptorContentType = "text/plain" | (string & {});
export declare const DescriptorContentType: S.String;
export interface GetSolFunctionPackageDescriptorInput {
    vnfPkgId: string;
    accept: DescriptorContentType;
}
export declare const GetSolFunctionPackageDescriptorInput: S.Schema<GetSolFunctionPackageDescriptorInput>;
export interface GetSolFunctionPackageDescriptorOutput {
    contentType?: DescriptorContentType;
    vnfd?: Uint8Array;
}
export declare const GetSolFunctionPackageDescriptorOutput: S.Schema<GetSolFunctionPackageDescriptorOutput>;
export interface GetSolNetworkInstanceInput {
    nsInstanceId: string;
}
export declare const GetSolNetworkInstanceInput: S.Schema<GetSolNetworkInstanceInput>;
export type NsState = "INSTANTIATED" | "NOT_INSTANTIATED" | "UPDATED" | "IMPAIRED" | "UPDATE_FAILED" | "STOPPED" | "DELETED" | "INSTANTIATE_IN_PROGRESS" | "INTENT_TO_UPDATE_IN_PROGRESS" | "UPDATE_IN_PROGRESS" | "TERMINATE_IN_PROGRESS" | (string & {});
export declare const NsState: S.String;
export interface LcmOperationInfo {
    nsLcmOpOccId: string;
}
export declare const LcmOperationInfo: S.Schema<LcmOperationInfo>;
export interface GetSolNetworkInstanceMetadata {
    createdAt: Date;
    lastModified: Date;
}
export declare const GetSolNetworkInstanceMetadata: S.Schema<GetSolNetworkInstanceMetadata>;
export interface GetSolNetworkInstanceOutput {
    id: string;
    arn: string;
    nsInstanceName: string;
    nsInstanceDescription: string;
    nsdId: string;
    nsdInfoId: string;
    nsState?: NsState;
    lcmOpInfo?: LcmOperationInfo;
    metadata: GetSolNetworkInstanceMetadata;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const GetSolNetworkInstanceOutput: S.Schema<GetSolNetworkInstanceOutput>;
export interface GetSolNetworkOperationInput {
    nsLcmOpOccId: string;
}
export declare const GetSolNetworkOperationInput: S.Schema<GetSolNetworkOperationInput>;
export type NsLcmOperationState = "PROCESSING" | "COMPLETED" | "FAILED" | "CANCELLING" | "CANCELLED" | (string & {});
export declare const NsLcmOperationState: S.String;
export type LcmOperationType = "INSTANTIATE" | "UPDATE" | "TERMINATE" | (string & {});
export declare const LcmOperationType: S.String;
export type UpdateSolNetworkType = "MODIFY_VNF_INFORMATION" | "UPDATE_NS" | (string & {});
export declare const UpdateSolNetworkType: S.String;
export interface ProblemDetails {
    detail: string;
    title?: string;
}
export declare const ProblemDetails: S.Schema<ProblemDetails>;
export interface UpdateNsMetadata {
    nsdInfoId: string;
    additionalParamsForNs?: any;
}
export declare const UpdateNsMetadata: S.Schema<UpdateNsMetadata>;
export interface ModifyVnfInfoMetadata {
    vnfInstanceId: string;
    vnfConfigurableProperties: any;
}
export declare const ModifyVnfInfoMetadata: S.Schema<ModifyVnfInfoMetadata>;
export interface InstantiateMetadata {
    nsdInfoId: string;
    additionalParamsForNs?: any;
}
export declare const InstantiateMetadata: S.Schema<InstantiateMetadata>;
export interface GetSolNetworkOperationMetadata {
    updateNsMetadata?: UpdateNsMetadata;
    modifyVnfInfoMetadata?: ModifyVnfInfoMetadata;
    instantiateMetadata?: InstantiateMetadata;
    createdAt: Date;
    lastModified: Date;
}
export declare const GetSolNetworkOperationMetadata: S.Schema<GetSolNetworkOperationMetadata>;
export type StringMap = {
    [key: string]: string | undefined;
};
export declare const StringMap: S.$Record<S.String, S.optional<S.String>>;
export interface ErrorInfo {
    cause?: string;
    details?: string;
}
export declare const ErrorInfo: S.Schema<ErrorInfo>;
export type TaskStatus = "SCHEDULED" | "STARTED" | "IN_PROGRESS" | "COMPLETED" | "ERROR" | "SKIPPED" | "CANCELLED" | (string & {});
export declare const TaskStatus: S.String;
export interface GetSolNetworkOperationTaskDetails {
    taskName?: string;
    taskContext?: {
        [key: string]: string | undefined;
    };
    taskErrorDetails?: ErrorInfo;
    taskStatus?: TaskStatus;
    taskStartTime?: Date;
    taskEndTime?: Date;
}
export declare const GetSolNetworkOperationTaskDetails: S.Schema<GetSolNetworkOperationTaskDetails>;
export type GetSolNetworkOperationTasksList = GetSolNetworkOperationTaskDetails[];
export declare const GetSolNetworkOperationTasksList: S.$Array<S.Schema<GetSolNetworkOperationTaskDetails>>;
export interface GetSolNetworkOperationOutput {
    id?: string;
    arn: string;
    operationState?: NsLcmOperationState;
    nsInstanceId?: string;
    lcmOperationType?: LcmOperationType;
    updateType?: UpdateSolNetworkType;
    error?: ProblemDetails;
    metadata?: GetSolNetworkOperationMetadata;
    tasks?: GetSolNetworkOperationTaskDetails[];
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const GetSolNetworkOperationOutput: S.Schema<GetSolNetworkOperationOutput>;
export interface GetSolNetworkPackageInput {
    nsdInfoId: string;
}
export declare const GetSolNetworkPackageInput: S.Schema<GetSolNetworkPackageInput>;
export type VnfPkgIdList = string[];
export declare const VnfPkgIdList: S.$Array<S.String>;
export interface NetworkArtifactMeta {
    overrides?: ToscaOverride[];
}
export declare const NetworkArtifactMeta: S.Schema<NetworkArtifactMeta>;
export interface GetSolNetworkPackageMetadata {
    nsd?: NetworkArtifactMeta;
    createdAt: Date;
    lastModified: Date;
}
export declare const GetSolNetworkPackageMetadata: S.Schema<GetSolNetworkPackageMetadata>;
export interface GetSolNetworkPackageOutput {
    id: string;
    arn: string;
    nsdOnboardingState: NsdOnboardingState;
    nsdOperationalState: NsdOperationalState;
    nsdUsageState: NsdUsageState;
    nsdId: string;
    nsdName: string;
    nsdVersion: string;
    vnfPkgIds: string[];
    metadata: GetSolNetworkPackageMetadata;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const GetSolNetworkPackageOutput: S.Schema<GetSolNetworkPackageOutput>;
export interface GetSolNetworkPackageContentInput {
    nsdInfoId: string;
    accept: PackageContentType;
}
export declare const GetSolNetworkPackageContentInput: S.Schema<GetSolNetworkPackageContentInput>;
export interface GetSolNetworkPackageContentOutput {
    contentType?: PackageContentType;
    nsdContent?: Uint8Array;
}
export declare const GetSolNetworkPackageContentOutput: S.Schema<GetSolNetworkPackageContentOutput>;
export interface GetSolNetworkPackageDescriptorInput {
    nsdInfoId: string;
}
export declare const GetSolNetworkPackageDescriptorInput: S.Schema<GetSolNetworkPackageDescriptorInput>;
export interface GetSolNetworkPackageDescriptorOutput {
    contentType?: DescriptorContentType;
    nsd?: Uint8Array;
}
export declare const GetSolNetworkPackageDescriptorOutput: S.Schema<GetSolNetworkPackageDescriptorOutput>;
export interface InstantiateSolNetworkInstanceInput {
    nsInstanceId: string;
    dryRun?: boolean;
    additionalParamsForNs?: any;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const InstantiateSolNetworkInstanceInput: S.Schema<InstantiateSolNetworkInstanceInput>;
export interface InstantiateSolNetworkInstanceOutput {
    nsLcmOpOccId: string;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const InstantiateSolNetworkInstanceOutput: S.Schema<InstantiateSolNetworkInstanceOutput>;
export interface ListSolFunctionInstancesInput {
    maxResults?: number;
    nextToken?: string;
}
export declare const ListSolFunctionInstancesInput: S.Schema<ListSolFunctionInstancesInput>;
export interface GetSolInstantiatedVnfInfo {
    vnfState?: VnfOperationalState;
}
export declare const GetSolInstantiatedVnfInfo: S.Schema<GetSolInstantiatedVnfInfo>;
export interface ListSolFunctionInstanceMetadata {
    createdAt: Date;
    lastModified: Date;
}
export declare const ListSolFunctionInstanceMetadata: S.Schema<ListSolFunctionInstanceMetadata>;
export interface ListSolFunctionInstanceInfo {
    id: string;
    arn: string;
    nsInstanceId: string;
    vnfPkgId: string;
    vnfPkgName?: string;
    instantiationState: VnfInstantiationState;
    instantiatedVnfInfo?: GetSolInstantiatedVnfInfo;
    metadata: ListSolFunctionInstanceMetadata;
}
export declare const ListSolFunctionInstanceInfo: S.Schema<ListSolFunctionInstanceInfo>;
export type ListSolFunctionInstanceResources = ListSolFunctionInstanceInfo[];
export declare const ListSolFunctionInstanceResources: S.$Array<S.Schema<ListSolFunctionInstanceInfo>>;
export interface ListSolFunctionInstancesOutput {
    nextToken?: string;
    functionInstances?: ListSolFunctionInstanceInfo[];
}
export declare const ListSolFunctionInstancesOutput: S.Schema<ListSolFunctionInstancesOutput>;
export interface ListSolFunctionPackagesInput {
    maxResults?: number;
    nextToken?: string;
}
export declare const ListSolFunctionPackagesInput: S.Schema<ListSolFunctionPackagesInput>;
export interface ListSolFunctionPackageMetadata {
    createdAt: Date;
    lastModified: Date;
}
export declare const ListSolFunctionPackageMetadata: S.Schema<ListSolFunctionPackageMetadata>;
export interface ListSolFunctionPackageInfo {
    id: string;
    arn: string;
    onboardingState: OnboardingState;
    operationalState: OperationalState;
    usageState: UsageState;
    vnfdId?: string;
    vnfProvider?: string;
    vnfProductName?: string;
    vnfdVersion?: string;
    metadata?: ListSolFunctionPackageMetadata;
}
export declare const ListSolFunctionPackageInfo: S.Schema<ListSolFunctionPackageInfo>;
export type ListSolFunctionPackageResources = ListSolFunctionPackageInfo[];
export declare const ListSolFunctionPackageResources: S.$Array<S.Schema<ListSolFunctionPackageInfo>>;
export interface ListSolFunctionPackagesOutput {
    nextToken?: string;
    functionPackages: ListSolFunctionPackageInfo[];
}
export declare const ListSolFunctionPackagesOutput: S.Schema<ListSolFunctionPackagesOutput>;
export interface ListSolNetworkInstancesInput {
    maxResults?: number;
    nextToken?: string;
}
export declare const ListSolNetworkInstancesInput: S.Schema<ListSolNetworkInstancesInput>;
export interface ListSolNetworkInstanceMetadata {
    createdAt: Date;
    lastModified: Date;
}
export declare const ListSolNetworkInstanceMetadata: S.Schema<ListSolNetworkInstanceMetadata>;
export interface ListSolNetworkInstanceInfo {
    id: string;
    arn: string;
    nsInstanceName: string;
    nsInstanceDescription: string;
    nsdId: string;
    nsdInfoId: string;
    nsState: NsState;
    metadata: ListSolNetworkInstanceMetadata;
}
export declare const ListSolNetworkInstanceInfo: S.Schema<ListSolNetworkInstanceInfo>;
export type ListSolNetworkInstanceResources = ListSolNetworkInstanceInfo[];
export declare const ListSolNetworkInstanceResources: S.$Array<S.Schema<ListSolNetworkInstanceInfo>>;
export interface ListSolNetworkInstancesOutput {
    nextToken?: string;
    networkInstances?: ListSolNetworkInstanceInfo[];
}
export declare const ListSolNetworkInstancesOutput: S.Schema<ListSolNetworkInstancesOutput>;
export interface ListSolNetworkOperationsInput {
    nsInstanceId?: string;
    maxResults?: number;
    nextToken?: string;
}
export declare const ListSolNetworkOperationsInput: S.Schema<ListSolNetworkOperationsInput>;
export interface ListSolNetworkOperationsMetadata {
    nsdInfoId?: string;
    vnfInstanceId?: string;
    createdAt: Date;
    lastModified: Date;
}
export declare const ListSolNetworkOperationsMetadata: S.Schema<ListSolNetworkOperationsMetadata>;
export interface ListSolNetworkOperationsInfo {
    id: string;
    arn: string;
    operationState: NsLcmOperationState;
    nsInstanceId: string;
    lcmOperationType: LcmOperationType;
    updateType?: UpdateSolNetworkType;
    error?: ProblemDetails;
    metadata?: ListSolNetworkOperationsMetadata;
}
export declare const ListSolNetworkOperationsInfo: S.Schema<ListSolNetworkOperationsInfo>;
export type ListSolNetworkOperationsResources = ListSolNetworkOperationsInfo[];
export declare const ListSolNetworkOperationsResources: S.$Array<S.Schema<ListSolNetworkOperationsInfo>>;
export interface ListSolNetworkOperationsOutput {
    nextToken?: string;
    networkOperations?: ListSolNetworkOperationsInfo[];
}
export declare const ListSolNetworkOperationsOutput: S.Schema<ListSolNetworkOperationsOutput>;
export interface ListSolNetworkPackagesInput {
    maxResults?: number;
    nextToken?: string;
}
export declare const ListSolNetworkPackagesInput: S.Schema<ListSolNetworkPackagesInput>;
export interface ListSolNetworkPackageMetadata {
    createdAt: Date;
    lastModified: Date;
}
export declare const ListSolNetworkPackageMetadata: S.Schema<ListSolNetworkPackageMetadata>;
export interface ListSolNetworkPackageInfo {
    id: string;
    arn: string;
    nsdOnboardingState: NsdOnboardingState;
    nsdOperationalState: NsdOperationalState;
    nsdUsageState: NsdUsageState;
    nsdId?: string;
    nsdName?: string;
    nsdVersion?: string;
    nsdDesigner?: string;
    nsdInvariantId?: string;
    vnfPkgIds?: string[];
    metadata: ListSolNetworkPackageMetadata;
}
export declare const ListSolNetworkPackageInfo: S.Schema<ListSolNetworkPackageInfo>;
export type ListSolNetworkPackageResources = ListSolNetworkPackageInfo[];
export declare const ListSolNetworkPackageResources: S.$Array<S.Schema<ListSolNetworkPackageInfo>>;
export interface ListSolNetworkPackagesOutput {
    nextToken?: string;
    networkPackages: ListSolNetworkPackageInfo[];
}
export declare const ListSolNetworkPackagesOutput: S.Schema<ListSolNetworkPackagesOutput>;
export interface ListTagsForResourceInput {
    resourceArn: string;
}
export declare const ListTagsForResourceInput: S.Schema<ListTagsForResourceInput>;
export interface ListTagsForResourceOutput {
    tags: {
        [key: string]: string | undefined;
    };
}
export declare const ListTagsForResourceOutput: S.Schema<ListTagsForResourceOutput>;
export interface PutSolFunctionPackageContentInput {
    vnfPkgId: string;
    contentType?: PackageContentType;
    file: T.StreamingInputBody;
}
export declare const PutSolFunctionPackageContentInput: S.Schema<PutSolFunctionPackageContentInput>;
export interface PutSolFunctionPackageContentMetadata {
    vnfd?: FunctionArtifactMeta;
}
export declare const PutSolFunctionPackageContentMetadata: S.Schema<PutSolFunctionPackageContentMetadata>;
export interface PutSolFunctionPackageContentOutput {
    id: string;
    vnfdId: string;
    vnfProductName: string;
    vnfProvider: string;
    vnfdVersion: string;
    metadata: PutSolFunctionPackageContentMetadata;
}
export declare const PutSolFunctionPackageContentOutput: S.Schema<PutSolFunctionPackageContentOutput>;
export interface PutSolNetworkPackageContentInput {
    nsdInfoId: string;
    contentType?: PackageContentType;
    file: T.StreamingInputBody;
}
export declare const PutSolNetworkPackageContentInput: S.Schema<PutSolNetworkPackageContentInput>;
export interface PutSolNetworkPackageContentMetadata {
    nsd?: NetworkArtifactMeta;
}
export declare const PutSolNetworkPackageContentMetadata: S.Schema<PutSolNetworkPackageContentMetadata>;
export interface PutSolNetworkPackageContentOutput {
    id: string;
    arn: string;
    nsdId: string;
    nsdName: string;
    nsdVersion: string;
    vnfPkgIds: string[];
    metadata: PutSolNetworkPackageContentMetadata;
}
export declare const PutSolNetworkPackageContentOutput: S.Schema<PutSolNetworkPackageContentOutput>;
export interface TagResourceInput {
    resourceArn: string;
    tags: {
        [key: string]: string | undefined;
    };
}
export declare const TagResourceInput: S.Schema<TagResourceInput>;
export interface TagResourceOutput {
}
export declare const TagResourceOutput: S.Schema<TagResourceOutput>;
export interface TerminateSolNetworkInstanceInput {
    nsInstanceId: string;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const TerminateSolNetworkInstanceInput: S.Schema<TerminateSolNetworkInstanceInput>;
export interface TerminateSolNetworkInstanceOutput {
    nsLcmOpOccId?: string;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const TerminateSolNetworkInstanceOutput: S.Schema<TerminateSolNetworkInstanceOutput>;
export type TagKeys = string[];
export declare const TagKeys: S.$Array<S.String>;
export interface UntagResourceInput {
    resourceArn: string;
    tagKeys: string[];
}
export declare const UntagResourceInput: S.Schema<UntagResourceInput>;
export interface UntagResourceOutput {
}
export declare const UntagResourceOutput: S.Schema<UntagResourceOutput>;
export interface UpdateSolFunctionPackageInput {
    vnfPkgId: string;
    operationalState: OperationalState;
}
export declare const UpdateSolFunctionPackageInput: S.Schema<UpdateSolFunctionPackageInput>;
export interface UpdateSolFunctionPackageOutput {
    operationalState: OperationalState;
}
export declare const UpdateSolFunctionPackageOutput: S.Schema<UpdateSolFunctionPackageOutput>;
export interface UpdateSolNetworkModify {
    vnfInstanceId: string;
    vnfConfigurableProperties: any;
}
export declare const UpdateSolNetworkModify: S.Schema<UpdateSolNetworkModify>;
export interface UpdateSolNetworkServiceData {
    nsdInfoId: string;
    additionalParamsForNs?: any;
}
export declare const UpdateSolNetworkServiceData: S.Schema<UpdateSolNetworkServiceData>;
export interface UpdateSolNetworkInstanceInput {
    nsInstanceId: string;
    updateType: UpdateSolNetworkType;
    modifyVnfInfoData?: UpdateSolNetworkModify;
    updateNs?: UpdateSolNetworkServiceData;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const UpdateSolNetworkInstanceInput: S.Schema<UpdateSolNetworkInstanceInput>;
export interface UpdateSolNetworkInstanceOutput {
    nsLcmOpOccId?: string;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const UpdateSolNetworkInstanceOutput: S.Schema<UpdateSolNetworkInstanceOutput>;
export interface UpdateSolNetworkPackageInput {
    nsdInfoId: string;
    nsdOperationalState: NsdOperationalState;
}
export declare const UpdateSolNetworkPackageInput: S.Schema<UpdateSolNetworkPackageInput>;
export interface UpdateSolNetworkPackageOutput {
    nsdOperationalState: NsdOperationalState;
}
export declare const UpdateSolNetworkPackageOutput: S.Schema<UpdateSolNetworkPackageOutput>;
export interface ValidateSolFunctionPackageContentInput {
    vnfPkgId: string;
    contentType?: PackageContentType;
    file: T.StreamingInputBody;
}
export declare const ValidateSolFunctionPackageContentInput: S.Schema<ValidateSolFunctionPackageContentInput>;
export interface ValidateSolFunctionPackageContentMetadata {
    vnfd?: FunctionArtifactMeta;
}
export declare const ValidateSolFunctionPackageContentMetadata: S.Schema<ValidateSolFunctionPackageContentMetadata>;
export interface ValidateSolFunctionPackageContentOutput {
    id: string;
    vnfdId: string;
    vnfProductName: string;
    vnfProvider: string;
    vnfdVersion: string;
    metadata: ValidateSolFunctionPackageContentMetadata;
}
export declare const ValidateSolFunctionPackageContentOutput: S.Schema<ValidateSolFunctionPackageContentOutput>;
export interface ValidateSolNetworkPackageContentInput {
    nsdInfoId: string;
    contentType?: PackageContentType;
    file: T.StreamingInputBody;
}
export declare const ValidateSolNetworkPackageContentInput: S.Schema<ValidateSolNetworkPackageContentInput>;
export interface ValidateSolNetworkPackageContentMetadata {
    nsd?: NetworkArtifactMeta;
}
export declare const ValidateSolNetworkPackageContentMetadata: S.Schema<ValidateSolNetworkPackageContentMetadata>;
export interface ValidateSolNetworkPackageContentOutput {
    id: string;
    arn: string;
    nsdId: string;
    nsdName: string;
    nsdVersion: string;
    vnfPkgIds: string[];
    metadata: ValidateSolNetworkPackageContentMetadata;
}
export declare const ValidateSolNetworkPackageContentOutput: S.Schema<ValidateSolNetworkPackageContentOutput>;
declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
    readonly message: 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;
    };
});
export declare class InternalServerException extends InternalServerException_base {
}
declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
    readonly message: 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;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
});
export declare class ThrottlingException extends ThrottlingException_base {
}
declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ValidationException extends ValidationException_base {
}
declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        QuotaError: true;
    };
});
export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
}
export type CancelSolNetworkOperationError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Cancels a network operation.
 *
 * A network operation is any operation that is done to your network, such as network instance instantiation or termination.
 */
export declare const cancelSolNetworkOperation: API.OperationMethod<CancelSolNetworkOperationInput, CancelSolNetworkOperationResponse, CancelSolNetworkOperationError, Credentials | Region | HttpClient.HttpClient>;
export type CreateSolFunctionPackageError = AccessDeniedException | InternalServerException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates a function package.
 *
 * A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network. For more information, see Function packages in the
 * *Amazon Web Services Telco Network Builder User Guide*.
 *
 * Creating a function package is the first step for creating a network in AWS TNB. This
 * request creates an empty container with an ID. The next step is to upload the actual CSAR
 * zip file into that empty container. To upload function package content, see PutSolFunctionPackageContent.
 */
export declare const createSolFunctionPackage: API.OperationMethod<CreateSolFunctionPackageInput, CreateSolFunctionPackageOutput, CreateSolFunctionPackageError, Credentials | Region | HttpClient.HttpClient>;
export type CreateSolNetworkInstanceError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates a network instance.
 *
 * A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which life-cycle operations (like terminate, update, and delete) can be performed. Creating a network instance is the third step after creating a network
 * package. For more information about network instances, Network instances in the
 * *Amazon Web Services Telco Network Builder User Guide*.
 *
 * Once you create a network instance, you can instantiate it. To instantiate a network,
 * see InstantiateSolNetworkInstance.
 */
export declare const createSolNetworkInstance: API.OperationMethod<CreateSolNetworkInstanceInput, CreateSolNetworkInstanceOutput, CreateSolNetworkInstanceError, Credentials | Region | HttpClient.HttpClient>;
export type CreateSolNetworkPackageError = AccessDeniedException | InternalServerException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates a network package.
 *
 * A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on. For more information, see Network instances in the
 * *Amazon Web Services Telco Network Builder User Guide*.
 *
 * A network package consists of a network service descriptor (NSD) file (required) and any
 * additional files (optional), such as scripts specific to your needs. For example, if you
 * have multiple function packages in your network package, you can use the NSD to define
 * which network functions should run in certain VPCs, subnets, or EKS clusters.
 *
 * This request creates an empty network package container with an ID. Once you create a
 * network package, you can upload the network package content using PutSolNetworkPackageContent.
 */
export declare const createSolNetworkPackage: API.OperationMethod<CreateSolNetworkPackageInput, CreateSolNetworkPackageOutput, CreateSolNetworkPackageError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteSolFunctionPackageError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deletes a function package.
 *
 * A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network.
 *
 * To delete a function package, the package must be in a disabled state. To disable a
 * function package, see UpdateSolFunctionPackage.
 */
export declare const deleteSolFunctionPackage: API.OperationMethod<DeleteSolFunctionPackageInput, DeleteSolFunctionPackageResponse, DeleteSolFunctionPackageError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteSolNetworkInstanceError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deletes a network instance.
 *
 * A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which life-cycle operations (like terminate, update, and delete) can be performed.
 *
 * To delete a network instance, the instance must be in a stopped or terminated state. To
 * terminate a network instance, see TerminateSolNetworkInstance.
 */
export declare const deleteSolNetworkInstance: API.OperationMethod<DeleteSolNetworkInstanceInput, DeleteSolNetworkInstanceResponse, DeleteSolNetworkInstanceError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteSolNetworkPackageError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deletes network package.
 *
 * A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on.
 *
 * To delete a network package, the package must be in a disable state. To disable a
 * network package, see UpdateSolNetworkPackage.
 */
export declare const deleteSolNetworkPackage: API.OperationMethod<DeleteSolNetworkPackageInput, DeleteSolNetworkPackageResponse, DeleteSolNetworkPackageError, Credentials | Region | HttpClient.HttpClient>;
export type GetSolFunctionInstanceError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Gets the details of a network function instance, including the instantiation state and
 * metadata from the function package descriptor in the network function package.
 *
 * A network function instance is a function in a function package .
 */
export declare const getSolFunctionInstance: API.OperationMethod<GetSolFunctionInstanceInput, GetSolFunctionInstanceOutput, GetSolFunctionInstanceError, Credentials | Region | HttpClient.HttpClient>;
export type GetSolFunctionPackageError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Gets the details of an individual function package, such as the operational state and
 * whether the package is in use.
 *
 * A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network..
 */
export declare const getSolFunctionPackage: API.OperationMethod<GetSolFunctionPackageInput, GetSolFunctionPackageOutput, GetSolFunctionPackageError, Credentials | Region | HttpClient.HttpClient>;
export type GetSolFunctionPackageContentError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Gets the contents of a function package.
 *
 * A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network.
 */
export declare const getSolFunctionPackageContent: API.OperationMethod<GetSolFunctionPackageContentInput, GetSolFunctionPackageContentOutput, GetSolFunctionPackageContentError, Credentials | Region | HttpClient.HttpClient>;
export type GetSolFunctionPackageDescriptorError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Gets a function package descriptor in a function package.
 *
 * A function package descriptor is a .yaml file in a function package that uses the TOSCA standard to describe how the network function in the function package should run on your network.
 *
 * A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network.
 */
export declare const getSolFunctionPackageDescriptor: API.OperationMethod<GetSolFunctionPackageDescriptorInput, GetSolFunctionPackageDescriptorOutput, GetSolFunctionPackageDescriptorError, Credentials | Region | HttpClient.HttpClient>;
export type GetSolNetworkInstanceError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Gets the details of the network instance.
 *
 * A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which life-cycle operations (like terminate, update, and delete) can be performed.
 */
export declare const getSolNetworkInstance: API.OperationMethod<GetSolNetworkInstanceInput, GetSolNetworkInstanceOutput, GetSolNetworkInstanceError, Credentials | Region | HttpClient.HttpClient>;
export type GetSolNetworkOperationError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Gets the details of a network operation, including the tasks involved in the network
 * operation and the status of the tasks.
 *
 * A network operation is any operation that is done to your network, such as network instance instantiation or termination.
 */
export declare const getSolNetworkOperation: API.OperationMethod<GetSolNetworkOperationInput, GetSolNetworkOperationOutput, GetSolNetworkOperationError, Credentials | Region | HttpClient.HttpClient>;
export type GetSolNetworkPackageError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Gets the details of a network package.
 *
 * A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on.
 */
export declare const getSolNetworkPackage: API.OperationMethod<GetSolNetworkPackageInput, GetSolNetworkPackageOutput, GetSolNetworkPackageError, Credentials | Region | HttpClient.HttpClient>;
export type GetSolNetworkPackageContentError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Gets the contents of a network package.
 *
 * A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on.
 */
export declare const getSolNetworkPackageContent: API.OperationMethod<GetSolNetworkPackageContentInput, GetSolNetworkPackageContentOutput, GetSolNetworkPackageContentError, Credentials | Region | HttpClient.HttpClient>;
export type GetSolNetworkPackageDescriptorError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Gets the content of the network service descriptor.
 *
 * A network service descriptor is a .yaml file in a network package that uses the TOSCA standard to describe the network functions you want to deploy and the Amazon Web Services infrastructure you want to deploy the network functions on.
 */
export declare const getSolNetworkPackageDescriptor: API.OperationMethod<GetSolNetworkPackageDescriptorInput, GetSolNetworkPackageDescriptorOutput, GetSolNetworkPackageDescriptorError, Credentials | Region | HttpClient.HttpClient>;
export type InstantiateSolNetworkInstanceError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Instantiates a network instance.
 *
 * A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which life-cycle operations (like terminate, update, and delete) can be performed.
 *
 * Before you can instantiate a network instance, you have to create a network instance.
 * For more information, see CreateSolNetworkInstance.
 */
export declare const instantiateSolNetworkInstance: API.OperationMethod<InstantiateSolNetworkInstanceInput, InstantiateSolNetworkInstanceOutput, InstantiateSolNetworkInstanceError, Credentials | Region | HttpClient.HttpClient>;
export type ListSolFunctionInstancesError = AccessDeniedException | InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists network function instances.
 *
 * A network function instance is a function in a function package .
 */
export declare const listSolFunctionInstances: API.OperationMethod<ListSolFunctionInstancesInput, ListSolFunctionInstancesOutput, ListSolFunctionInstancesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListSolFunctionInstancesInput) => stream.Stream<ListSolFunctionInstancesOutput, ListSolFunctionInstancesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListSolFunctionInstancesInput) => stream.Stream<ListSolFunctionInstanceInfo, ListSolFunctionInstancesError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListSolFunctionPackagesError = AccessDeniedException | InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists information about function packages.
 *
 * A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network.
 */
export declare const listSolFunctionPackages: API.OperationMethod<ListSolFunctionPackagesInput, ListSolFunctionPackagesOutput, ListSolFunctionPackagesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListSolFunctionPackagesInput) => stream.Stream<ListSolFunctionPackagesOutput, ListSolFunctionPackagesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListSolFunctionPackagesInput) => stream.Stream<ListSolFunctionPackageInfo, ListSolFunctionPackagesError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListSolNetworkInstancesError = AccessDeniedException | InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists your network instances.
 *
 * A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which life-cycle operations (like terminate, update, and delete) can be performed.
 */
export declare const listSolNetworkInstances: API.OperationMethod<ListSolNetworkInstancesInput, ListSolNetworkInstancesOutput, ListSolNetworkInstancesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListSolNetworkInstancesInput) => stream.Stream<ListSolNetworkInstancesOutput, ListSolNetworkInstancesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListSolNetworkInstancesInput) => stream.Stream<ListSolNetworkInstanceInfo, ListSolNetworkInstancesError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListSolNetworkOperationsError = AccessDeniedException | InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists details for a network operation, including when the operation started and the
 * status of the operation.
 *
 * A network operation is any operation that is done to your network, such as network instance instantiation or termination.
 */
export declare const listSolNetworkOperations: API.OperationMethod<ListSolNetworkOperationsInput, ListSolNetworkOperationsOutput, ListSolNetworkOperationsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListSolNetworkOperationsInput) => stream.Stream<ListSolNetworkOperationsOutput, ListSolNetworkOperationsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListSolNetworkOperationsInput) => stream.Stream<ListSolNetworkOperationsInfo, ListSolNetworkOperationsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListSolNetworkPackagesError = AccessDeniedException | InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists network packages.
 *
 * A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on.
 */
export declare const listSolNetworkPackages: API.OperationMethod<ListSolNetworkPackagesInput, ListSolNetworkPackagesOutput, ListSolNetworkPackagesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListSolNetworkPackagesInput) => stream.Stream<ListSolNetworkPackagesOutput, ListSolNetworkPackagesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListSolNetworkPackagesInput) => stream.Stream<ListSolNetworkPackageInfo, ListSolNetworkPackagesError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListTagsForResourceError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists tags for AWS TNB resources.
 */
export declare const listTagsForResource: API.OperationMethod<ListTagsForResourceInput, ListTagsForResourceOutput, ListTagsForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type PutSolFunctionPackageContentError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Uploads the contents of a function package.
 *
 * A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network.
 */
export declare const putSolFunctionPackageContent: API.OperationMethod<PutSolFunctionPackageContentInput, PutSolFunctionPackageContentOutput, PutSolFunctionPackageContentError, Credentials | Region | HttpClient.HttpClient>;
export type PutSolNetworkPackageContentError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Uploads the contents of a network package.
 *
 * A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on.
 */
export declare const putSolNetworkPackageContent: API.OperationMethod<PutSolNetworkPackageContentInput, PutSolNetworkPackageContentOutput, PutSolNetworkPackageContentError, Credentials | Region | HttpClient.HttpClient>;
export type TagResourceError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Tags an AWS TNB resource.
 *
 * A tag is a label that you assign to an Amazon Web Services resource. Each tag consists of a key and an optional value. You can use tags to search and filter your resources or track your Amazon Web Services costs.
 */
export declare const tagResource: API.OperationMethod<TagResourceInput, TagResourceOutput, TagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type TerminateSolNetworkInstanceError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Terminates a network instance.
 *
 * A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which life-cycle operations (like terminate, update, and delete) can be performed.
 *
 * You must terminate a network instance before you can delete it.
 */
export declare const terminateSolNetworkInstance: API.OperationMethod<TerminateSolNetworkInstanceInput, TerminateSolNetworkInstanceOutput, TerminateSolNetworkInstanceError, Credentials | Region | HttpClient.HttpClient>;
export type UntagResourceError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Untags an AWS TNB resource.
 *
 * A tag is a label that you assign to an Amazon Web Services resource. Each tag consists of a key and an optional value. You can use tags to search and filter your resources or track your Amazon Web Services costs.
 */
export declare const untagResource: API.OperationMethod<UntagResourceInput, UntagResourceOutput, UntagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateSolFunctionPackageError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Updates the operational state of function package.
 *
 * A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network.
 */
export declare const updateSolFunctionPackage: API.OperationMethod<UpdateSolFunctionPackageInput, UpdateSolFunctionPackageOutput, UpdateSolFunctionPackageError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateSolNetworkInstanceError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Update a network instance.
 *
 * A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which life-cycle operations (like terminate, update, and delete) can be performed.
 *
 * Choose the *updateType* parameter to target the necessary update of the network instance.
 */
export declare const updateSolNetworkInstance: API.OperationMethod<UpdateSolNetworkInstanceInput, UpdateSolNetworkInstanceOutput, UpdateSolNetworkInstanceError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateSolNetworkPackageError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Updates the operational state of a network package.
 *
 * A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on.
 *
 * A network service descriptor is a .yaml file in a network package that uses the TOSCA standard to describe the network functions you want to deploy and the Amazon Web Services infrastructure you want to deploy the network functions on.
 */
export declare const updateSolNetworkPackage: API.OperationMethod<UpdateSolNetworkPackageInput, UpdateSolNetworkPackageOutput, UpdateSolNetworkPackageError, Credentials | Region | HttpClient.HttpClient>;
export type ValidateSolFunctionPackageContentError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Validates function package content. This can be used as a dry run before uploading
 * function package content with PutSolFunctionPackageContent.
 *
 * A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network.
 */
export declare const validateSolFunctionPackageContent: API.OperationMethod<ValidateSolFunctionPackageContentInput, ValidateSolFunctionPackageContentOutput, ValidateSolFunctionPackageContentError, Credentials | Region | HttpClient.HttpClient>;
export type ValidateSolNetworkPackageContentError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Validates network package content. This can be used as a dry run before uploading
 * network package content with PutSolNetworkPackageContent.
 *
 * A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on.
 */
export declare const validateSolNetworkPackageContent: API.OperationMethod<ValidateSolNetworkPackageContentInput, ValidateSolNetworkPackageContentOutput, ValidateSolNetworkPackageContentError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=tnb.d.ts.map