/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the Source EULA. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

import * as nls from 'vscode-nls';
const localize = nls.loadMessageBundle();

// Labels
export const OkButtonText: string = localize('schemaCompareDialog.ok', "OK");
export const CancelButtonText: string = localize('schemaCompareDialog.cancel', "Cancel");
export const SourceTitle: string = localize('schemaCompareDialog.SourceTitle', "Source");
export const TargetTitle: string = localize('schemaCompareDialog.TargetTitle', "Target");
export const FileTextBoxLabel: string = localize('schemaCompareDialog.fileTextBoxLabel', "File");
export const DacpacRadioButtonLabel: string = localize('schemaCompare.dacpacRadioButtonLabel', "Data-tier Application File (.dacpac)");
export const DatabaseRadioButtonLabel: string = localize('schemaCompare.databaseButtonLabel', "Database");
export const RadioButtonsLabel: string = localize('schemaCompare.radioButtonsLabel', "Type");
export const ServerDropdownLabel: string = localize('schemaCompareDialog.serverDropdownTitle', "Server");
export const DatabaseDropdownLabel: string = localize('schemaCompareDialog.databaseDropdownTitle', "Database");
export const NoActiveConnectionsLabel: string = localize('schemaCompare.noActiveConnectionsText', "No active connections");
export const SchemaCompareLabel: string = localize('schemaCompare.dialogTitle', "Schema Compare");
export const differentSourceMessage: string = localize('schemaCompareDialog.differentSourceMessage', "A different source schema has been selected. Compare to see the comparison?");
export const differentTargetMessage: string = localize('schemaCompareDialog.differentTargetMessage', "A different target schema has been selected. Compare to see the comparison?");
export const differentSourceTargetMessage: string = localize('schemaCompareDialog.differentSourceTargetMessage', "Different source and target schemas have been selected. Compare to see the comparison?");
export const YesButtonText: string = localize('schemaCompareDialog.Yes', "Yes");
export const NoButtonText: string = localize('schemaCompareDialog.No', "No");
export const sourceFile: string = localize('schemaCompareDialog.sourceTextBox', "Source file");
export const targetFile: string = localize('schemaCompareDialog.targetTextBox', "Target file");
export const sourceDatabase: string = localize('schemaCompareDialog.sourceDatabaseDropdown', "Source Database");
export const targetDatabase: string = localize('schemaCompareDialog.targetDatabaseDropdown', "Target Database");
export const sourceServer: string = localize('schemaCompareDialog.sourceServerDropdown', "Source Server");
export const targetServer: string = localize('schemaCompareDialog.targetServerDropdown', "Target Server");
export const defaultText: string = localize('schemaCompareDialog.defaultUser', "default");
export const open: string = localize('schemaCompare.openFile', "Open");
export const selectSourceFile: string = localize('schemaCompare.selectSourceFile', "Select source file");
export const selectTargetFile: string = localize('schemaCompare.selectTargetFile', "Select target file");
export const ResetButtonText: string = localize('SchemaCompareOptionsDialog.Reset', "Reset");
export const OptionsChangedMessage: string = localize('schemaCompareOptions.RecompareMessage', "Options have changed. Recompare to see the comparison?");
export const OptionsLabel: string = localize('SchemaCompare.SchemaCompareOptionsDialogLabel', "Schema Compare Options");
export const GeneralOptionsLabel: string = localize('SchemaCompare.GeneralOptionsLabel', "General Options");
export const ObjectTypesOptionsLabel: string = localize('SchemaCompare.ObjectTypesOptionsLabel', "Include Object Types");
export const diffEditorTitle: string = localize('schemaCompare.CompareDetailsTitle', "Compare Details");
export const applyConfirmation: string = localize('schemaCompare.ApplyConfirmation', "Are you sure you want to update the target?");
export const reCompareToRefeshMessage: string = localize('schemaCompare.RecompareToRefresh', "Press Compare to refresh the comparison.");
export const generateScriptEnabledMessage: string = localize('schemaCompare.generateScriptEnabledButton', "Generate script to deploy changes to target");
export const generateScriptNoChangesMessage: string = localize('schemaCompare.generateScriptNoChanges', "No changes to script");
export const applyEnabledMessage: string = localize('schemaCompare.applyButtonEnabledTitle', "Apply changes to target");
export const applyNoChangesMessage: string = localize('schemaCompare.applyNoChanges', "No changes to apply");
export const includeExcludeInfoMessage: string = localize('schemaCompare.includeExcludeInfoMessage', "Please note that include/exclude operations can take a moment to calculate affected dependencies");
export const sourceTitle: string = localize('schemaCompareDialog.SourceTitle', "Source");
export const targetTitle: string = localize('schemaCompareDialog.TargetTitle', "Target");
export const deleteAction: string = localize('schemaCompare.deleteAction', "Delete");
export const changeAction: string = localize('schemaCompare.changeAction', "Change");
export const addAction: string = localize('schemaCompare.addAction', "Add");
export const differencesTableTitle: string = localize('schemaCompare.differencesTableTitle', "Comparison between Source and Target");
export const waitText: string = localize('schemaCompare.waitText', "Initializing Comparison. This might take a moment.");
export const startText: string = localize('schemaCompare.startText', "To compare two schemas, first select a source schema and target schema, then press Compare.");
export const noDifferencesText: string = localize('schemaCompare.noDifferences', "No schema differences were found.");
export const type: string = localize('schemaCompare.typeColumn', "Type");
export const sourceName: string = localize('schemaCompare.sourceNameColumn', "Source Name");
export const include: string = localize('schemaCompare.includeColumnName', "Include");
export const action: string = localize('schemaCompare.actionColumn', "Action");
export const targetName: string = localize('schemaCompare.targetNameColumn', "Target Name");
export const generateScriptDisabled: string = localize('schemaCompare.generateScriptButtonDisabledTitle', "Generate script is enabled when the target is a database");
export const applyDisabled: string = localize('schemaCompare.applyButtonDisabledTitle', "Apply is enabled when the target is a database");
export function cannotExcludeMessageDependent(diffEntryName: string, firstDependentName: string): string { return localize('schemaCompare.cannotExcludeMessageWithDependent', "Cannot exclude {0}. Included dependents exist, such as {1}", diffEntryName, firstDependentName); }
export function cannotIncludeMessageDependent(diffEntryName: string, firstDependentName: string): string { return localize('schemaCompare.cannotIncludeMessageWithDependent', "Cannot include {0}. Excluded dependents exist, such as {1}", diffEntryName, firstDependentName); }
export function cannotExcludeMessage(diffEntryName: string): string { return localize('schemaCompare.cannotExcludeMessage', "Cannot exclude {0}. Included dependents exist", diffEntryName); }
export function cannotIncludeMessage(diffEntryName: string): string { return localize('schemaCompare.cannotIncludeMessage', "Cannot include {0}. Excluded dependents exist", diffEntryName); }
export const compare: string = localize('schemaCompare.compareButton', "Compare");
export const stop: string = localize('schemaCompare.cancelCompareButton', "Stop");
export const generateScript: string = localize('schemaCompare.generateScriptButton', "Generate script");
export const options: string = localize('schemaCompare.optionsButton', "Options");
export const apply: string = localize('schemaCompare.updateButton', "Apply");
export const switchDirection: string = localize('schemaCompare.switchDirectionButton', "Switch direction");
export const switchDirectionDescription: string = localize('schemaCompare.switchButtonTitle', "Switch source and target");
export const selectSource: string = localize('schemaCompare.sourceButtonTitle', "Select Source");
export const selectTarget: string = localize('schemaCompare.targetButtonTitle', "Select Target");
export const openScmp: string = localize('schemaCompare.openScmpButton', "Open .scmp file");
export const openScmpDescription: string = localize('schemaCompare.openScmpButtonTitle', "Load source, target, and options saved in an .scmp file");
export const saveScmp: string = localize('schemaCompare.saveScmpButton', "Save .scmp file");
export const saveScmpDescription: string = localize('schemaCompare.saveScmpButtonTitle', "Save source and target, options, and excluded elements");
export const save: string = localize('schemaCompare.saveFile', "Save");
export function getConnectionString(caller: string): string { return localize('schemaCompare.GetConnectionString', "Do you want to connect to {0}?", caller); }

