@aws-sdk/client-iot-wireless 3.50.0 → 3.51.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,2709 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+
+export interface SessionKeysAbpV1_0_x {
+    
+    NwkSKey?: string;
+    
+    AppSKey?: string;
+}
+export declare namespace SessionKeysAbpV1_0_x {
+    
+    const filterSensitiveLog: (obj: SessionKeysAbpV1_0_x) => any;
+}
+
+export interface AbpV1_0_x {
+    
+    DevAddr?: string;
+    
+    SessionKeys?: SessionKeysAbpV1_0_x;
+}
+export declare namespace AbpV1_0_x {
+    
+    const filterSensitiveLog: (obj: AbpV1_0_x) => any;
+}
+
+export interface SessionKeysAbpV1_1 {
+    
+    FNwkSIntKey?: string;
+    
+    SNwkSIntKey?: string;
+    
+    NwkSEncKey?: string;
+    
+    AppSKey?: string;
+}
+export declare namespace SessionKeysAbpV1_1 {
+    
+    const filterSensitiveLog: (obj: SessionKeysAbpV1_1) => any;
+}
+
+export interface AbpV1_1 {
+    
+    DevAddr?: string;
+    
+    SessionKeys?: SessionKeysAbpV1_1;
+}
+export declare namespace AbpV1_1 {
+    
+    const filterSensitiveLog: (obj: AbpV1_1) => any;
+}
+
+export interface AccessDeniedException extends __SmithyException, $MetadataBearer {
+    name: "AccessDeniedException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface SidewalkAccountInfo {
+    
+    AmazonId?: string;
+    
+    AppServerPrivateKey?: string;
+}
+export declare namespace SidewalkAccountInfo {
+    
+    const filterSensitiveLog: (obj: SidewalkAccountInfo) => any;
+}
+
+export interface Tag {
+    
+    Key: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export interface AssociateAwsAccountWithPartnerAccountRequest {
+    
+    Sidewalk: SidewalkAccountInfo | undefined;
+    
+    ClientRequestToken?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace AssociateAwsAccountWithPartnerAccountRequest {
+    
+    const filterSensitiveLog: (obj: AssociateAwsAccountWithPartnerAccountRequest) => any;
+}
+export interface AssociateAwsAccountWithPartnerAccountResponse {
+    
+    Sidewalk?: SidewalkAccountInfo;
+    
+    Arn?: string;
+}
+export declare namespace AssociateAwsAccountWithPartnerAccountResponse {
+    
+    const filterSensitiveLog: (obj: AssociateAwsAccountWithPartnerAccountResponse) => any;
+}
+
+export interface ConflictException extends __SmithyException, $MetadataBearer {
+    name: "ConflictException";
+    $fault: "client";
+    Message?: string;
+    
+    ResourceId?: string;
+    
+    ResourceType?: string;
+}
+
+export interface InternalServerException extends __SmithyException, $MetadataBearer {
+    name: "InternalServerException";
+    $fault: "server";
+    Message?: string;
+}
+
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    Message?: string;
+    
+    ResourceId?: string;
+    
+    ResourceType?: string;
+}
+
+export interface ThrottlingException extends __SmithyException, $MetadataBearer {
+    name: "ThrottlingException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface ValidationException extends __SmithyException, $MetadataBearer {
+    name: "ValidationException";
+    $fault: "client";
+    Message?: string;
+}
+export interface AssociateMulticastGroupWithFuotaTaskRequest {
+    
+    Id: string | undefined;
+    
+    MulticastGroupId: string | undefined;
+}
+export declare namespace AssociateMulticastGroupWithFuotaTaskRequest {
+    
+    const filterSensitiveLog: (obj: AssociateMulticastGroupWithFuotaTaskRequest) => any;
+}
+export interface AssociateMulticastGroupWithFuotaTaskResponse {
+}
+export declare namespace AssociateMulticastGroupWithFuotaTaskResponse {
+    
+    const filterSensitiveLog: (obj: AssociateMulticastGroupWithFuotaTaskResponse) => any;
+}
+export interface AssociateWirelessDeviceWithFuotaTaskRequest {
+    
+    Id: string | undefined;
+    
+    WirelessDeviceId: string | undefined;
+}
+export declare namespace AssociateWirelessDeviceWithFuotaTaskRequest {
+    
+    const filterSensitiveLog: (obj: AssociateWirelessDeviceWithFuotaTaskRequest) => any;
+}
+export interface AssociateWirelessDeviceWithFuotaTaskResponse {
+}
+export declare namespace AssociateWirelessDeviceWithFuotaTaskResponse {
+    
+    const filterSensitiveLog: (obj: AssociateWirelessDeviceWithFuotaTaskResponse) => any;
+}
+export interface AssociateWirelessDeviceWithMulticastGroupRequest {
+    
+    Id: string | undefined;
+    
+    WirelessDeviceId: string | undefined;
+}
+export declare namespace AssociateWirelessDeviceWithMulticastGroupRequest {
+    
+    const filterSensitiveLog: (obj: AssociateWirelessDeviceWithMulticastGroupRequest) => any;
+}
+export interface AssociateWirelessDeviceWithMulticastGroupResponse {
+}
+export declare namespace AssociateWirelessDeviceWithMulticastGroupResponse {
+    
+    const filterSensitiveLog: (obj: AssociateWirelessDeviceWithMulticastGroupResponse) => any;
+}
+export interface AssociateWirelessDeviceWithThingRequest {
+    
+    Id: string | undefined;
+    
+    ThingArn: string | undefined;
+}
+export declare namespace AssociateWirelessDeviceWithThingRequest {
+    
+    const filterSensitiveLog: (obj: AssociateWirelessDeviceWithThingRequest) => any;
+}
+export interface AssociateWirelessDeviceWithThingResponse {
+}
+export declare namespace AssociateWirelessDeviceWithThingResponse {
+    
+    const filterSensitiveLog: (obj: AssociateWirelessDeviceWithThingResponse) => any;
+}
+export interface AssociateWirelessGatewayWithCertificateRequest {
+    
+    Id: string | undefined;
+    
+    IotCertificateId: string | undefined;
+}
+export declare namespace AssociateWirelessGatewayWithCertificateRequest {
+    
+    const filterSensitiveLog: (obj: AssociateWirelessGatewayWithCertificateRequest) => any;
+}
+export interface AssociateWirelessGatewayWithCertificateResponse {
+    
+    IotCertificateId?: string;
+}
+export declare namespace AssociateWirelessGatewayWithCertificateResponse {
+    
+    const filterSensitiveLog: (obj: AssociateWirelessGatewayWithCertificateResponse) => any;
+}
+export interface AssociateWirelessGatewayWithThingRequest {
+    
+    Id: string | undefined;
+    
+    ThingArn: string | undefined;
+}
+export declare namespace AssociateWirelessGatewayWithThingRequest {
+    
+    const filterSensitiveLog: (obj: AssociateWirelessGatewayWithThingRequest) => any;
+}
+export interface AssociateWirelessGatewayWithThingResponse {
+}
+export declare namespace AssociateWirelessGatewayWithThingResponse {
+    
+    const filterSensitiveLog: (obj: AssociateWirelessGatewayWithThingResponse) => any;
+}
+export declare enum BatteryLevel {
+    CRITICAL = "critical",
+    LOW = "low",
+    NORMAL = "normal"
+}
+export interface CancelMulticastGroupSessionRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace CancelMulticastGroupSessionRequest {
+    
+    const filterSensitiveLog: (obj: CancelMulticastGroupSessionRequest) => any;
+}
+export interface CancelMulticastGroupSessionResponse {
+}
+export declare namespace CancelMulticastGroupSessionResponse {
+    
+    const filterSensitiveLog: (obj: CancelMulticastGroupSessionResponse) => any;
+}
+export declare enum SigningAlg {
+    Ed25519 = "Ed25519",
+    P256r1 = "P256r1"
+}
+
+export interface CertificateList {
+    
+    SigningAlg: SigningAlg | string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace CertificateList {
+    
+    const filterSensitiveLog: (obj: CertificateList) => any;
+}
+export declare enum ConnectionStatus {
+    CONNECTED = "Connected",
+    DISCONNECTED = "Disconnected"
+}
+export declare enum ExpressionType {
+    MqttTopic = "MqttTopic",
+    RuleName = "RuleName"
+}
+export interface CreateDestinationRequest {
+    
+    Name: string | undefined;
+    
+    ExpressionType: ExpressionType | string | undefined;
+    
+    Expression: string | undefined;
+    
+    Description?: string;
+    
+    RoleArn: string | undefined;
+    
+    Tags?: Tag[];
+    
+    ClientRequestToken?: string;
+}
+export declare namespace CreateDestinationRequest {
+    
+    const filterSensitiveLog: (obj: CreateDestinationRequest) => any;
+}
+export interface CreateDestinationResponse {
+    
+    Arn?: string;
+    
+    Name?: string;
+}
+export declare namespace CreateDestinationResponse {
+    
+    const filterSensitiveLog: (obj: CreateDestinationResponse) => any;
+}
+
+export interface LoRaWANDeviceProfile {
+    
+    SupportsClassB?: boolean;
+    
+    ClassBTimeout?: number;
+    
+    PingSlotPeriod?: number;
+    
+    PingSlotDr?: number;
+    
+    PingSlotFreq?: number;
+    
+    SupportsClassC?: boolean;
+    
+    ClassCTimeout?: number;
+    
+    MacVersion?: string;
+    
+    RegParamsRevision?: string;
+    
+    RxDelay1?: number;
+    
+    RxDrOffset1?: number;
+    
+    RxDataRate2?: number;
+    
+    RxFreq2?: number;
+    
+    FactoryPresetFreqsList?: number[];
+    
+    MaxEirp?: number;
+    
+    MaxDutyCycle?: number;
+    
+    RfRegion?: string;
+    
+    SupportsJoin?: boolean;
+    
+    Supports32BitFCnt?: boolean;
+}
+export declare namespace LoRaWANDeviceProfile {
+    
+    const filterSensitiveLog: (obj: LoRaWANDeviceProfile) => any;
+}
+export interface CreateDeviceProfileRequest {
+    
+    Name?: string;
+    
+    LoRaWAN?: LoRaWANDeviceProfile;
+    
+    Tags?: Tag[];
+    
+    ClientRequestToken?: string;
+}
+export declare namespace CreateDeviceProfileRequest {
+    
+    const filterSensitiveLog: (obj: CreateDeviceProfileRequest) => any;
+}
+export interface CreateDeviceProfileResponse {
+    
+    Arn?: string;
+    
+    Id?: string;
+}
+export declare namespace CreateDeviceProfileResponse {
+    
+    const filterSensitiveLog: (obj: CreateDeviceProfileResponse) => any;
+}
+export declare enum SupportedRfRegion {
+    AS923_1 = "AS923-1",
+    AU915 = "AU915",
+    EU868 = "EU868",
+    US915 = "US915"
+}
+
+export interface LoRaWANFuotaTask {
+    
+    RfRegion?: SupportedRfRegion | string;
+}
+export declare namespace LoRaWANFuotaTask {
+    
+    const filterSensitiveLog: (obj: LoRaWANFuotaTask) => any;
+}
+export interface CreateFuotaTaskRequest {
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    ClientRequestToken?: string;
+    
+    LoRaWAN?: LoRaWANFuotaTask;
+    
+    FirmwareUpdateImage: string | undefined;
+    
+    FirmwareUpdateRole: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateFuotaTaskRequest {
+    
+    const filterSensitiveLog: (obj: CreateFuotaTaskRequest) => any;
+}
+export interface CreateFuotaTaskResponse {
+    
+    Arn?: string;
+    
+    Id?: string;
+}
+export declare namespace CreateFuotaTaskResponse {
+    
+    const filterSensitiveLog: (obj: CreateFuotaTaskResponse) => any;
+}
+export declare enum DlClass {
+    ClassB = "ClassB",
+    ClassC = "ClassC"
+}
+
+export interface LoRaWANMulticast {
+    
+    RfRegion?: SupportedRfRegion | string;
+    
+    DlClass?: DlClass | string;
+}
+export declare namespace LoRaWANMulticast {
+    
+    const filterSensitiveLog: (obj: LoRaWANMulticast) => any;
+}
+export interface CreateMulticastGroupRequest {
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    ClientRequestToken?: string;
+    
+    LoRaWAN: LoRaWANMulticast | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateMulticastGroupRequest {
+    
+    const filterSensitiveLog: (obj: CreateMulticastGroupRequest) => any;
+}
+export interface CreateMulticastGroupResponse {
+    
+    Arn?: string;
+    
+    Id?: string;
+}
+export declare namespace CreateMulticastGroupResponse {
+    
+    const filterSensitiveLog: (obj: CreateMulticastGroupResponse) => any;
+}
+
+export interface LoRaWANServiceProfile {
+    
+    AddGwMetadata?: boolean;
+}
+export declare namespace LoRaWANServiceProfile {
+    
+    const filterSensitiveLog: (obj: LoRaWANServiceProfile) => any;
+}
+export interface CreateServiceProfileRequest {
+    
+    Name?: string;
+    
+    LoRaWAN?: LoRaWANServiceProfile;
+    
+    Tags?: Tag[];
+    
+    ClientRequestToken?: string;
+}
+export declare namespace CreateServiceProfileRequest {
+    
+    const filterSensitiveLog: (obj: CreateServiceProfileRequest) => any;
+}
+export interface CreateServiceProfileResponse {
+    
+    Arn?: string;
+    
+    Id?: string;
+}
+export declare namespace CreateServiceProfileResponse {
+    
+    const filterSensitiveLog: (obj: CreateServiceProfileResponse) => any;
+}
+
+export interface FPorts {
+    
+    Fuota?: number;
+    
+    Multicast?: number;
+    
+    ClockSync?: number;
+}
+export declare namespace FPorts {
+    
+    const filterSensitiveLog: (obj: FPorts) => any;
+}
+
+export interface OtaaV1_0_x {
+    
+    AppKey?: string;
+    
+    AppEui?: string;
+    
+    GenAppKey?: string;
+}
+export declare namespace OtaaV1_0_x {
+    
+    const filterSensitiveLog: (obj: OtaaV1_0_x) => any;
+}
+
+export interface OtaaV1_1 {
+    
+    AppKey?: string;
+    
+    NwkKey?: string;
+    
+    JoinEui?: string;
+}
+export declare namespace OtaaV1_1 {
+    
+    const filterSensitiveLog: (obj: OtaaV1_1) => any;
+}
+
+export interface LoRaWANDevice {
+    
+    DevEui?: string;
+    
+    DeviceProfileId?: string;
+    
+    ServiceProfileId?: string;
+    
+    OtaaV1_1?: OtaaV1_1;
+    
+    OtaaV1_0_x?: OtaaV1_0_x;
+    
+    AbpV1_1?: AbpV1_1;
+    
+    AbpV1_0_x?: AbpV1_0_x;
+    
+    FPorts?: FPorts;
+}
+export declare namespace LoRaWANDevice {
+    
+    const filterSensitiveLog: (obj: LoRaWANDevice) => any;
+}
+export declare enum WirelessDeviceType {
+    LoRaWAN = "LoRaWAN",
+    Sidewalk = "Sidewalk"
+}
+export interface CreateWirelessDeviceRequest {
+    
+    Type: WirelessDeviceType | string | undefined;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    DestinationName: string | undefined;
+    
+    ClientRequestToken?: string;
+    
+    LoRaWAN?: LoRaWANDevice;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateWirelessDeviceRequest {
+    
+    const filterSensitiveLog: (obj: CreateWirelessDeviceRequest) => any;
+}
+export interface CreateWirelessDeviceResponse {
+    
+    Arn?: string;
+    
+    Id?: string;
+}
+export declare namespace CreateWirelessDeviceResponse {
+    
+    const filterSensitiveLog: (obj: CreateWirelessDeviceResponse) => any;
+}
+
+export interface LoRaWANGateway {
+    
+    GatewayEui?: string;
+    
+    RfRegion?: string;
+    
+    JoinEuiFilters?: string[][];
+    
+    NetIdFilters?: string[];
+    
+    SubBands?: number[];
+}
+export declare namespace LoRaWANGateway {
+    
+    const filterSensitiveLog: (obj: LoRaWANGateway) => any;
+}
+export interface CreateWirelessGatewayRequest {
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    LoRaWAN: LoRaWANGateway | undefined;
+    
+    Tags?: Tag[];
+    
+    ClientRequestToken?: string;
+}
+export declare namespace CreateWirelessGatewayRequest {
+    
+    const filterSensitiveLog: (obj: CreateWirelessGatewayRequest) => any;
+}
+export interface CreateWirelessGatewayResponse {
+    
+    Arn?: string;
+    
+    Id?: string;
+}
+export declare namespace CreateWirelessGatewayResponse {
+    
+    const filterSensitiveLog: (obj: CreateWirelessGatewayResponse) => any;
+}
+export interface CreateWirelessGatewayTaskRequest {
+    
+    Id: string | undefined;
+    
+    WirelessGatewayTaskDefinitionId: string | undefined;
+}
+export declare namespace CreateWirelessGatewayTaskRequest {
+    
+    const filterSensitiveLog: (obj: CreateWirelessGatewayTaskRequest) => any;
+}
+export declare enum WirelessGatewayTaskStatus {
+    COMPLETED = "COMPLETED",
+    FAILED = "FAILED",
+    FIRST_RETRY = "FIRST_RETRY",
+    IN_PROGRESS = "IN_PROGRESS",
+    PENDING = "PENDING",
+    SECOND_RETRY = "SECOND_RETRY"
+}
+export interface CreateWirelessGatewayTaskResponse {
+    
+    WirelessGatewayTaskDefinitionId?: string;
+    
+    Status?: WirelessGatewayTaskStatus | string;
+}
+export declare namespace CreateWirelessGatewayTaskResponse {
+    
+    const filterSensitiveLog: (obj: CreateWirelessGatewayTaskResponse) => any;
+}
+
+export interface LoRaWANGatewayVersion {
+    
+    PackageVersion?: string;
+    
+    Model?: string;
+    
+    Station?: string;
+}
+export declare namespace LoRaWANGatewayVersion {
+    
+    const filterSensitiveLog: (obj: LoRaWANGatewayVersion) => any;
+}
+
+export interface LoRaWANUpdateGatewayTaskCreate {
+    
+    UpdateSignature?: string;
+    
+    SigKeyCrc?: number;
+    
+    CurrentVersion?: LoRaWANGatewayVersion;
+    
+    UpdateVersion?: LoRaWANGatewayVersion;
+}
+export declare namespace LoRaWANUpdateGatewayTaskCreate {
+    
+    const filterSensitiveLog: (obj: LoRaWANUpdateGatewayTaskCreate) => any;
+}
+
+export interface UpdateWirelessGatewayTaskCreate {
+    
+    UpdateDataSource?: string;
+    
+    UpdateDataRole?: string;
+    
+    LoRaWAN?: LoRaWANUpdateGatewayTaskCreate;
+}
+export declare namespace UpdateWirelessGatewayTaskCreate {
+    
+    const filterSensitiveLog: (obj: UpdateWirelessGatewayTaskCreate) => any;
+}
+export interface CreateWirelessGatewayTaskDefinitionRequest {
+    
+    AutoCreateTasks: boolean | undefined;
+    
+    Name?: string;
+    
+    Update?: UpdateWirelessGatewayTaskCreate;
+    
+    ClientRequestToken?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateWirelessGatewayTaskDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: CreateWirelessGatewayTaskDefinitionRequest) => any;
+}
+export interface CreateWirelessGatewayTaskDefinitionResponse {
+    
+    Id?: string;
+    
+    Arn?: string;
+}
+export declare namespace CreateWirelessGatewayTaskDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: CreateWirelessGatewayTaskDefinitionResponse) => any;
+}
+export interface DeleteDestinationRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace DeleteDestinationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDestinationRequest) => any;
+}
+export interface DeleteDestinationResponse {
+}
+export declare namespace DeleteDestinationResponse {
+    
+    const filterSensitiveLog: (obj: DeleteDestinationResponse) => any;
+}
+export interface DeleteDeviceProfileRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace DeleteDeviceProfileRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDeviceProfileRequest) => any;
+}
+export interface DeleteDeviceProfileResponse {
+}
+export declare namespace DeleteDeviceProfileResponse {
+    
+    const filterSensitiveLog: (obj: DeleteDeviceProfileResponse) => any;
+}
+export interface DeleteFuotaTaskRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace DeleteFuotaTaskRequest {
+    
+    const filterSensitiveLog: (obj: DeleteFuotaTaskRequest) => any;
+}
+export interface DeleteFuotaTaskResponse {
+}
+export declare namespace DeleteFuotaTaskResponse {
+    
+    const filterSensitiveLog: (obj: DeleteFuotaTaskResponse) => any;
+}
+export interface DeleteMulticastGroupRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace DeleteMulticastGroupRequest {
+    
+    const filterSensitiveLog: (obj: DeleteMulticastGroupRequest) => any;
+}
+export interface DeleteMulticastGroupResponse {
+}
+export declare namespace DeleteMulticastGroupResponse {
+    
+    const filterSensitiveLog: (obj: DeleteMulticastGroupResponse) => any;
+}
+export interface DeleteQueuedMessagesRequest {
+    
+    Id: string | undefined;
+    
+    MessageId: string | undefined;
+    
+    WirelessDeviceType?: WirelessDeviceType | string;
+}
+export declare namespace DeleteQueuedMessagesRequest {
+    
+    const filterSensitiveLog: (obj: DeleteQueuedMessagesRequest) => any;
+}
+export interface DeleteQueuedMessagesResponse {
+}
+export declare namespace DeleteQueuedMessagesResponse {
+    
+    const filterSensitiveLog: (obj: DeleteQueuedMessagesResponse) => any;
+}
+export interface DeleteServiceProfileRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace DeleteServiceProfileRequest {
+    
+    const filterSensitiveLog: (obj: DeleteServiceProfileRequest) => any;
+}
+export interface DeleteServiceProfileResponse {
+}
+export declare namespace DeleteServiceProfileResponse {
+    
+    const filterSensitiveLog: (obj: DeleteServiceProfileResponse) => any;
+}
+export interface DeleteWirelessDeviceRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace DeleteWirelessDeviceRequest {
+    
+    const filterSensitiveLog: (obj: DeleteWirelessDeviceRequest) => any;
+}
+export interface DeleteWirelessDeviceResponse {
+}
+export declare namespace DeleteWirelessDeviceResponse {
+    
+    const filterSensitiveLog: (obj: DeleteWirelessDeviceResponse) => any;
+}
+export interface DeleteWirelessGatewayRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace DeleteWirelessGatewayRequest {
+    
+    const filterSensitiveLog: (obj: DeleteWirelessGatewayRequest) => any;
+}
+export interface DeleteWirelessGatewayResponse {
+}
+export declare namespace DeleteWirelessGatewayResponse {
+    
+    const filterSensitiveLog: (obj: DeleteWirelessGatewayResponse) => any;
+}
+export interface DeleteWirelessGatewayTaskRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace DeleteWirelessGatewayTaskRequest {
+    
+    const filterSensitiveLog: (obj: DeleteWirelessGatewayTaskRequest) => any;
+}
+export interface DeleteWirelessGatewayTaskResponse {
+}
+export declare namespace DeleteWirelessGatewayTaskResponse {
+    
+    const filterSensitiveLog: (obj: DeleteWirelessGatewayTaskResponse) => any;
+}
+export interface DeleteWirelessGatewayTaskDefinitionRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace DeleteWirelessGatewayTaskDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteWirelessGatewayTaskDefinitionRequest) => any;
+}
+export interface DeleteWirelessGatewayTaskDefinitionResponse {
+}
+export declare namespace DeleteWirelessGatewayTaskDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: DeleteWirelessGatewayTaskDefinitionResponse) => any;
+}
+
+export interface Destinations {
+    
+    Arn?: string;
+    
+    Name?: string;
+    
+    ExpressionType?: ExpressionType | string;
+    
+    Expression?: string;
+    
+    Description?: string;
+    
+    RoleArn?: string;
+}
+export declare namespace Destinations {
+    
+    const filterSensitiveLog: (obj: Destinations) => any;
+}
+
+export interface DeviceProfile {
+    
+    Arn?: string;
+    
+    Name?: string;
+    
+    Id?: string;
+}
+export declare namespace DeviceProfile {
+    
+    const filterSensitiveLog: (obj: DeviceProfile) => any;
+}
+export declare enum EventNotificationTopicStatus {
+    Disabled = "Disabled",
+    Enabled = "Enabled"
+}
+
+export interface SidewalkEventNotificationConfigurations {
+    
+    AmazonIdEventTopic?: EventNotificationTopicStatus | string;
+}
+export declare namespace SidewalkEventNotificationConfigurations {
+    
+    const filterSensitiveLog: (obj: SidewalkEventNotificationConfigurations) => any;
+}
+
+export interface DeviceRegistrationStateEventConfiguration {
+    
+    Sidewalk?: SidewalkEventNotificationConfigurations;
+}
+export declare namespace DeviceRegistrationStateEventConfiguration {
+    
+    const filterSensitiveLog: (obj: DeviceRegistrationStateEventConfiguration) => any;
+}
+export declare enum DeviceState {
+    PROVISIONED = "Provisioned",
+    REGISTEREDNOTSEEN = "RegisteredNotSeen",
+    REGISTEREDREACHABLE = "RegisteredReachable",
+    REGISTEREDUNREACHABLE = "RegisteredUnreachable"
+}
+export declare enum PartnerType {
+    Sidewalk = "Sidewalk"
+}
+export interface DisassociateAwsAccountFromPartnerAccountRequest {
+    
+    PartnerAccountId: string | undefined;
+    
+    PartnerType: PartnerType | string | undefined;
+}
+export declare namespace DisassociateAwsAccountFromPartnerAccountRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateAwsAccountFromPartnerAccountRequest) => any;
+}
+export interface DisassociateAwsAccountFromPartnerAccountResponse {
+}
+export declare namespace DisassociateAwsAccountFromPartnerAccountResponse {
+    
+    const filterSensitiveLog: (obj: DisassociateAwsAccountFromPartnerAccountResponse) => any;
+}
+export interface DisassociateMulticastGroupFromFuotaTaskRequest {
+    
+    Id: string | undefined;
+    
+    MulticastGroupId: string | undefined;
+}
+export declare namespace DisassociateMulticastGroupFromFuotaTaskRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateMulticastGroupFromFuotaTaskRequest) => any;
+}
+export interface DisassociateMulticastGroupFromFuotaTaskResponse {
+}
+export declare namespace DisassociateMulticastGroupFromFuotaTaskResponse {
+    
+    const filterSensitiveLog: (obj: DisassociateMulticastGroupFromFuotaTaskResponse) => any;
+}
+export interface DisassociateWirelessDeviceFromFuotaTaskRequest {
+    
+    Id: string | undefined;
+    
+    WirelessDeviceId: string | undefined;
+}
+export declare namespace DisassociateWirelessDeviceFromFuotaTaskRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateWirelessDeviceFromFuotaTaskRequest) => any;
+}
+export interface DisassociateWirelessDeviceFromFuotaTaskResponse {
+}
+export declare namespace DisassociateWirelessDeviceFromFuotaTaskResponse {
+    
+    const filterSensitiveLog: (obj: DisassociateWirelessDeviceFromFuotaTaskResponse) => any;
+}
+export interface DisassociateWirelessDeviceFromMulticastGroupRequest {
+    
+    Id: string | undefined;
+    
+    WirelessDeviceId: string | undefined;
+}
+export declare namespace DisassociateWirelessDeviceFromMulticastGroupRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateWirelessDeviceFromMulticastGroupRequest) => any;
+}
+export interface DisassociateWirelessDeviceFromMulticastGroupResponse {
+}
+export declare namespace DisassociateWirelessDeviceFromMulticastGroupResponse {
+    
+    const filterSensitiveLog: (obj: DisassociateWirelessDeviceFromMulticastGroupResponse) => any;
+}
+export interface DisassociateWirelessDeviceFromThingRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace DisassociateWirelessDeviceFromThingRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateWirelessDeviceFromThingRequest) => any;
+}
+export interface DisassociateWirelessDeviceFromThingResponse {
+}
+export declare namespace DisassociateWirelessDeviceFromThingResponse {
+    
+    const filterSensitiveLog: (obj: DisassociateWirelessDeviceFromThingResponse) => any;
+}
+export interface DisassociateWirelessGatewayFromCertificateRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace DisassociateWirelessGatewayFromCertificateRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateWirelessGatewayFromCertificateRequest) => any;
+}
+export interface DisassociateWirelessGatewayFromCertificateResponse {
+}
+export declare namespace DisassociateWirelessGatewayFromCertificateResponse {
+    
+    const filterSensitiveLog: (obj: DisassociateWirelessGatewayFromCertificateResponse) => any;
+}
+export interface DisassociateWirelessGatewayFromThingRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace DisassociateWirelessGatewayFromThingRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateWirelessGatewayFromThingRequest) => any;
+}
+export interface DisassociateWirelessGatewayFromThingResponse {
+}
+export declare namespace DisassociateWirelessGatewayFromThingResponse {
+    
+    const filterSensitiveLog: (obj: DisassociateWirelessGatewayFromThingResponse) => any;
+}
+
+export interface LoRaWANSendDataToDevice {
+    
+    FPort?: number;
+}
+export declare namespace LoRaWANSendDataToDevice {
+    
+    const filterSensitiveLog: (obj: LoRaWANSendDataToDevice) => any;
+}
+
+export interface DownlinkQueueMessage {
+    
+    MessageId?: string;
+    
+    TransmitMode?: number;
+    
+    ReceivedAt?: string;
+    
+    LoRaWAN?: LoRaWANSendDataToDevice;
+}
+export declare namespace DownlinkQueueMessage {
+    
+    const filterSensitiveLog: (obj: DownlinkQueueMessage) => any;
+}
+export declare enum Event {
+    ACK = "ack",
+    DISCOVERED = "discovered",
+    LOST = "lost",
+    NACK = "nack",
+    PASSTHROUGH = "passthrough"
+}
+export declare enum EventNotificationPartnerType {
+    Sidewalk = "Sidewalk"
+}
+export declare enum FuotaDeviceStatus {
+    FragAlgo_unsupported = "FragAlgo_unsupported",
+    FragIndex_unsupported = "FragIndex_unsupported",
+    Initial = "Initial",
+    MICError = "MICError",
+    MemoryError = "MemoryError",
+    MissingFrag = "MissingFrag",
+    Not_enough_memory = "Not_enough_memory",
+    Package_Not_Supported = "Package_Not_Supported",
+    SessionCnt_replay = "SessionCnt_replay",
+    Successful = "Successful",
+    Wrong_descriptor = "Wrong_descriptor"
+}
+
+export interface FuotaTask {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+}
+export declare namespace FuotaTask {
+    
+    const filterSensitiveLog: (obj: FuotaTask) => any;
+}
+export declare enum FuotaTaskStatus {
+    Delete_Waiting = "Delete_Waiting",
+    FuotaDone = "FuotaDone",
+    FuotaSession_Waiting = "FuotaSession_Waiting",
+    In_FuotaSession = "In_FuotaSession",
+    Pending = "Pending"
+}
+export interface GetDestinationRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace GetDestinationRequest {
+    
+    const filterSensitiveLog: (obj: GetDestinationRequest) => any;
+}
+export interface GetDestinationResponse {
+    
+    Arn?: string;
+    
+    Name?: string;
+    
+    Expression?: string;
+    
+    ExpressionType?: ExpressionType | string;
+    
+    Description?: string;
+    
+    RoleArn?: string;
+}
+export declare namespace GetDestinationResponse {
+    
+    const filterSensitiveLog: (obj: GetDestinationResponse) => any;
+}
+export interface GetDeviceProfileRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace GetDeviceProfileRequest {
+    
+    const filterSensitiveLog: (obj: GetDeviceProfileRequest) => any;
+}
+export interface GetDeviceProfileResponse {
+    
+    Arn?: string;
+    
+    Name?: string;
+    
+    Id?: string;
+    
+    LoRaWAN?: LoRaWANDeviceProfile;
+}
+export declare namespace GetDeviceProfileResponse {
+    
+    const filterSensitiveLog: (obj: GetDeviceProfileResponse) => any;
+}
+export interface GetFuotaTaskRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace GetFuotaTaskRequest {
+    
+    const filterSensitiveLog: (obj: GetFuotaTaskRequest) => any;
+}
+
+export interface LoRaWANFuotaTaskGetInfo {
+    
+    RfRegion?: string;
+    
+    StartTime?: Date;
+}
+export declare namespace LoRaWANFuotaTaskGetInfo {
+    
+    const filterSensitiveLog: (obj: LoRaWANFuotaTaskGetInfo) => any;
+}
+export interface GetFuotaTaskResponse {
+    
+    Arn?: string;
+    
+    Id?: string;
+    
+    Status?: FuotaTaskStatus | string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    LoRaWAN?: LoRaWANFuotaTaskGetInfo;
+    
+    FirmwareUpdateImage?: string;
+    
+    FirmwareUpdateRole?: string;
+    
+    CreatedAt?: Date;
+}
+export declare namespace GetFuotaTaskResponse {
+    
+    const filterSensitiveLog: (obj: GetFuotaTaskResponse) => any;
+}
+export interface GetLogLevelsByResourceTypesRequest {
+}
+export declare namespace GetLogLevelsByResourceTypesRequest {
+    
+    const filterSensitiveLog: (obj: GetLogLevelsByResourceTypesRequest) => any;
+}
+export declare enum LogLevel {
+    DISABLED = "DISABLED",
+    ERROR = "ERROR",
+    INFO = "INFO"
+}
+export declare enum WirelessDeviceEvent {
+    Downlink_Data = "Downlink_Data",
+    Join = "Join",
+    Registration = "Registration",
+    Rejoin = "Rejoin",
+    Uplink_Data = "Uplink_Data"
+}
+
+export interface WirelessDeviceEventLogOption {
+    
+    Event: WirelessDeviceEvent | string | undefined;
+    
+    LogLevel: LogLevel | string | undefined;
+}
+export declare namespace WirelessDeviceEventLogOption {
+    
+    const filterSensitiveLog: (obj: WirelessDeviceEventLogOption) => any;
+}
+
+export interface WirelessDeviceLogOption {
+    
+    Type: WirelessDeviceType | string | undefined;
+    
+    LogLevel: LogLevel | string | undefined;
+    
+    Events?: WirelessDeviceEventLogOption[];
+}
+export declare namespace WirelessDeviceLogOption {
+    
+    const filterSensitiveLog: (obj: WirelessDeviceLogOption) => any;
+}
+export declare enum WirelessGatewayEvent {
+    CUPS_Request = "CUPS_Request",
+    Certificate = "Certificate"
+}
+
+export interface WirelessGatewayEventLogOption {
+    
+    Event: WirelessGatewayEvent | string | undefined;
+    
+    LogLevel: LogLevel | string | undefined;
+}
+export declare namespace WirelessGatewayEventLogOption {
+    
+    const filterSensitiveLog: (obj: WirelessGatewayEventLogOption) => any;
+}
+export declare enum WirelessGatewayType {
+    LoRaWAN = "LoRaWAN"
+}
+
+export interface WirelessGatewayLogOption {
+    
+    Type: WirelessGatewayType | string | undefined;
+    
+    LogLevel: LogLevel | string | undefined;
+    
+    Events?: WirelessGatewayEventLogOption[];
+}
+export declare namespace WirelessGatewayLogOption {
+    
+    const filterSensitiveLog: (obj: WirelessGatewayLogOption) => any;
+}
+export interface GetLogLevelsByResourceTypesResponse {
+    
+    DefaultLogLevel?: LogLevel | string;
+    
+    WirelessGatewayLogOptions?: WirelessGatewayLogOption[];
+    
+    WirelessDeviceLogOptions?: WirelessDeviceLogOption[];
+}
+export declare namespace GetLogLevelsByResourceTypesResponse {
+    
+    const filterSensitiveLog: (obj: GetLogLevelsByResourceTypesResponse) => any;
+}
+export interface GetMulticastGroupRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace GetMulticastGroupRequest {
+    
+    const filterSensitiveLog: (obj: GetMulticastGroupRequest) => any;
+}
+
+export interface LoRaWANMulticastGet {
+    
+    RfRegion?: SupportedRfRegion | string;
+    
+    DlClass?: DlClass | string;
+    
+    NumberOfDevicesRequested?: number;
+    
+    NumberOfDevicesInGroup?: number;
+}
+export declare namespace LoRaWANMulticastGet {
+    
+    const filterSensitiveLog: (obj: LoRaWANMulticastGet) => any;
+}
+export interface GetMulticastGroupResponse {
+    
+    Arn?: string;
+    
+    Id?: string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    Status?: string;
+    
+    LoRaWAN?: LoRaWANMulticastGet;
+    
+    CreatedAt?: Date;
+}
+export declare namespace GetMulticastGroupResponse {
+    
+    const filterSensitiveLog: (obj: GetMulticastGroupResponse) => any;
+}
+export interface GetMulticastGroupSessionRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace GetMulticastGroupSessionRequest {
+    
+    const filterSensitiveLog: (obj: GetMulticastGroupSessionRequest) => any;
+}
+
+export interface LoRaWANMulticastSession {
+    
+    DlDr?: number;
+    
+    DlFreq?: number;
+    
+    SessionStartTime?: Date;
+    
+    SessionTimeout?: number;
+}
+export declare namespace LoRaWANMulticastSession {
+    
+    const filterSensitiveLog: (obj: LoRaWANMulticastSession) => any;
+}
+export interface GetMulticastGroupSessionResponse {
+    
+    LoRaWAN?: LoRaWANMulticastSession;
+}
+export declare namespace GetMulticastGroupSessionResponse {
+    
+    const filterSensitiveLog: (obj: GetMulticastGroupSessionResponse) => any;
+}
+export interface GetNetworkAnalyzerConfigurationRequest {
+    
+    ConfigurationName: string | undefined;
+}
+export declare namespace GetNetworkAnalyzerConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: GetNetworkAnalyzerConfigurationRequest) => any;
+}
+export declare enum WirelessDeviceFrameInfo {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface TraceContent {
+    
+    WirelessDeviceFrameInfo?: WirelessDeviceFrameInfo | string;
+    
+    LogLevel?: LogLevel | string;
+}
+export declare namespace TraceContent {
+    
+    const filterSensitiveLog: (obj: TraceContent) => any;
+}
+export interface GetNetworkAnalyzerConfigurationResponse {
+    
+    TraceContent?: TraceContent;
+    
+    WirelessDevices?: string[];
+    
+    WirelessGateways?: string[];
+}
+export declare namespace GetNetworkAnalyzerConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: GetNetworkAnalyzerConfigurationResponse) => any;
+}
+export interface GetPartnerAccountRequest {
+    
+    PartnerAccountId: string | undefined;
+    
+    PartnerType: PartnerType | string | undefined;
+}
+export declare namespace GetPartnerAccountRequest {
+    
+    const filterSensitiveLog: (obj: GetPartnerAccountRequest) => any;
+}
+
+export interface SidewalkAccountInfoWithFingerprint {
+    
+    AmazonId?: string;
+    
+    Fingerprint?: string;
+    
+    Arn?: string;
+}
+export declare namespace SidewalkAccountInfoWithFingerprint {
+    
+    const filterSensitiveLog: (obj: SidewalkAccountInfoWithFingerprint) => any;
+}
+export interface GetPartnerAccountResponse {
+    
+    Sidewalk?: SidewalkAccountInfoWithFingerprint;
+    
+    AccountLinked?: boolean;
+}
+export declare namespace GetPartnerAccountResponse {
+    
+    const filterSensitiveLog: (obj: GetPartnerAccountResponse) => any;
+}
+export declare enum IdentifierType {
+    PartnerAccountId = "PartnerAccountId"
+}
+export interface GetResourceEventConfigurationRequest {
+    
+    Identifier: string | undefined;
+    
+    IdentifierType: IdentifierType | string | undefined;
+    
+    PartnerType?: EventNotificationPartnerType | string;
+}
+export declare namespace GetResourceEventConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: GetResourceEventConfigurationRequest) => any;
+}
+
+export interface ProximityEventConfiguration {
+    
+    Sidewalk?: SidewalkEventNotificationConfigurations;
+}
+export declare namespace ProximityEventConfiguration {
+    
+    const filterSensitiveLog: (obj: ProximityEventConfiguration) => any;
+}
+export interface GetResourceEventConfigurationResponse {
+    
+    DeviceRegistrationState?: DeviceRegistrationStateEventConfiguration;
+    
+    Proximity?: ProximityEventConfiguration;
+}
+export declare namespace GetResourceEventConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: GetResourceEventConfigurationResponse) => any;
+}
+export interface GetResourceLogLevelRequest {
+    
+    ResourceIdentifier: string | undefined;
+    
+    ResourceType: string | undefined;
+}
+export declare namespace GetResourceLogLevelRequest {
+    
+    const filterSensitiveLog: (obj: GetResourceLogLevelRequest) => any;
+}
+export interface GetResourceLogLevelResponse {
+    
+    LogLevel?: LogLevel | string;
+}
+export declare namespace GetResourceLogLevelResponse {
+    
+    const filterSensitiveLog: (obj: GetResourceLogLevelResponse) => any;
+}
+export declare enum WirelessGatewayServiceType {
+    CUPS = "CUPS",
+    LNS = "LNS"
+}
+export interface GetServiceEndpointRequest {
+    
+    ServiceType?: WirelessGatewayServiceType | string;
+}
+export declare namespace GetServiceEndpointRequest {
+    
+    const filterSensitiveLog: (obj: GetServiceEndpointRequest) => any;
+}
+export interface GetServiceEndpointResponse {
+    
+    ServiceType?: WirelessGatewayServiceType | string;
+    
+    ServiceEndpoint?: string;
+    
+    ServerTrust?: string;
+}
+export declare namespace GetServiceEndpointResponse {
+    
+    const filterSensitiveLog: (obj: GetServiceEndpointResponse) => any;
+}
+export interface GetServiceProfileRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace GetServiceProfileRequest {
+    
+    const filterSensitiveLog: (obj: GetServiceProfileRequest) => any;
+}
+
+export interface LoRaWANGetServiceProfileInfo {
+    
+    UlRate?: number;
+    
+    UlBucketSize?: number;
+    
+    UlRatePolicy?: string;
+    
+    DlRate?: number;
+    
+    DlBucketSize?: number;
+    
+    DlRatePolicy?: string;
+    
+    AddGwMetadata?: boolean;
+    
+    DevStatusReqFreq?: number;
+    
+    ReportDevStatusBattery?: boolean;
+    
+    ReportDevStatusMargin?: boolean;
+    
+    DrMin?: number;
+    
+    DrMax?: number;
+    
+    ChannelMask?: string;
+    
+    PrAllowed?: boolean;
+    
+    HrAllowed?: boolean;
+    
+    RaAllowed?: boolean;
+    
+    NwkGeoLoc?: boolean;
+    
+    TargetPer?: number;
+    
+    MinGwDiversity?: number;
+}
+export declare namespace LoRaWANGetServiceProfileInfo {
+    
+    const filterSensitiveLog: (obj: LoRaWANGetServiceProfileInfo) => any;
+}
+export interface GetServiceProfileResponse {
+    
+    Arn?: string;
+    
+    Name?: string;
+    
+    Id?: string;
+    
+    LoRaWAN?: LoRaWANGetServiceProfileInfo;
+}
+export declare namespace GetServiceProfileResponse {
+    
+    const filterSensitiveLog: (obj: GetServiceProfileResponse) => any;
+}
+export declare enum WirelessDeviceIdType {
+    DevEui = "DevEui",
+    SidewalkManufacturingSn = "SidewalkManufacturingSn",
+    ThingName = "ThingName",
+    WirelessDeviceId = "WirelessDeviceId"
+}
+export interface GetWirelessDeviceRequest {
+    
+    Identifier: string | undefined;
+    
+    IdentifierType: WirelessDeviceIdType | string | undefined;
+}
+export declare namespace GetWirelessDeviceRequest {
+    
+    const filterSensitiveLog: (obj: GetWirelessDeviceRequest) => any;
+}
+
+export interface SidewalkDevice {
+    
+    AmazonId?: string;
+    
+    SidewalkId?: string;
+    
+    SidewalkManufacturingSn?: string;
+    
+    DeviceCertificates?: CertificateList[];
+}
+export declare namespace SidewalkDevice {
+    
+    const filterSensitiveLog: (obj: SidewalkDevice) => any;
+}
+export interface GetWirelessDeviceResponse {
+    
+    Type?: WirelessDeviceType | string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    DestinationName?: string;
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    ThingName?: string;
+    
+    ThingArn?: string;
+    
+    LoRaWAN?: LoRaWANDevice;
+    
+    Sidewalk?: SidewalkDevice;
+}
+export declare namespace GetWirelessDeviceResponse {
+    
+    const filterSensitiveLog: (obj: GetWirelessDeviceResponse) => any;
+}
+export interface GetWirelessDeviceStatisticsRequest {
+    
+    WirelessDeviceId: string | undefined;
+}
+export declare namespace GetWirelessDeviceStatisticsRequest {
+    
+    const filterSensitiveLog: (obj: GetWirelessDeviceStatisticsRequest) => any;
+}
+
+export interface LoRaWANGatewayMetadata {
+    
+    GatewayEui?: string;
+    
+    Snr?: number;
+    
+    Rssi?: number;
+}
+export declare namespace LoRaWANGatewayMetadata {
+    
+    const filterSensitiveLog: (obj: LoRaWANGatewayMetadata) => any;
+}
+
+export interface LoRaWANDeviceMetadata {
+    
+    DevEui?: string;
+    
+    FPort?: number;
+    
+    DataRate?: number;
+    
+    Frequency?: number;
+    
+    Timestamp?: string;
+    
+    Gateways?: LoRaWANGatewayMetadata[];
+}
+export declare namespace LoRaWANDeviceMetadata {
+    
+    const filterSensitiveLog: (obj: LoRaWANDeviceMetadata) => any;
+}
+
+export interface SidewalkDeviceMetadata {
+    
+    Rssi?: number;
+    
+    BatteryLevel?: BatteryLevel | string;
+    
+    Event?: Event | string;
+    
+    DeviceState?: DeviceState | string;
+}
+export declare namespace SidewalkDeviceMetadata {
+    
+    const filterSensitiveLog: (obj: SidewalkDeviceMetadata) => any;
+}
+export interface GetWirelessDeviceStatisticsResponse {
+    
+    WirelessDeviceId?: string;
+    
+    LastUplinkReceivedAt?: string;
+    
+    LoRaWAN?: LoRaWANDeviceMetadata;
+    
+    Sidewalk?: SidewalkDeviceMetadata;
+}
+export declare namespace GetWirelessDeviceStatisticsResponse {
+    
+    const filterSensitiveLog: (obj: GetWirelessDeviceStatisticsResponse) => any;
+}
+export declare enum WirelessGatewayIdType {
+    GatewayEui = "GatewayEui",
+    ThingName = "ThingName",
+    WirelessGatewayId = "WirelessGatewayId"
+}
+export interface GetWirelessGatewayRequest {
+    
+    Identifier: string | undefined;
+    
+    IdentifierType: WirelessGatewayIdType | string | undefined;
+}
+export declare namespace GetWirelessGatewayRequest {
+    
+    const filterSensitiveLog: (obj: GetWirelessGatewayRequest) => any;
+}
+export interface GetWirelessGatewayResponse {
+    
+    Name?: string;
+    
+    Id?: string;
+    
+    Description?: string;
+    
+    LoRaWAN?: LoRaWANGateway;
+    
+    Arn?: string;
+    
+    ThingName?: string;
+    
+    ThingArn?: string;
+}
+export declare namespace GetWirelessGatewayResponse {
+    
+    const filterSensitiveLog: (obj: GetWirelessGatewayResponse) => any;
+}
+export interface GetWirelessGatewayCertificateRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace GetWirelessGatewayCertificateRequest {
+    
+    const filterSensitiveLog: (obj: GetWirelessGatewayCertificateRequest) => any;
+}
+export interface GetWirelessGatewayCertificateResponse {
+    
+    IotCertificateId?: string;
+    
+    LoRaWANNetworkServerCertificateId?: string;
+}
+export declare namespace GetWirelessGatewayCertificateResponse {
+    
+    const filterSensitiveLog: (obj: GetWirelessGatewayCertificateResponse) => any;
+}
+export interface GetWirelessGatewayFirmwareInformationRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace GetWirelessGatewayFirmwareInformationRequest {
+    
+    const filterSensitiveLog: (obj: GetWirelessGatewayFirmwareInformationRequest) => any;
+}
+
+export interface LoRaWANGatewayCurrentVersion {
+    
+    CurrentVersion?: LoRaWANGatewayVersion;
+}
+export declare namespace LoRaWANGatewayCurrentVersion {
+    
+    const filterSensitiveLog: (obj: LoRaWANGatewayCurrentVersion) => any;
+}
+export interface GetWirelessGatewayFirmwareInformationResponse {
+    
+    LoRaWAN?: LoRaWANGatewayCurrentVersion;
+}
+export declare namespace GetWirelessGatewayFirmwareInformationResponse {
+    
+    const filterSensitiveLog: (obj: GetWirelessGatewayFirmwareInformationResponse) => any;
+}
+export interface GetWirelessGatewayStatisticsRequest {
+    
+    WirelessGatewayId: string | undefined;
+}
+export declare namespace GetWirelessGatewayStatisticsRequest {
+    
+    const filterSensitiveLog: (obj: GetWirelessGatewayStatisticsRequest) => any;
+}
+export interface GetWirelessGatewayStatisticsResponse {
+    
+    WirelessGatewayId?: string;
+    
+    LastUplinkReceivedAt?: string;
+    
+    ConnectionStatus?: ConnectionStatus | string;
+}
+export declare namespace GetWirelessGatewayStatisticsResponse {
+    
+    const filterSensitiveLog: (obj: GetWirelessGatewayStatisticsResponse) => any;
+}
+export interface GetWirelessGatewayTaskRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace GetWirelessGatewayTaskRequest {
+    
+    const filterSensitiveLog: (obj: GetWirelessGatewayTaskRequest) => any;
+}
+export interface GetWirelessGatewayTaskResponse {
+    
+    WirelessGatewayId?: string;
+    
+    WirelessGatewayTaskDefinitionId?: string;
+    
+    LastUplinkReceivedAt?: string;
+    
+    TaskCreatedAt?: string;
+    
+    Status?: WirelessGatewayTaskStatus | string;
+}
+export declare namespace GetWirelessGatewayTaskResponse {
+    
+    const filterSensitiveLog: (obj: GetWirelessGatewayTaskResponse) => any;
+}
+export interface GetWirelessGatewayTaskDefinitionRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace GetWirelessGatewayTaskDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: GetWirelessGatewayTaskDefinitionRequest) => any;
+}
+export interface GetWirelessGatewayTaskDefinitionResponse {
+    
+    AutoCreateTasks?: boolean;
+    
+    Name?: string;
+    
+    Update?: UpdateWirelessGatewayTaskCreate;
+    
+    Arn?: string;
+}
+export declare namespace GetWirelessGatewayTaskDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: GetWirelessGatewayTaskDefinitionResponse) => any;
+}
+export interface ListDestinationsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListDestinationsRequest {
+    
+    const filterSensitiveLog: (obj: ListDestinationsRequest) => any;
+}
+export interface ListDestinationsResponse {
+    
+    NextToken?: string;
+    
+    DestinationList?: Destinations[];
+}
+export declare namespace ListDestinationsResponse {
+    
+    const filterSensitiveLog: (obj: ListDestinationsResponse) => any;
+}
+export interface ListDeviceProfilesRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListDeviceProfilesRequest {
+    
+    const filterSensitiveLog: (obj: ListDeviceProfilesRequest) => any;
+}
+export interface ListDeviceProfilesResponse {
+    
+    NextToken?: string;
+    
+    DeviceProfileList?: DeviceProfile[];
+}
+export declare namespace ListDeviceProfilesResponse {
+    
+    const filterSensitiveLog: (obj: ListDeviceProfilesResponse) => any;
+}
+export interface ListFuotaTasksRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListFuotaTasksRequest {
+    
+    const filterSensitiveLog: (obj: ListFuotaTasksRequest) => any;
+}
+export interface ListFuotaTasksResponse {
+    
+    NextToken?: string;
+    
+    FuotaTaskList?: FuotaTask[];
+}
+export declare namespace ListFuotaTasksResponse {
+    
+    const filterSensitiveLog: (obj: ListFuotaTasksResponse) => any;
+}
+export interface ListMulticastGroupsRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListMulticastGroupsRequest {
+    
+    const filterSensitiveLog: (obj: ListMulticastGroupsRequest) => any;
+}
+
+export interface MulticastGroup {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+}
+export declare namespace MulticastGroup {
+    
+    const filterSensitiveLog: (obj: MulticastGroup) => any;
+}
+export interface ListMulticastGroupsResponse {
+    
+    NextToken?: string;
+    
+    MulticastGroupList?: MulticastGroup[];
+}
+export declare namespace ListMulticastGroupsResponse {
+    
+    const filterSensitiveLog: (obj: ListMulticastGroupsResponse) => any;
+}
+export interface ListMulticastGroupsByFuotaTaskRequest {
+    
+    Id: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListMulticastGroupsByFuotaTaskRequest {
+    
+    const filterSensitiveLog: (obj: ListMulticastGroupsByFuotaTaskRequest) => any;
+}
+
+export interface MulticastGroupByFuotaTask {
+    
+    Id?: string;
+}
+export declare namespace MulticastGroupByFuotaTask {
+    
+    const filterSensitiveLog: (obj: MulticastGroupByFuotaTask) => any;
+}
+export interface ListMulticastGroupsByFuotaTaskResponse {
+    
+    NextToken?: string;
+    
+    MulticastGroupList?: MulticastGroupByFuotaTask[];
+}
+export declare namespace ListMulticastGroupsByFuotaTaskResponse {
+    
+    const filterSensitiveLog: (obj: ListMulticastGroupsByFuotaTaskResponse) => any;
+}
+export interface ListPartnerAccountsRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListPartnerAccountsRequest {
+    
+    const filterSensitiveLog: (obj: ListPartnerAccountsRequest) => any;
+}
+export interface ListPartnerAccountsResponse {
+    
+    NextToken?: string;
+    
+    Sidewalk?: SidewalkAccountInfoWithFingerprint[];
+}
+export declare namespace ListPartnerAccountsResponse {
+    
+    const filterSensitiveLog: (obj: ListPartnerAccountsResponse) => any;
+}
+export interface ListQueuedMessagesRequest {
+    
+    Id: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    WirelessDeviceType?: WirelessDeviceType | string;
+}
+export declare namespace ListQueuedMessagesRequest {
+    
+    const filterSensitiveLog: (obj: ListQueuedMessagesRequest) => any;
+}
+export interface ListQueuedMessagesResponse {
+    
+    NextToken?: string;
+    
+    DownlinkQueueMessagesList?: DownlinkQueueMessage[];
+}
+export declare namespace ListQueuedMessagesResponse {
+    
+    const filterSensitiveLog: (obj: ListQueuedMessagesResponse) => any;
+}
+export interface ListServiceProfilesRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListServiceProfilesRequest {
+    
+    const filterSensitiveLog: (obj: ListServiceProfilesRequest) => any;
+}
+
+export interface ServiceProfile {
+    
+    Arn?: string;
+    
+    Name?: string;
+    
+    Id?: string;
+}
+export declare namespace ServiceProfile {
+    
+    const filterSensitiveLog: (obj: ServiceProfile) => any;
+}
+export interface ListServiceProfilesResponse {
+    
+    NextToken?: string;
+    
+    ServiceProfileList?: ServiceProfile[];
+}
+export declare namespace ListServiceProfilesResponse {
+    
+    const filterSensitiveLog: (obj: ListServiceProfilesResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    Tags?: Tag[];
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface ListWirelessDevicesRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    DestinationName?: string;
+    
+    DeviceProfileId?: string;
+    
+    ServiceProfileId?: string;
+    
+    WirelessDeviceType?: WirelessDeviceType | string;
+    
+    FuotaTaskId?: string;
+    
+    MulticastGroupId?: string;
+}
+export declare namespace ListWirelessDevicesRequest {
+    
+    const filterSensitiveLog: (obj: ListWirelessDevicesRequest) => any;
+}
+
+export interface LoRaWANListDevice {
+    
+    DevEui?: string;
+}
+export declare namespace LoRaWANListDevice {
+    
+    const filterSensitiveLog: (obj: LoRaWANListDevice) => any;
+}
+
+export interface SidewalkListDevice {
+    
+    AmazonId?: string;
+    
+    SidewalkId?: string;
+    
+    SidewalkManufacturingSn?: string;
+    
+    DeviceCertificates?: CertificateList[];
+}
+export declare namespace SidewalkListDevice {
+    
+    const filterSensitiveLog: (obj: SidewalkListDevice) => any;
+}
+
+export interface WirelessDeviceStatistics {
+    
+    Arn?: string;
+    
+    Id?: string;
+    
+    Type?: WirelessDeviceType | string;
+    
+    Name?: string;
+    
+    DestinationName?: string;
+    
+    LastUplinkReceivedAt?: string;
+    
+    LoRaWAN?: LoRaWANListDevice;
+    
+    Sidewalk?: SidewalkListDevice;
+    
+    FuotaDeviceStatus?: FuotaDeviceStatus | string;
+    
+    MulticastDeviceStatus?: string;
+    
+    McGroupId?: number;
+}
+export declare namespace WirelessDeviceStatistics {
+    
+    const filterSensitiveLog: (obj: WirelessDeviceStatistics) => any;
+}
+export interface ListWirelessDevicesResponse {
+    
+    NextToken?: string;
+    
+    WirelessDeviceList?: WirelessDeviceStatistics[];
+}
+export declare namespace ListWirelessDevicesResponse {
+    
+    const filterSensitiveLog: (obj: ListWirelessDevicesResponse) => any;
+}
+export interface ListWirelessGatewaysRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListWirelessGatewaysRequest {
+    
+    const filterSensitiveLog: (obj: ListWirelessGatewaysRequest) => any;
+}
+
+export interface WirelessGatewayStatistics {
+    
+    Arn?: string;
+    
+    Id?: string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    LoRaWAN?: LoRaWANGateway;
+    
+    LastUplinkReceivedAt?: string;
+}
+export declare namespace WirelessGatewayStatistics {
+    
+    const filterSensitiveLog: (obj: WirelessGatewayStatistics) => any;
+}
+export interface ListWirelessGatewaysResponse {
+    
+    NextToken?: string;
+    
+    WirelessGatewayList?: WirelessGatewayStatistics[];
+}
+export declare namespace ListWirelessGatewaysResponse {
+    
+    const filterSensitiveLog: (obj: ListWirelessGatewaysResponse) => any;
+}
+export declare enum WirelessGatewayTaskDefinitionType {
+    UPDATE = "UPDATE"
+}
+export interface ListWirelessGatewayTaskDefinitionsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    TaskDefinitionType?: WirelessGatewayTaskDefinitionType | string;
+}
+export declare namespace ListWirelessGatewayTaskDefinitionsRequest {
+    
+    const filterSensitiveLog: (obj: ListWirelessGatewayTaskDefinitionsRequest) => any;
+}
+
+export interface LoRaWANUpdateGatewayTaskEntry {
+    
+    CurrentVersion?: LoRaWANGatewayVersion;
+    
+    UpdateVersion?: LoRaWANGatewayVersion;
+}
+export declare namespace LoRaWANUpdateGatewayTaskEntry {
+    
+    const filterSensitiveLog: (obj: LoRaWANUpdateGatewayTaskEntry) => any;
+}
+
+export interface UpdateWirelessGatewayTaskEntry {
+    
+    Id?: string;
+    
+    LoRaWAN?: LoRaWANUpdateGatewayTaskEntry;
+    
+    Arn?: string;
+}
+export declare namespace UpdateWirelessGatewayTaskEntry {
+    
+    const filterSensitiveLog: (obj: UpdateWirelessGatewayTaskEntry) => any;
+}
+export interface ListWirelessGatewayTaskDefinitionsResponse {
+    
+    NextToken?: string;
+    
+    TaskDefinitions?: UpdateWirelessGatewayTaskEntry[];
+}
+export declare namespace ListWirelessGatewayTaskDefinitionsResponse {
+    
+    const filterSensitiveLog: (obj: ListWirelessGatewayTaskDefinitionsResponse) => any;
+}
+export interface PutResourceLogLevelRequest {
+    
+    ResourceIdentifier: string | undefined;
+    
+    ResourceType: string | undefined;
+    
+    LogLevel: LogLevel | string | undefined;
+}
+export declare namespace PutResourceLogLevelRequest {
+    
+    const filterSensitiveLog: (obj: PutResourceLogLevelRequest) => any;
+}
+export interface PutResourceLogLevelResponse {
+}
+export declare namespace PutResourceLogLevelResponse {
+    
+    const filterSensitiveLog: (obj: PutResourceLogLevelResponse) => any;
+}
+export interface ResetAllResourceLogLevelsRequest {
+}
+export declare namespace ResetAllResourceLogLevelsRequest {
+    
+    const filterSensitiveLog: (obj: ResetAllResourceLogLevelsRequest) => any;
+}
+export interface ResetAllResourceLogLevelsResponse {
+}
+export declare namespace ResetAllResourceLogLevelsResponse {
+    
+    const filterSensitiveLog: (obj: ResetAllResourceLogLevelsResponse) => any;
+}
+export interface ResetResourceLogLevelRequest {
+    
+    ResourceIdentifier: string | undefined;
+    
+    ResourceType: string | undefined;
+}
+export declare namespace ResetResourceLogLevelRequest {
+    
+    const filterSensitiveLog: (obj: ResetResourceLogLevelRequest) => any;
+}
+export interface ResetResourceLogLevelResponse {
+}
+export declare namespace ResetResourceLogLevelResponse {
+    
+    const filterSensitiveLog: (obj: ResetResourceLogLevelResponse) => any;
+}
+
+export interface LoRaWANMulticastMetadata {
+    
+    FPort?: number;
+}
+export declare namespace LoRaWANMulticastMetadata {
+    
+    const filterSensitiveLog: (obj: LoRaWANMulticastMetadata) => any;
+}
+
+export interface MulticastWirelessMetadata {
+    
+    LoRaWAN?: LoRaWANMulticastMetadata;
+}
+export declare namespace MulticastWirelessMetadata {
+    
+    const filterSensitiveLog: (obj: MulticastWirelessMetadata) => any;
+}
+export interface SendDataToMulticastGroupRequest {
+    
+    Id: string | undefined;
+    
+    PayloadData: string | undefined;
+    
+    WirelessMetadata: MulticastWirelessMetadata | undefined;
+}
+export declare namespace SendDataToMulticastGroupRequest {
+    
+    const filterSensitiveLog: (obj: SendDataToMulticastGroupRequest) => any;
+}
+export interface SendDataToMulticastGroupResponse {
+    
+    MessageId?: string;
+}
+export declare namespace SendDataToMulticastGroupResponse {
+    
+    const filterSensitiveLog: (obj: SendDataToMulticastGroupResponse) => any;
+}
+export declare enum MessageType {
+    CUSTOM_COMMAND_ID_GET = "CUSTOM_COMMAND_ID_GET",
+    CUSTOM_COMMAND_ID_NOTIFY = "CUSTOM_COMMAND_ID_NOTIFY",
+    CUSTOM_COMMAND_ID_RESP = "CUSTOM_COMMAND_ID_RESP",
+    CUSTOM_COMMAND_ID_SET = "CUSTOM_COMMAND_ID_SET"
+}
+
+export interface SidewalkSendDataToDevice {
+    
+    Seq?: number;
+    
+    MessageType?: MessageType | string;
+}
+export declare namespace SidewalkSendDataToDevice {
+    
+    const filterSensitiveLog: (obj: SidewalkSendDataToDevice) => any;
+}
+
+export interface WirelessMetadata {
+    
+    LoRaWAN?: LoRaWANSendDataToDevice;
+    
+    Sidewalk?: SidewalkSendDataToDevice;
+}
+export declare namespace WirelessMetadata {
+    
+    const filterSensitiveLog: (obj: WirelessMetadata) => any;
+}
+export interface SendDataToWirelessDeviceRequest {
+    
+    Id: string | undefined;
+    
+    TransmitMode: number | undefined;
+    
+    PayloadData: string | undefined;
+    
+    WirelessMetadata?: WirelessMetadata;
+}
+export declare namespace SendDataToWirelessDeviceRequest {
+    
+    const filterSensitiveLog: (obj: SendDataToWirelessDeviceRequest) => any;
+}
+export interface SendDataToWirelessDeviceResponse {
+    
+    MessageId?: string;
+}
+export declare namespace SendDataToWirelessDeviceResponse {
+    
+    const filterSensitiveLog: (obj: SendDataToWirelessDeviceResponse) => any;
+}
+export interface StartBulkAssociateWirelessDeviceWithMulticastGroupRequest {
+    
+    Id: string | undefined;
+    
+    QueryString?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace StartBulkAssociateWirelessDeviceWithMulticastGroupRequest {
+    
+    const filterSensitiveLog: (obj: StartBulkAssociateWirelessDeviceWithMulticastGroupRequest) => any;
+}
+export interface StartBulkAssociateWirelessDeviceWithMulticastGroupResponse {
+}
+export declare namespace StartBulkAssociateWirelessDeviceWithMulticastGroupResponse {
+    
+    const filterSensitiveLog: (obj: StartBulkAssociateWirelessDeviceWithMulticastGroupResponse) => any;
+}
+export interface StartBulkDisassociateWirelessDeviceFromMulticastGroupRequest {
+    
+    Id: string | undefined;
+    
+    QueryString?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace StartBulkDisassociateWirelessDeviceFromMulticastGroupRequest {
+    
+    const filterSensitiveLog: (obj: StartBulkDisassociateWirelessDeviceFromMulticastGroupRequest) => any;
+}
+export interface StartBulkDisassociateWirelessDeviceFromMulticastGroupResponse {
+}
+export declare namespace StartBulkDisassociateWirelessDeviceFromMulticastGroupResponse {
+    
+    const filterSensitiveLog: (obj: StartBulkDisassociateWirelessDeviceFromMulticastGroupResponse) => any;
+}
+
+export interface LoRaWANStartFuotaTask {
+    
+    StartTime?: Date;
+}
+export declare namespace LoRaWANStartFuotaTask {
+    
+    const filterSensitiveLog: (obj: LoRaWANStartFuotaTask) => any;
+}
+export interface StartFuotaTaskRequest {
+    
+    Id: string | undefined;
+    
+    LoRaWAN?: LoRaWANStartFuotaTask;
+}
+export declare namespace StartFuotaTaskRequest {
+    
+    const filterSensitiveLog: (obj: StartFuotaTaskRequest) => any;
+}
+export interface StartFuotaTaskResponse {
+}
+export declare namespace StartFuotaTaskResponse {
+    
+    const filterSensitiveLog: (obj: StartFuotaTaskResponse) => any;
+}
+export interface StartMulticastGroupSessionRequest {
+    
+    Id: string | undefined;
+    
+    LoRaWAN: LoRaWANMulticastSession | undefined;
+}
+export declare namespace StartMulticastGroupSessionRequest {
+    
+    const filterSensitiveLog: (obj: StartMulticastGroupSessionRequest) => any;
+}
+export interface StartMulticastGroupSessionResponse {
+}
+export declare namespace StartMulticastGroupSessionResponse {
+    
+    const filterSensitiveLog: (obj: StartMulticastGroupSessionResponse) => any;
+}
+export interface TagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+
+export interface TooManyTagsException extends __SmithyException, $MetadataBearer {
+    name: "TooManyTagsException";
+    $fault: "client";
+    Message?: string;
+    
+    ResourceName?: string;
+}
+export interface TestWirelessDeviceRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace TestWirelessDeviceRequest {
+    
+    const filterSensitiveLog: (obj: TestWirelessDeviceRequest) => any;
+}
+export interface TestWirelessDeviceResponse {
+    
+    Result?: string;
+}
+export declare namespace TestWirelessDeviceResponse {
+    
+    const filterSensitiveLog: (obj: TestWirelessDeviceResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+export interface UpdateDestinationRequest {
+    
+    Name: string | undefined;
+    
+    ExpressionType?: ExpressionType | string;
+    
+    Expression?: string;
+    
+    Description?: string;
+    
+    RoleArn?: string;
+}
+export declare namespace UpdateDestinationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateDestinationRequest) => any;
+}
+export interface UpdateDestinationResponse {
+}
+export declare namespace UpdateDestinationResponse {
+    
+    const filterSensitiveLog: (obj: UpdateDestinationResponse) => any;
+}
+export interface UpdateFuotaTaskRequest {
+    
+    Id: string | undefined;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    LoRaWAN?: LoRaWANFuotaTask;
+    
+    FirmwareUpdateImage?: string;
+    
+    FirmwareUpdateRole?: string;
+}
+export declare namespace UpdateFuotaTaskRequest {
+    
+    const filterSensitiveLog: (obj: UpdateFuotaTaskRequest) => any;
+}
+export interface UpdateFuotaTaskResponse {
+}
+export declare namespace UpdateFuotaTaskResponse {
+    
+    const filterSensitiveLog: (obj: UpdateFuotaTaskResponse) => any;
+}
+export interface UpdateLogLevelsByResourceTypesRequest {
+    
+    DefaultLogLevel?: LogLevel | string;
+    
+    WirelessDeviceLogOptions?: WirelessDeviceLogOption[];
+    
+    WirelessGatewayLogOptions?: WirelessGatewayLogOption[];
+}
+export declare namespace UpdateLogLevelsByResourceTypesRequest {
+    
+    const filterSensitiveLog: (obj: UpdateLogLevelsByResourceTypesRequest) => any;
+}
+export interface UpdateLogLevelsByResourceTypesResponse {
+}
+export declare namespace UpdateLogLevelsByResourceTypesResponse {
+    
+    const filterSensitiveLog: (obj: UpdateLogLevelsByResourceTypesResponse) => any;
+}
+export interface UpdateMulticastGroupRequest {
+    
+    Id: string | undefined;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    LoRaWAN?: LoRaWANMulticast;
+}
+export declare namespace UpdateMulticastGroupRequest {
+    
+    const filterSensitiveLog: (obj: UpdateMulticastGroupRequest) => any;
+}
+export interface UpdateMulticastGroupResponse {
+}
+export declare namespace UpdateMulticastGroupResponse {
+    
+    const filterSensitiveLog: (obj: UpdateMulticastGroupResponse) => any;
+}
+export interface UpdateNetworkAnalyzerConfigurationRequest {
+    
+    ConfigurationName: string | undefined;
+    
+    TraceContent?: TraceContent;
+    
+    WirelessDevicesToAdd?: string[];
+    
+    WirelessDevicesToRemove?: string[];
+    
+    WirelessGatewaysToAdd?: string[];
+    
+    WirelessGatewaysToRemove?: string[];
+}
+export declare namespace UpdateNetworkAnalyzerConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateNetworkAnalyzerConfigurationRequest) => any;
+}
+export interface UpdateNetworkAnalyzerConfigurationResponse {
+}
+export declare namespace UpdateNetworkAnalyzerConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: UpdateNetworkAnalyzerConfigurationResponse) => any;
+}
+
+export interface SidewalkUpdateAccount {
+    
+    AppServerPrivateKey?: string;
+}
+export declare namespace SidewalkUpdateAccount {
+    
+    const filterSensitiveLog: (obj: SidewalkUpdateAccount) => any;
+}
+export interface UpdatePartnerAccountRequest {
+    
+    Sidewalk: SidewalkUpdateAccount | undefined;
+    
+    PartnerAccountId: string | undefined;
+    
+    PartnerType: PartnerType | string | undefined;
+}
+export declare namespace UpdatePartnerAccountRequest {
+    
+    const filterSensitiveLog: (obj: UpdatePartnerAccountRequest) => any;
+}
+export interface UpdatePartnerAccountResponse {
+}
+export declare namespace UpdatePartnerAccountResponse {
+    
+    const filterSensitiveLog: (obj: UpdatePartnerAccountResponse) => any;
+}
+export interface UpdateResourceEventConfigurationRequest {
+    
+    Identifier: string | undefined;
+    
+    IdentifierType: IdentifierType | string | undefined;
+    
+    PartnerType?: EventNotificationPartnerType | string;
+    
+    DeviceRegistrationState?: DeviceRegistrationStateEventConfiguration;
+    
+    Proximity?: ProximityEventConfiguration;
+}
+export declare namespace UpdateResourceEventConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateResourceEventConfigurationRequest) => any;
+}
+export interface UpdateResourceEventConfigurationResponse {
+}
+export declare namespace UpdateResourceEventConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: UpdateResourceEventConfigurationResponse) => any;
+}
+
+export interface LoRaWANUpdateDevice {
+    
+    DeviceProfileId?: string;
+    
+    ServiceProfileId?: string;
+}
+export declare namespace LoRaWANUpdateDevice {
+    
+    const filterSensitiveLog: (obj: LoRaWANUpdateDevice) => any;
+}
+export interface UpdateWirelessDeviceRequest {
+    
+    Id: string | undefined;
+    
+    DestinationName?: string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    LoRaWAN?: LoRaWANUpdateDevice;
+}
+export declare namespace UpdateWirelessDeviceRequest {
+    
+    const filterSensitiveLog: (obj: UpdateWirelessDeviceRequest) => any;
+}
+export interface UpdateWirelessDeviceResponse {
+}
+export declare namespace UpdateWirelessDeviceResponse {
+    
+    const filterSensitiveLog: (obj: UpdateWirelessDeviceResponse) => any;
+}
+export interface UpdateWirelessGatewayRequest {
+    
+    Id: string | undefined;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    JoinEuiFilters?: string[][];
+    
+    NetIdFilters?: string[];
+}
+export declare namespace UpdateWirelessGatewayRequest {
+    
+    const filterSensitiveLog: (obj: UpdateWirelessGatewayRequest) => any;
+}
+export interface UpdateWirelessGatewayResponse {
+}
+export declare namespace UpdateWirelessGatewayResponse {
+    
+    const filterSensitiveLog: (obj: UpdateWirelessGatewayResponse) => any;
+}