// options
export const IgnoreTableOptions: string = localize('SchemaCompare.IgnoreTableOptions', "Ignore Table Options");
export const IgnoreSemicolonBetweenStatements: string = localize('SchemaCompare.IgnoreSemicolonBetweenStatements', "Ignore Semicolon Between Statements");
export const IgnoreRouteLifetime: string = localize('SchemaCompare.IgnoreRouteLifetime', "Ignore Route Lifetime");
export const IgnoreRoleMembership: string = localize('SchemaCompare.IgnoreRoleMembership', "Ignore Role Membership");
export const IgnoreQuotedIdentifiers: string = localize('SchemaCompare.IgnoreQuotedIdentifiers', "Ignore Quoted Identifiers");
export const IgnorePermissions: string = localize('SchemaCompare.IgnorePermissions', "Ignore Permissions");
export const IgnorePartitionSchemes: string = localize('SchemaCompare.IgnorePartitionSchemes', "Ignore Partition Schemes");
export const IgnoreObjectPlacementOnPartitionScheme: string = localize('SchemaCompare.IgnoreObjectPlacementOnPartitionScheme', "Ignore Object Placement On Partition Scheme");
export const IgnoreNotForReplication: string = localize('SchemaCompare.IgnoreNotForReplication', "Ignore Not For Replication");
export const IgnoreLoginSids: string = localize('SchemaCompare.IgnoreLoginSids', "Ignore Login Sids");
export const IgnoreLockHintsOnIndexes: string = localize('SchemaCompare.IgnoreLockHintsOnIndexes', "Ignore Lock Hints On Indexes");
export const IgnoreKeywordCasing: string = localize('SchemaCompare.IgnoreKeywordCasing', "Ignore Keyword Casing");
export const IgnoreIndexPadding: string = localize('SchemaCompare.IgnoreIndexPadding', "Ignore Index Padding");
export const IgnoreIndexOptions: string = localize('SchemaCompare.IgnoreIndexOptions', "Ignore Index Options");
export const IgnoreIncrement: string = localize('SchemaCompare.IgnoreIncrement', "Ignore Increment");
export const IgnoreIdentitySeed: string = localize('SchemaCompare.IgnoreIdentitySeed', "Ignore Identity Seed");
export const IgnoreUserSettingsObjects: string = localize('SchemaCompare.IgnoreUserSettingsObjects', "Ignore User Settings Objects");
export const IgnoreFullTextCatalogFilePath: string = localize('SchemaCompare.IgnoreFullTextCatalogFilePath', "Ignore Full Text Catalog FilePath");
export const IgnoreWhitespace: string = localize('SchemaCompare.IgnoreWhitespace', "Ignore Whitespace");
export const IgnoreWithNocheckOnForeignKeys: string = localize('SchemaCompare.IgnoreWithNocheckOnForeignKeys', "Ignore With Nocheck On ForeignKeys");
export const VerifyCollationCompatibility: string = localize('SchemaCompare.VerifyCollationCompatibility', "Verify Collation Compatibility");
export const UnmodifiableObjectWarnings: string = localize('SchemaCompare.UnmodifiableObjectWarnings', "Unmodifiable Object Warnings");
export const TreatVerificationErrorsAsWarnings: string = localize('SchemaCompare.TreatVerificationErrorsAsWarnings', "Treat Verification Errors As Warnings");
export const ScriptRefreshModule: string = localize('SchemaCompare.ScriptRefreshModule', "Script Refresh Module");
export const ScriptNewConstraintValidation: string = localize('SchemaCompare.ScriptNewConstraintValidation', "Script New Constraint Validation");
export const ScriptFileSize: string = localize('SchemaCompare.ScriptFileSize', "Script File Size");
export const ScriptDeployStateChecks: string = localize('SchemaCompare.ScriptDeployStateChecks', "Script Deploy StateChecks");
export const ScriptDatabaseOptions: string = localize('SchemaCompare.ScriptDatabaseOptions', "Script Database Options");
export const ScriptDatabaseCompatibility: string = localize('SchemaCompare.ScriptDatabaseCompatibility', "Script Database Compatibility");
export const ScriptDatabaseCollation: string = localize('SchemaCompare.ScriptDatabaseCollation', "Script Database Collation");
export const RunDeploymentPlanExecutors: string = localize('SchemaCompare.RunDeploymentPlanExecutors', "Run Deployment Plan Executors");
export const RegisterDataTierApplication: string = localize('SchemaCompare.RegisterDataTierApplication', "Register DataTier Application");
export const PopulateFilesOnFileGroups: string = localize('SchemaCompare.PopulateFilesOnFileGroups', "Populate Files On File Groups");
export const NoAlterStatementsToChangeClrTypes: string = localize('SchemaCompare.NoAlterStatementsToChangeClrTypes', "No Alter Statements To Change Clr Types");
export const IncludeTransactionalScripts: string = localize('SchemaCompare.IncludeTransactionalScripts', "Include Transactional Scripts");
export const IncludeCompositeObjects: string = localize('SchemaCompare.IncludeCompositeObjects', "Include Composite Objects");
export const AllowUnsafeRowLevelSecurityDataMovement: string = localize('SchemaCompare.AllowUnsafeRowLevelSecurityDataMovement', "Allow Unsafe Row Level Security Data Movement");
export const IgnoreWithNocheckOnCheckConstraints: string = localize('SchemaCompare.IgnoreWithNocheckOnCheckConstraints', "Ignore With No check On Check Constraints");
export const IgnoreFillFactor: string = localize('SchemaCompare.IgnoreFillFactor', "Ignore Fill Factor");
export const IgnoreFileSize: string = localize('SchemaCompare.IgnoreFileSize', "Ignore File Size");
export const IgnoreFilegroupPlacement: string = localize('SchemaCompare.IgnoreFilegroupPlacement', "Ignore Filegroup Placement");
export const DoNotAlterReplicatedObjects: string = localize('SchemaCompare.DoNotAlterReplicatedObjects', "Do Not Alter Replicated Objects");
export const DoNotAlterChangeDataCaptureObjects: string = localize('SchemaCompare.DoNotAlterChangeDataCaptureObjects', "Do Not Alter Change Data Capture Objects");
export const DisableAndReenableDdlTriggers: string = localize('SchemaCompare.DisableAndReenableDdlTriggers', "Disable And Reenable Ddl Triggers");
export const DeployDatabaseInSingleUserMode: string = localize('SchemaCompare.DeployDatabaseInSingleUserMode', "Deploy Database In Single User Mode");
export const CreateNewDatabase: string = localize('SchemaCompare.CreateNewDatabase', "Create New Database");
export const CompareUsingTargetCollation: string = localize('SchemaCompare.CompareUsingTargetCollation', "Compare Using Target Collation");
export const CommentOutSetVarDeclarations: string = localize('SchemaCompare.CommentOutSetVarDeclarations', "Comment Out Set Var Declarations");
export const BlockWhenDriftDetected: string = localize('SchemaCompare.BlockWhenDriftDetected', "Block When Drift Detected");
export const BlockOnPossibleDataLoss: string = localize('SchemaCompare.BlockOnPossibleDataLoss', "Block On Possible Data Loss");
export const BackupDatabaseBeforeChanges: string = localize('SchemaCompare.BackupDatabaseBeforeChanges', "Backup Database Before Changes");
export const AllowIncompatiblePlatform: string = localize('SchemaCompare.AllowIncompatiblePlatform', "Allow Incompatible Platform");
export const AllowDropBlockingAssemblies: string = localize('SchemaCompare.AllowDropBlockingAssemblies', "Allow Drop Blocking Assemblies");
export const DropConstraintsNotInSource: string = localize('SchemaCompare.DropConstraintsNotInSource', "Drop Constraints Not In Source");
export const DropDmlTriggersNotInSource: string = localize('SchemaCompare.DropDmlTriggersNotInSource', "Drop Dml Triggers Not In Source");
export const DropExtendedPropertiesNotInSource: string = localize('SchemaCompare.DropExtendedPropertiesNotInSource', "Drop Extended Properties Not In Source");
export const DropIndexesNotInSource: string = localize('SchemaCompare.DropIndexesNotInSource', "Drop Indexes Not In Source");
export const IgnoreFileAndLogFilePath: string = localize('SchemaCompare.IgnoreFileAndLogFilePath', "Ignore File And Log File Path");
export const IgnoreExtendedProperties: string = localize('SchemaCompare.IgnoreExtendedProperties', "Ignore Extended Properties");
export const IgnoreDmlTriggerState: string = localize('SchemaCompare.IgnoreDmlTriggerState', "Ignore Dml Trigger State");
export const IgnoreDmlTriggerOrder: string = localize('SchemaCompare.IgnoreDmlTriggerOrder', "Ignore Dml Trigger Order");
export const IgnoreDefaultSchema: string = localize('SchemaCompare.IgnoreDefaultSchema', "Ignore Default Schema");
export const IgnoreDdlTriggerState: string = localize('SchemaCompare.IgnoreDdlTriggerState', "Ignore Ddl Trigger State");
export const IgnoreDdlTriggerOrder: string = localize('SchemaCompare.IgnoreDdlTriggerOrder', "Ignore Ddl Trigger Order");
export const IgnoreCryptographicProviderFilePath: string = localize('SchemaCompare.IgnoreCryptographicProviderFilePath', "Ignore Cryptographic Provider FilePath");
export const VerifyDeployment: string = localize('SchemaCompare.VerifyDeployment', "Verify Deployment");
export const IgnoreComments: string = localize('SchemaCompare.IgnoreComments', "Ignore Comments");
export const IgnoreColumnCollation: string = localize('SchemaCompare.IgnoreColumnCollation', "Ignore Column Collation");
export const IgnoreAuthorizer: string = localize('SchemaCompare.IgnoreAuthorizer', "Ignore Authorizer");
export const IgnoreAnsiNulls: string = localize('SchemaCompare.IgnoreAnsiNulls', "Ignore AnsiNulls");
export const GenerateSmartDefaults: string = localize('SchemaCompare.GenerateSmartDefaults', "Generate SmartDefaults");
export const DropStatisticsNotInSource: string = localize('SchemaCompare.DropStatisticsNotInSource', "Drop Statistics Not In Source");
export const DropRoleMembersNotInSource: string = localize('SchemaCompare.DropRoleMembersNotInSource', "Drop Role Members Not In Source");
export const DropPermissionsNotInSource: string = localize('SchemaCompare.DropPermissionsNotInSource', "Drop Permissions Not In Source");
export const DropObjectsNotInSource: string = localize('SchemaCompare.DropObjectsNotInSource', "Drop Objects Not In Source");
export const IgnoreColumnOrder: string = localize('SchemaCompare.IgnoreColumnOrder', "Ignore Column Order");

// object types
export const Aggregates: string = localize('SchemaCompare.Aggregates', "Aggregates");
export const ApplicationRoles: string = localize('SchemaCompare.ApplicationRoles', "Application Roles");
export const Assemblies: string = localize('SchemaCompare.Assemblies', "Assemblies");
export const AssemblyFiles: string = localize('SchemaCompare.AssemblyFiles', "Assembly Files");
export const AsymmetricKeys: string = localize('SchemaCompare.AsymmetricKeys', "Asymmetric Keys");
export const BrokerPriorities: string = localize('SchemaCompare.BrokerPriorities', "Broker Priorities");
export const Certificates: string = localize('SchemaCompare.Certificates', "Certificates");
export const ColumnEncryptionKeys: string = localize('SchemaCompare.ColumnEncryptionKeys', "Column Encryption Keys");
export const ColumnMasterKeys: string = localize('SchemaCompare.ColumnMasterKeys', "Column Master Keys");
export const Contracts: string = localize('SchemaCompare.Contracts', "Contracts");
export const DatabaseOptions: string = localize('SchemaCompare.DatabaseOptions', "Database Options");
export const DatabaseRoles: string = localize('SchemaCompare.DatabaseRoles', "Database Roles");
export const DatabaseTriggers: string = localize('SchemaCompare.DatabaseTriggers', "DatabaseTriggers");
export const Defaults: string = localize('SchemaCompare.Defaults', "Defaults");
export const ExtendedProperties: string = localize('SchemaCompare.ExtendedProperties', "Extended Properties");
export const ExternalDataSources: string = localize('SchemaCompare.ExternalDataSources', "External Data Sources");
export const ExternalFileFormats: string = localize('SchemaCompare.ExternalFileFormats', "External File Formats");
export const ExternalTables: string = localize('SchemaCompare.ExternalTables', "External Tables");
export const Filegroups: string = localize('SchemaCompare.Filegroups', "Filegroups");
export const Files: string = localize('SchemaCompare.Files', "Files");
export const FileTables: string = localize('SchemaCompare.FileTables', "File Tables");
export const FullTextCatalogs: string = localize('SchemaCompare.FullTextCatalogs', "Full Text Catalogs");
export const FullTextStoplists: string = localize('SchemaCompare.FullTextStoplists', "Full Text Stoplists");
export const MessageTypes: string = localize('SchemaCompare.MessageTypes', "Message Types");
export const PartitionFunctions: string = localize('SchemaCompare.PartitionFunctions', "Partition Functions");
export const PartitionSchemes: string = localize('SchemaCompare.PartitionSchemes', "Partition Schemes");
export const Permissions: string = localize('SchemaCompare.Permissions', "Permissions");
export const Queues: string = localize('SchemaCompare.Queues', "Queues");
export const RemoteServiceBindings: string = localize('SchemaCompare.RemoteServiceBindings', "Remote Service Bindings");
export const RoleMembership: string = localize('SchemaCompare.RoleMembership', "Role Membership");
export const Rules: string = localize('SchemaCompare.Rules', "Rules");
export const ScalarValuedFunctions: string = localize('SchemaCompare.ScalarValuedFunctions', "Scalar Valued Functions");
export const SearchPropertyLists: string = localize('SchemaCompare.SearchPropertyLists', "Search Property Lists");
export const SecurityPolicies: string = localize('SchemaCompare.SecurityPolicies', "Security Policies");
export const Sequences: string = localize('SchemaCompare.Sequences', "Sequences");
export const Services: string = localize('SchemaCompare.Services', "Services");
export const Signatures: string = localize('SchemaCompare.Signatures', "Signatures");
export const StoredProcedures: string = localize('SchemaCompare.StoredProcedures', "StoredProcedures");
export const SymmetricKeys: string = localize('SchemaCompare.SymmetricKeys', "SymmetricKeys");
export const Synonyms: string = localize('SchemaCompare.Synonyms', "Synonyms");
export const Tables: string = localize('SchemaCompare.Tables', "Tables");
export const TableValuedFunctions: string = localize('SchemaCompare.TableValuedFunctions', "Table Valued Functions");
export const UserDefinedDataTypes: string = localize('SchemaCompare.UserDefinedDataTypes', "User Defined Data Types");
export const UserDefinedTableTypes: string = localize('SchemaCompare.UserDefinedTableTypes', "User Defined Table Types");
export const ClrUserDefinedTypes: string = localize('SchemaCompare.ClrUserDefinedTypes', "Clr User Defined Types");
export const Users: string = localize('SchemaCompare.Users', "Users");
export const Views: string = localize('SchemaCompare.Views', "Views");
export const XmlSchemaCollections: string = localize('SchemaCompare.XmlSchemaCollections', "Xml Schema Collections");
export const Audits: string = localize('SchemaCompare.Audits', "Audits");
export const Credentials: string = localize('SchemaCompare.Credentials', "Credentials");
export const CryptographicProviders: string = localize('SchemaCompare.CryptographicProviders', "Cryptographic Providers");
export const DatabaseAuditSpecifications: string = localize('SchemaCompare.DatabaseAuditSpecifications', "Database Audit Specifications");
export const DatabaseEncryptionKeys: string = localize('SchemaCompare.DatabaseEncryptionKeys', "Database Encryption Keys");
export const DatabaseScopedCredentials: string = localize('SchemaCompare.DatabaseScopedCredentials', "Database Scoped Credentials");
export const Endpoints: string = localize('SchemaCompare.Endpoints', "Endpoints");
export const ErrorMessages: string = localize('SchemaCompare.ErrorMessages', "Error Messages");
export const EventNotifications: string = localize('SchemaCompare.EventNotifications', "Event Notifications");
export const EventSessions: string = localize('SchemaCompare.EventSessions', "Event Sessions");
export const LinkedServerLogins: string = localize('SchemaCompare.LinkedServerLogins', "Linked Server Logins");
export const LinkedServers: string = localize('SchemaCompare.LinkedServers', "Linked Servers");
export const Logins: string = localize('SchemaCompare.Logins', "Logins");
export const MasterKeys: string = localize('SchemaCompare.MasterKeys', "Master Keys");
export const Routes: string = localize('SchemaCompare.Routes', "Routes");
export const ServerAuditSpecifications: string = localize('SchemaCompare.ServerAuditSpecifications', "Server Audit Specifications");
export const ServerRoleMembership: string = localize('SchemaCompare.ServerRoleMembership', "Server Role Membership");
export const ServerRoles: string = localize('SchemaCompare.ServerRoles', "Server Roles");
export const ServerTriggers: string = localize('SchemaCompare.ServerTriggers', "Server Triggers");

// options descriptions
export const descriptionIgnoreTableOptions: string = localize('SchemaCompare.Description.IgnoreTableOptions', "Specifies whether differences in the table options will be ignored or updated when you publish to a database.");
export const descriptionIgnoreSemicolonBetweenStatements: string = localize('SchemaCompare.Description.IgnoreSemicolonBetweenStatements', "Specifies whether differences in the semi-colons between T-SQL statements will be ignored or updated when you publish to a database.");
export const descriptionIgnoreRouteLifetime: string = localize('SchemaCompare.Description.IgnoreRouteLifetime', "Specifies whether differences in the amount of time that SQL Server retains the route in the routing table should be ignored or updated when you publish to a database.");
export const descriptionIgnoreRoleMembership: string = localize('SchemaCompare.Description.IgnoreRoleMembership', "Specifies whether differences in the role membership of logins should be ignored or updated when you publish to a database.");
export const descriptionIgnoreQuotedIdentifiers: string = localize('SchemaCompare.Description.IgnoreQuotedIdentifiers', "Specifies whether differences in the quoted identifiers setting should be ignored or updated when you publish to a database.");
export const descriptionIgnorePermissions: string = localize('SchemaCompare.Description.IgnorePermissions', "Specifies whether permissions should be ignored.");
export const descriptionIgnorePartitionSchemes: string = localize('SchemaCompare.Description.IgnorePartitionSchemes', "Specifies whether differences in partition schemes and functions should be ignored or updated when you publish to a database.");
export const descriptionIgnoreObjectPlacementOnPartitionScheme: string = localize('SchemaCompare.Description.IgnoreObjectPlacementOnPartitionScheme', "Specifies whether an object\'s placement on a partition scheme should be ignored or updated when you publish to a database.");
export const descriptionIgnoreNotForReplication: string = localize('SchemaCompare.Description.IgnoreNotForReplication', "Specifies whether the not for replication settings should be ignored or updated when you publish to a database.");
export const descriptionIgnoreLoginSids: string = localize('SchemaCompare.Description.IgnoreLoginSids', "Specifies whether differences in the security identification number (SID) should be ignored or updated when you publish to a database.");
export const descriptionIgnoreLockHintsOnIndexes: string = localize('SchemaCompare.Description.IgnoreLockHintsOnIndexes', "Specifies whether differences in the lock hints on indexes should be ignored or updated when you publish to a database.");
export const descriptionIgnoreKeywordCasing: string = localize('SchemaCompare.Description.IgnoreKeywordCasing', "Specifies whether differences in the casing of keywords should be ignored or updated when you publish to a database.");
export const descriptionIgnoreIndexPadding: string = localize('SchemaCompare.Description.IgnoreIndexPadding', "Specifies whether differences in the index padding should be ignored or updated when you publish to a database.");
export const descriptionIgnoreIndexOptions: string = localize('SchemaCompare.Description.IgnoreIndexOptions', "Specifies whether differences in the index options should be ignored or updated when you publish to a database.");
export const descriptionIgnoreIncrement: string = localize('SchemaCompare.Description.IgnoreIncrement', "Specifies whether differences in the increment for an identity column should be ignored or updated when you publish to a database.");
export const descriptionIgnoreIdentitySeed: string = localize('SchemaCompare.Description.IgnoreIdentitySeed', "Specifies whether differences in the seed for an identity column should be ignored or updated when you publish updates to a database.");
export const descriptionIgnoreUserSettingsObjects: string = localize('SchemaCompare.Description.IgnoreUserSettingsObjects', "Specifies whether differences in the user settings objects will be ignored or updated when you publish to a database.");
export const descriptionIgnoreFullTextCatalogFilePath: string = localize('SchemaCompare.Description.IgnoreFullTextCatalogFilePath', "Specifies whether differences in the file path for the full-text catalog should be ignored or whether a warning should be issued when you publish to a database.");
export const descriptionIgnoreWhitespace: string = localize('SchemaCompare.Description.IgnoreWhitespace', "Specifies whether differences in white space will be ignored or updated when you publish to a database.");
export const descriptionIgnoreWithNocheckOnForeignKeys: string = localize('SchemaCompare.Description.IgnoreWithNocheckOnForeignKeys', "Specifies whether differences in the value of the WITH NOCHECK clause for foreign keys will be ignored or updated when you publish to a database.");
export const descriptionVerifyCollationCompatibility: string = localize('SchemaCompare.Description.VerifyCollationCompatibility', "Specifies whether collation compatibility is verified.");
export const descriptionUnmodifiableObjectWarnings: string = localize('SchemaCompare.Description.UnmodifiableObjectWarnings', "Specifies whether warnings should be generated when differences are found in objects that cannot be modified, for example, if the file size or file paths were different for a file.");
export const descriptionTreatVerificationErrorsAsWarnings: string = localize('SchemaCompare.Description.TreatVerificationErrorsAsWarnings', "Specifies whether errors encountered during publish verification should be treated as warnings. The check is performed against the generated deployment plan before the plan is executed against your target database. Plan verification detects problems such as the loss of target-only objects (such as indexes) that must be dropped to make a change. Verification will also detect situations where dependencies (such as a table or view) exist because of a reference to a composite project, but do not exist in the target database. You might choose to do this to get a complete list of all issues, instead of having the publish action stop on the first error.");
export const descriptionScriptRefreshModule: string = localize('SchemaCompare.Description.ScriptRefreshModule', "Include refresh statements at the end of the publish script.");
export const descriptionScriptNewConstraintValidation: string = localize('SchemaCompare.Description.ScriptNewConstraintValidation', "At the end of publish all of the constraints will be verified as one set, avoiding data errors caused by a check or foreign key constraint in the middle of publish. If set to False, your constraints will be published without checking the corresponding data.");
export const descriptionScriptFileSize: string = localize('SchemaCompare.Description.ScriptFileSize', "Controls whether size is specified when adding a file to a filegroup.");
export const descriptionScriptDeployStateChecks: string = localize('SchemaCompare.Description.ScriptDeployStateChecks', "Specifies whether statements are generated in the publish script to verify that the database name and server name match the names specified in the database project.");
export const descriptionScriptDatabaseOptions: string = localize('SchemaCompare.Description.ScriptDatabaseOptions', "Specifies whether target database properties should be set or updated as part of the publish action.");
export const descriptionScriptDatabaseCompatibility: string = localize('SchemaCompare.Description.ScriptDatabaseCompatibility', "Specifies whether differences in the database compatibility should be ignored or updated when you publish to a database.");
export const descriptionScriptDatabaseCollation: string = localize('SchemaCompare.Description.ScriptDatabaseCollation', "Specifies whether differences in the database collation should be ignored or updated when you publish to a database.");
export const descriptionRunDeploymentPlanExecutors: string = localize('SchemaCompare.Description.RunDeploymentPlanExecutors', "Specifies whether DeploymentPlanExecutor contributors should be run when other operations are executed.");
export const descriptionRegisterDataTierApplication: string = localize('SchemaCompare.Description.RegisterDataTierApplication', "Specifies whether the schema is registered with the database server.");
export const descriptionPopulateFilesOnFileGroups: string = localize('SchemaCompare.Description.PopulateFilesOnFileGroups', "Specifies whether a new file is also created when a new FileGroup is created in the target database.");
export const descriptionNoAlterStatementsToChangeClrTypes: string = localize('SchemaCompare.Description.NoAlterStatementsToChangeClrTypes', "Specifies that publish should always drop and re-create an assembly if there is a difference instead of issuing an ALTER ASSEMBLY statement");
export const descriptionIncludeTransactionalScripts: string = localize('SchemaCompare.Description.IncludeTransactionalScripts', "Specifies whether transactional statements should be used where possible when you publish to a database.");
export const descriptionIncludeCompositeObjects: string = localize('SchemaCompare.Description.IncludeCompositeObjects', "Include all composite elements as part of a single publish operation.");
export const descriptionAllowUnsafeRowLevelSecurityDataMovement: string = localize('SchemaCompare.Description.AllowUnsafeRowLevelSecurityDataMovement', "Do not block data motion on a table which has Row Level Security if this property is set to true. Default is false.");
export const descriptionIgnoreWithNocheckOnCheckConstraints: string = localize('SchemaCompare.Description.IgnoreWithNocheckOnCheckConstraints', "Specifies whether differences in the value of the WITH NOCHECK clause for check constraints will be ignored or updated when you publish to a database.");
export const descriptionIgnoreFillFactor: string = localize('SchemaCompare.Description.IgnoreFillFactor', "Specifies whether differences in the fill factor for index storage should be ignored or whether a warning should be issued when you publish to a database.");
export const descriptionIgnoreFileSize: string = localize('SchemaCompare.Description.IgnoreFileSize', "Specifies whether differences in the file sizes should be ignored or whether a warning should be issued when you publish to a database.");
export const descriptionIgnoreFilegroupPlacement: string = localize('SchemaCompare.Description.IgnoreFilegroupPlacement', "Specifies whether differences in the placement of objects in FILEGROUPs should be ignored or updated when you publish to a database.");
export const descriptionDoNotAlterReplicatedObjects: string = localize('SchemaCompare.Description.DoNotAlterReplicatedObjects', "Specifies whether objects that are replicated are identified during verification.");
export const descriptionDoNotAlterChangeDataCaptureObjects: string = localize('SchemaCompare.Description.DoNotAlterChangeDataCaptureObjects', "If true, Change Data Capture objects are not altered.");
export const descriptionDisableAndReenableDdlTriggers: string = localize('SchemaCompare.Description.DisableAndReenableDdlTriggers', "Specifies whether Data Definition Language (DDL) triggers are disabled at the beginning of the publish process and re-enabled at the end of the publish action.");
export const descriptionDeployDatabaseInSingleUserMode: string = localize('SchemaCompare.Description.DeployDatabaseInSingleUserMode', "If true, the database is set to Single User Mode before deploying.");
export const descriptionCreateNewDatabase: string = localize('SchemaCompare.Description.CreateNewDatabase', "Specifies whether the target database should be updated or whether it should be dropped and re-created when you publish to a database.");
export const descriptionCompareUsingTargetCollation: string = localize('SchemaCompare.Description.CompareUsingTargetCollation', "This setting dictates how the database\'s collation is handled during deployment; by default the target database\'s collation will be updated if it does not match the collation specified by the source.  When this option is set, the target database\'s (or server\'s) collation should be used.");
export const descriptionCommentOutSetVarDeclarations: string = localize('SchemaCompare.Description.CommentOutSetVarDeclarations', "Specifies whether the declaration of SETVAR variables should be commented out in the generated publish script. You might choose to do this if you plan to specify the values on the command line when you publish by using a tool such as SQLCMD.EXE.");
export const descriptionBlockWhenDriftDetected: string = localize('SchemaCompare.Description.BlockWhenDriftDetected', "Specifies whether to block updating a database whose schema no longer matches its registration or is unregistered.");
export const descriptionBlockOnPossibleDataLoss: string = localize('SchemaCompare.Description.BlockOnPossibleDataLoss', "Specifies that the publish episode should be terminated if there is a possibility of data loss resulting from the publish operation.");
export const descriptionBackupDatabaseBeforeChanges: string = localize('SchemaCompare.Description.BackupDatabaseBeforeChanges', "Backups the database before deploying any changes.");
export const descriptionAllowIncompatiblePlatform: string = localize('SchemaCompare.Description.AllowIncompatiblePlatform', "Specifies whether to attempt the action despite incompatible SQL Server platforms.");
export const descriptionAllowDropBlockingAssemblies: string = localize('SchemaCompare.Description.AllowDropBlockingAssemblies', "This property is used by SqlClr deployment to cause any blocking assemblies to be dropped as part of the deployment plan. By default, any blocking/referencing assemblies will block an assembly update if the referencing assembly needs to be dropped.");
export const descriptionDropConstraintsNotInSource: string = localize('SchemaCompare.Description.DropConstraintsNotInSource', "Specifies whether constraints that do not exist in the database snapshot (.dacpac) file will be dropped from the target database when you publish to a database.");
export const descriptionDropDmlTriggersNotInSource: string = localize('SchemaCompare.Description.DropDmlTriggersNotInSource', "Specifies whether DML triggers that do not exist in the database snapshot (.dacpac) file will be dropped from the target database when you publish to a database.");
export const descriptionDropExtendedPropertiesNotInSource: string = localize('SchemaCompare.Description.DropExtendedPropertiesNotInSource', "Specifies whether extended properties that do not exist in the database snapshot (.dacpac) file will be dropped from the target database when you publish to a database.");
export const descriptionDropIndexesNotInSource: string = localize('SchemaCompare.Description.DropIndexesNotInSource', "Specifies whether indexes that do not exist in the database snapshot (.dacpac) file will be dropped from the target database when you publish to a database.");
export const descriptionIgnoreFileAndLogFilePath: string = localize('SchemaCompare.Description.IgnoreFileAndLogFilePath', "Specifies whether differences in the paths for files and log files should be ignored or updated when you publish to a database.");
export const descriptionIgnoreExtendedProperties: string = localize('SchemaCompare.Description.IgnoreExtendedProperties', "Specifies whether extended properties should be ignored.");
export const descriptionIgnoreDmlTriggerState: string = localize('SchemaCompare.Description.IgnoreDmlTriggerState', "Specifies whether differences in the enabled or disabled state of DML triggers should be ignored or updated when you publish to a database.");
export const descriptionIgnoreDmlTriggerOrder: string = localize('SchemaCompare.Description.IgnoreDmlTriggerOrder', "Specifies whether differences in the order of Data Manipulation Language (DML) triggers should be ignored or updated when you publish to a database.");
export const descriptionIgnoreDefaultSchema: string = localize('SchemaCompare.Description.IgnoreDefaultSchema', "Specifies whether differences in the default schema should be ignored or updated when you publish to a database.");
export const descriptionIgnoreDdlTriggerState: string = localize('SchemaCompare.Description.IgnoreDdlTriggerState', "Specifies whether differences in the enabled or disabled state of Data Definition Language (DDL) triggers should be ignored or updated when you publish to a database.");
export const descriptionIgnoreDdlTriggerOrder: string = localize('SchemaCompare.Description.IgnoreDdlTriggerOrder', "Specifies whether differences in the order of Data Definition Language (DDL) triggers should be ignored or updated when you publish to a database or server.");
export const descriptionIgnoreCryptographicProviderFilePath: string = localize('SchemaCompare.Description.IgnoreCryptographicProviderFilePath', "Specifies whether differences in the file path for the cryptographic provider should be ignored or updated when you publish to a database.");
export const descriptionVerifyDeployment: string = localize('SchemaCompare.Description.VerifyDeployment', "Specifies whether checks should be performed before publishing that will stop the publish action if issues are present that might block successful publishing. For example, your publish action might stop if you have foreign keys on the target database that do not exist in the database project, and that will cause errors when you publish.");
export const descriptionIgnoreComments: string = localize('SchemaCompare.Description.IgnoreComments', "Specifies whether differences in the comments should be ignored or updated when you publish to a database.");
export const descriptionIgnoreColumnCollation: string = localize('SchemaCompare.Description.IgnoreColumnCollation', "Specifies whether differences in the column collations should be ignored or updated when you publish to a database.");
export const descriptionIgnoreAuthorizer: string = localize('SchemaCompare.Description.IgnoreAuthorizer', "Specifies whether differences in the Authorizer should be ignored or updated when you publish to a database.");
export const descriptionIgnoreAnsiNulls: string = localize('SchemaCompare.Description.IgnoreAnsiNulls', "Specifies whether differences in the ANSI NULLS setting should be ignored or updated when you publish to a database.");
export const descriptionGenerateSmartDefaults: string = localize('SchemaCompare.Description.GenerateSmartDefaults', "Automatically provides a default value when updating a table that contains data with a column that does not allow null values.");
export const descriptionDropStatisticsNotInSource: string = localize('SchemaCompare.Description.DropStatisticsNotInSource', "Specifies whether statistics that do not exist in the database snapshot (.dacpac) file will be dropped from the target database when you publish to a database.");
export const descriptionDropRoleMembersNotInSource: string = localize('SchemaCompare.Description.DropRoleMembersNotInSource', "Specifies whether role members that are not defined in the database snapshot (.dacpac) file will be dropped from the target database when you publish updates to a database.</");
export const descriptionDropPermissionsNotInSource: string = localize('SchemaCompare.Description.DropPermissionsNotInSource', "Specifies whether permissions that do not exist in the database snapshot (.dacpac) file will be dropped from the target database when you publish updates to a database.");
export const descriptionDropObjectsNotInSource: string = localize('SchemaCompare.Description.DropObjectsNotInSource', "Specifies whether objects that do not exist in the database snapshot (.dacpac) file will be dropped from the target database when you publish to a database.  This value takes precedence over DropExtendedProperties.");
export const descriptionIgnoreColumnOrder: string = localize('SchemaCompare.Description.IgnoreColumnOrder', "Specifies whether differences in table column order should be ignored or updated when you publish to a database.");


// Error messages
export function compareErrorMessage(errorMessage: string): string { return localize('schemaCompare.compareErrorMessage', "Schema Compare failed: {0}", errorMessage ? errorMessage : 'Unknown'); }
export function saveScmpErrorMessage(errorMessage: string): string { return localize('schemaCompare.saveScmpErrorMessage', "Save scmp failed: '{0}'", (errorMessage) ? errorMessage : 'Unknown'); }
export function cancelErrorMessage(errorMessage: string): string { return localize('schemaCompare.cancelErrorMessage', "Cancel schema compare failed: '{0}'", (errorMessage) ? errorMessage : 'Unknown'); }
export function generateScriptErrorMessage(errorMessage: string): string { return localize('schemaCompare.generateScriptErrorMessage', "Generate script failed: '{0}'", (errorMessage) ? errorMessage : 'Unknown'); }
export function applyErrorMessage(errorMessage: string): string { return localize('schemaCompare.updateErrorMessage', "Schema Compare Apply failed '{0}'", errorMessage ? errorMessage : 'Unknown'); }
export function openScmpErrorMessage(errorMessage: string): string { return localize('schemaCompare.openScmpErrorMessage', "Open scmp failed: '{0}'", (errorMessage) ? errorMessage : 'Unknown'); }
